/*
|
* Copyright (c) 2010-2020 Belledonne Communications SARL.
|
*
|
* This file is part of linphone-iphone
|
*
|
* This program is free software: you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation, either version 3 of the License, or
|
* (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
|
#import "UICompositeView.h"
|
|
#import "LinphoneAppDelegate.h"
|
#import "Utils.h"
|
#import "SideMenuView.h"
|
|
@implementation UICompositeViewDescription
|
|
- (id)copy {
|
UICompositeViewDescription *copy = [UICompositeViewDescription alloc];
|
copy.name = self.name;
|
copy.statusBar = self.statusBar;
|
copy.tabBar = self.tabBar;
|
copy.sideMenu = self.sideMenu;
|
copy.statusBarEnabled = self.statusBarEnabled;
|
copy.tabBarEnabled = self.tabBarEnabled;
|
copy.sideMenuEnabled = self.sideMenuEnabled;
|
copy.fullscreen = self.fullscreen;
|
copy.landscapeMode = self.landscapeMode;
|
copy.portraitMode = self.portraitMode;
|
copy.isLeftFragment = self.isLeftFragment;
|
copy.otherFragment = self.otherFragment;
|
copy.darkBackground = self.darkBackground;
|
return copy;
|
}
|
|
- (BOOL)equal:(UICompositeViewDescription *)description {
|
return [self.name compare:description.name] == NSOrderedSame;
|
}
|
|
- (id)init:(Class)content
|
statusBar:(Class)statusBar
|
tabBar:(Class)tabBar
|
sideMenu:(Class)sideMenu
|
fullscreen:(BOOL)fullscreen
|
isLeftFragment:(BOOL)isLeftFragment
|
fragmentWith:(Class)otherFragment {
|
self.name = NSStringFromClass(content);
|
self.statusBar = NSStringFromClass(statusBar);
|
self.tabBar = NSStringFromClass(tabBar);
|
self.sideMenu = NSStringFromClass(sideMenu);
|
self.statusBarEnabled = YES;
|
self.tabBarEnabled = YES;
|
self.sideMenuEnabled = NO;
|
self.fullscreen = fullscreen;
|
self.landscapeMode = YES;
|
self.portraitMode = YES;
|
self.otherFragment = IPAD ? NSStringFromClass(otherFragment) : nil;
|
self.isLeftFragment = isLeftFragment || (self.otherFragment == nil);
|
self.darkBackground = true;
|
|
return self;
|
}
|
|
@end
|
@interface UICompositeView ()
|
|
@property(nonatomic, strong) UIViewController *statusBarViewController;
|
@property(nonatomic, strong) UIViewController *tabBarViewController;
|
@property(nonatomic, strong) UIViewController *mainViewController;
|
@property(nonatomic, strong) UIViewController *detailsViewController;
|
@property(nonatomic, strong) UIViewController *sideMenuViewController;
|
|
@end
|
|
@implementation UICompositeView
|
|
#pragma mark - Lifecycle Functions
|
|
- (void)initUICompositeView {
|
viewControllerCache = [[NSMutableDictionary alloc] init];
|
currentOrientation = (UIInterfaceOrientation)UIDeviceOrientationUnknown;
|
}
|
|
- (id)init {
|
self = [super init];
|
if (self) {
|
[self initUICompositeView];
|
}
|
return self;
|
}
|
|
- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil {
|
self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
|
if (self) {
|
[self initUICompositeView];
|
}
|
return self;
|
}
|
|
- (id)initWithCoder:(NSCoder *)decoder {
|
self = [super initWithCoder:decoder];
|
if (self) {
|
[self initUICompositeView];
|
}
|
return self;
|
}
|
|
- (void)dealloc {
|
[NSNotificationCenter.defaultCenter removeObserver:self];
|
}
|
|
#pragma mark - ViewController Functions
|
|
- (void)updateViewsFramesAccordingToLaunchOrientation {
|
CGRect frame =
|
[self.view frame]; // this view has the correct size at launch (1024/768 for iPad, 320*{568,480} for iPhone)
|
UIInterfaceOrientation orientation = [UIApplication sharedApplication].statusBarOrientation;
|
BOOL portrait = UIInterfaceOrientationIsPortrait(orientation);
|
CGRect oppositeFrame = frame;
|
oppositeFrame.size.height = frame.size.width;
|
oppositeFrame.size.width = frame.size.height;
|
|
// if we start in portrait, the landscape view must get the opposite height and width
|
if (portrait || [[UIDevice currentDevice].systemVersion floatValue] < 8) {
|
LOGI(@"landscape get opposite: %@", NSStringFromCGSize(oppositeFrame.size));
|
[landscapeView setFrame:oppositeFrame];
|
} else {
|
// if we start in landscape, the landscape view has to get the current size,
|
// whereas the portrait has to get the opposite
|
LOGI(@"landscape get frame: %@ and portrait gets opposite: %@", NSStringFromCGSize(frame.size),
|
NSStringFromCGSize(oppositeFrame.size));
|
[landscapeView setFrame:frame];
|
[portraitView setFrame:oppositeFrame];
|
}
|
}
|
|
- (void)viewDidLoad {
|
/* Force landscape view to match portrait view, because portrait view inherits
|
the device screen size at load */
|
[self updateViewsFramesAccordingToLaunchOrientation];
|
[super viewDidLoad];
|
NSArray * arr =[[NSBundle mainBundle] loadNibNamed:@"LaunchScreen" owner:nil options:nil];
|
LaunchScreen * customView = [arr firstObject];
|
customView.frame = self.view.frame;
|
customView.tag = 999;
|
[self.view addSubview:customView];
|
}
|
|
- (void)viewWillAppear:(BOOL)animated {
|
[super viewWillAppear:animated];
|
[[UIDevice currentDevice] beginGeneratingDeviceOrientationNotifications];
|
[self.mainViewController viewWillAppear:animated];
|
[self.detailsViewController viewWillAppear:animated];
|
[self.tabBarViewController viewWillAppear:animated];
|
[self.statusBarViewController viewWillAppear:animated];
|
[self.sideMenuViewController viewWillAppear:animated];
|
[NSNotificationCenter.defaultCenter addObserver:self
|
selector:@selector(orientationDidChange:)
|
name:UIDeviceOrientationDidChangeNotification
|
object:nil];
|
}
|
|
- (void)viewDidAppear:(BOOL)animated {
|
[super viewDidAppear:animated];
|
[self.mainViewController viewDidAppear:animated];
|
[self.detailsViewController viewDidAppear:animated];
|
[self.tabBarViewController viewDidAppear:animated];
|
[self.statusBarViewController viewDidAppear:animated];
|
[self.sideMenuViewController viewDidAppear:animated];
|
}
|
|
- (void)viewWillDisappear:(BOOL)animated {
|
[self.mainViewController viewWillDisappear:animated];
|
[self.detailsViewController viewWillDisappear:animated];
|
[self.tabBarViewController viewWillDisappear:animated];
|
[self.statusBarViewController viewWillDisappear:animated];
|
[self.sideMenuViewController viewWillDisappear:animated];
|
[NSNotificationCenter.defaultCenter removeObserver:self name:UIDeviceOrientationDidChangeNotification object:nil];
|
[[UIDevice currentDevice] endGeneratingDeviceOrientationNotifications];
|
[super viewWillDisappear:animated];
|
}
|
|
- (void)viewDidDisappear:(BOOL)animated {
|
[self.mainViewController viewDidDisappear:animated];
|
[self.detailsViewController viewDidDisappear:animated];
|
[self.tabBarViewController viewDidDisappear:animated];
|
[self.statusBarViewController viewDidDisappear:animated];
|
[self.sideMenuViewController viewDidDisappear:animated];
|
[super viewDidDisappear:animated];
|
}
|
|
#pragma mark - Rotation messages
|
|
- (void)willRotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation
|
duration:(NSTimeInterval)duration {
|
currentOrientation = toInterfaceOrientation;
|
[super willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
[self.mainViewController willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
[self.detailsViewController willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
[self.tabBarViewController willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
[self.statusBarViewController willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
[self.sideMenuViewController willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
}
|
|
- (void)willAnimateRotationToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation
|
duration:(NSTimeInterval)duration {
|
[super willAnimateRotationToInterfaceOrientation:toInterfaceOrientation
|
duration:duration]; // Will invoke TPMultiLayout
|
[self.mainViewController willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
[self.detailsViewController willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
[self.tabBarViewController willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
[self.statusBarViewController willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
[self.sideMenuViewController willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
[self update:nil tabBar:nil statusBar:nil sideMenu:nil fullscreen:nil];
|
}
|
|
- (void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)fromInterfaceOrientation {
|
[super didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
[self.mainViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
[self.detailsViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
[self.tabBarViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
[self.statusBarViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
[self.sideMenuViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
}
|
|
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
|
if (interfaceOrientation == currentOrientation)
|
return YES;
|
return NO;
|
}
|
|
#pragma mark - Event Functions
|
|
- (void)orientationDidChange:(NSNotification *)notif {
|
@try {
|
// Update rotation
|
UIInterfaceOrientation correctOrientation =
|
[self getCorrectInterfaceOrientation:[[UIDevice currentDevice] orientation]];
|
if (currentOrientation != correctOrientation) {
|
[UICompositeView setOrientation:correctOrientation
|
animated:currentOrientation != UIDeviceOrientationUnknown];
|
}
|
} @catch (NSException *exception) {
|
// There are some crashes reports from iTunes connect because Linphone core is
|
// not ready yet - whatever the reason is, we can safely ignore the exception
|
LOGE(@"Exception: %@, ignoring", exception);
|
}
|
}
|
|
#pragma mark -
|
|
/*
|
Will simulate a device rotation
|
*/
|
+ (void)setOrientation:(UIInterfaceOrientation)orientation animated:(BOOL)animated {
|
UIView *firstResponder = nil;
|
|
UIViewController *controller = nil;
|
|
controller = [[UIApplication sharedApplication] keyWindow].rootViewController;
|
CGRect frame = [[UIScreen mainScreen] bounds];
|
UIInterfaceOrientation oldOrientation = controller.interfaceOrientation;
|
|
NSTimeInterval animationDuration = animated ? 0.3f : 0.0;
|
|
[controller willRotateToInterfaceOrientation:orientation duration:animationDuration];
|
[controller willAnimateRotationToInterfaceOrientation:orientation duration:animationDuration];
|
[controller didRotateFromInterfaceOrientation:oldOrientation];
|
[UIView animateWithDuration:animationDuration
|
animations:^{
|
[controller.view setFrame:frame];
|
}];
|
|
if (firstResponder == nil) {
|
firstResponder = [UICompositeView findFirstResponder:controller.view];
|
}
|
|
[[UIApplication sharedApplication] setStatusBarOrientation:orientation animated:animated];
|
if (firstResponder) {
|
[firstResponder resignFirstResponder];
|
[firstResponder becomeFirstResponder];
|
}
|
}
|
|
+ (UIView *)findFirstResponder:(UIView *)view {
|
if (view.isFirstResponder) {
|
return view;
|
}
|
for (UIView *subView in view.subviews) {
|
UIView *ret = [UICompositeView findFirstResponder:subView];
|
if (ret != nil)
|
return ret;
|
}
|
return nil;
|
}
|
|
- (void)clearCache:(NSArray *)exclude {
|
for (NSString *key in [viewControllerCache allKeys]) {
|
bool remove = true;
|
|
/*ImagePickerView can be used as popover and we do NOT want to free it*/;
|
if ([key isEqualToString:ImagePickerView.compositeViewDescription.name]) {
|
remove = false;
|
} else if (exclude != nil) {
|
for (UICompositeViewDescription *description in exclude) {
|
if ([key isEqualToString:description.name] || [key isEqualToString:description.statusBar] ||
|
[key isEqualToString:description.tabBar] || [key isEqualToString:description.sideMenu]) {
|
remove = false;
|
break;
|
}
|
}
|
}
|
if (remove) {
|
LOGI(@"Free cached view: %@", key);
|
[viewControllerCache removeObjectForKey:key];
|
}
|
}
|
}
|
|
- (UIInterfaceOrientation)currentOrientation {
|
return currentOrientation;
|
}
|
|
- (IBAction)onRightSwipe:(id)sender {
|
[self hideSideMenu:NO];
|
}
|
|
+ (void)addSubView:(UIViewController *)controller view:(UIView *)view {
|
if (controller != nil) {
|
[view addSubview:controller.view];
|
}
|
}
|
|
+ (void)removeSubView:(UIViewController *)controller {
|
if (controller != nil) {
|
[controller.view removeFromSuperview];
|
}
|
}
|
|
- (UIViewController *)getCachedController:(NSString *)name {
|
UIViewController *controller = nil;
|
if (name != nil) {
|
controller = [viewControllerCache objectForKey:name];
|
if (controller == nil) {
|
controller = [[NSClassFromString(name) alloc] init];
|
[viewControllerCache setValue:controller forKey:name];
|
[controller view]; // Load the view
|
}
|
}
|
return controller;
|
}
|
|
- (UIInterfaceOrientation)getCorrectInterfaceOrientation:(UIDeviceOrientation)deviceOrientation {
|
if (currentViewDescription != nil) {
|
// If unknown return status bar orientation
|
if (deviceOrientation == UIDeviceOrientationUnknown && currentOrientation == UIDeviceOrientationUnknown) {
|
return [UIApplication sharedApplication].statusBarOrientation;
|
}
|
|
// Don't rotate in UIDeviceOrientationFaceUp UIDeviceOrientationFaceDown
|
if (!UIDeviceOrientationIsPortrait(deviceOrientation) && !UIDeviceOrientationIsLandscape(deviceOrientation)) {
|
if (currentOrientation == UIDeviceOrientationUnknown) {
|
return [UIApplication sharedApplication].statusBarOrientation;
|
}
|
deviceOrientation = (UIDeviceOrientation)currentOrientation;
|
}
|
if (UIDeviceOrientationIsPortrait(deviceOrientation)) {
|
if ([currentViewDescription portraitMode]) {
|
return (UIInterfaceOrientation)deviceOrientation;
|
} else {
|
return UIInterfaceOrientationLandscapeLeft;
|
}
|
}
|
if (UIDeviceOrientationIsLandscape(deviceOrientation)) {
|
if ([currentViewDescription landscapeMode]) {
|
return (UIInterfaceOrientation)deviceOrientation;
|
} else {
|
return UIInterfaceOrientationPortrait;
|
}
|
}
|
}
|
return UIInterfaceOrientationPortrait;
|
}
|
|
- (void)update:(UICompositeViewDescription *)description
|
tabBar:(NSNumber *)tabBar
|
statusBar:(NSNumber *)statusBar
|
sideMenu:(NSNumber *)sideMenu
|
fullscreen:(NSNumber *)fullscreen {
|
|
UIViewController *oldMainViewController = self.mainViewController;
|
UIViewController *oldDetailsViewController = self.detailsViewController;
|
UIViewController *oldStatusBarViewController = self.statusBarViewController;
|
UIViewController *oldTabBarViewController = self.tabBarViewController;
|
UIViewController *oldSideMenuViewController = self.sideMenuViewController;
|
// Copy view description
|
UICompositeViewDescription *oldViewDescription = nil;
|
|
if (description != nil) {
|
oldViewDescription = currentViewDescription;
|
currentViewDescription = [description copy];
|
|
UIViewController *newMainViewController = description.isLeftFragment
|
? [self getCachedController:description.name]
|
: [self getCachedController:description.otherFragment];
|
UIViewController *newDetailsViewController = !description.isLeftFragment
|
? [self getCachedController:description.name]
|
: [self getCachedController:description.otherFragment];
|
UIViewController *newStatusBarViewController = [self getCachedController:description.statusBar];
|
UIViewController *newTabBarViewController = [self getCachedController:description.tabBar];
|
UIViewController *newSideMenuViewController = [self getCachedController:description.sideMenu];
|
|
// Animate only with a previous screen
|
if (oldViewDescription != nil && self.viewTransition != nil) {
|
if (oldMainViewController != newMainViewController) {
|
[self.mainView.layer removeAnimationForKey:@"transition"];
|
[self.mainView.layer addAnimation:self.viewTransition forKey:@"transition"];
|
} else {
|
[self.mainView.layer removeAnimationForKey:@"transition"];
|
}
|
if (oldDetailsViewController != newDetailsViewController) {
|
[self.detailsView.layer removeAnimationForKey:@"transition"];
|
[self.detailsView.layer addAnimation:self.viewTransition forKey:@"transition"];
|
} else {
|
[self.detailsView.layer removeAnimationForKey:@"transition"];
|
}
|
|
if (oldStatusBarViewController != newStatusBarViewController ||
|
oldViewDescription.statusBarEnabled != currentViewDescription.statusBarEnabled) {
|
[self.statusBarView.layer removeAnimationForKey:@"transition"];
|
[self.statusBarView.layer addAnimation:self.viewTransition forKey:@"transition"];
|
} else {
|
[self.statusBarView.layer removeAnimationForKey:@"transition"];
|
}
|
if (oldTabBarViewController != newTabBarViewController ||
|
oldViewDescription.tabBarEnabled != currentViewDescription.tabBarEnabled) {
|
[self.tabBarView.layer removeAnimationForKey:@"transition"];
|
[self.tabBarView.layer addAnimation:self.viewTransition forKey:@"transition"];
|
} else {
|
[self.tabBarView.layer removeAnimationForKey:@"transition"];
|
}
|
if (oldSideMenuViewController != newSideMenuViewController ||
|
oldViewDescription.sideMenuEnabled != currentViewDescription.sideMenuEnabled) {
|
[self.sideMenuView.layer removeAnimationForKey:@"transition"];
|
[self.sideMenuView.layer addAnimation:self.viewTransition forKey:@"transition"];
|
}
|
}
|
|
if (oldMainViewController != nil && oldMainViewController != newMainViewController) {
|
[UICompositeView removeSubView:oldMainViewController];
|
}
|
if (oldDetailsViewController != nil && oldDetailsViewController != newDetailsViewController) {
|
[UICompositeView removeSubView:oldDetailsViewController];
|
}
|
if (oldTabBarViewController != nil && oldTabBarViewController != newTabBarViewController) {
|
[UICompositeView removeSubView:oldTabBarViewController];
|
}
|
if (oldStatusBarViewController != nil && oldStatusBarViewController != newStatusBarViewController) {
|
[UICompositeView removeSubView:oldStatusBarViewController];
|
}
|
if (oldSideMenuViewController != nil && oldSideMenuViewController != newSideMenuViewController) {
|
[UICompositeView removeSubView:oldSideMenuViewController];
|
}
|
|
self.statusBarViewController = newStatusBarViewController;
|
self.mainViewController = newMainViewController;
|
self.detailsViewController = newDetailsViewController;
|
self.tabBarViewController = newTabBarViewController;
|
self.sideMenuViewController = newSideMenuViewController;
|
|
// Update rotation
|
UIInterfaceOrientation correctOrientation = [self
|
getCorrectInterfaceOrientation:(UIDeviceOrientation)[UIApplication sharedApplication].statusBarOrientation];
|
if (currentOrientation != correctOrientation) {
|
[UICompositeView setOrientation:correctOrientation
|
animated:currentOrientation != UIDeviceOrientationUnknown];
|
if (UIInterfaceOrientationIsLandscape(correctOrientation)) {
|
[self.mainViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
[self.detailsViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
[self.tabBarViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
[self.statusBarViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
[self.sideMenuViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
}
|
} else {
|
if (oldMainViewController != newMainViewController) {
|
UIInterfaceOrientation oldOrientation = self.mainViewController.interfaceOrientation;
|
[self.mainViewController willRotateToInterfaceOrientation:correctOrientation duration:0];
|
[self.mainViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
[self.mainViewController didRotateFromInterfaceOrientation:oldOrientation];
|
}
|
if (oldDetailsViewController != newDetailsViewController) {
|
UIInterfaceOrientation oldOrientation = self.detailsViewController.interfaceOrientation;
|
[self.detailsViewController willRotateToInterfaceOrientation:correctOrientation duration:0];
|
[self.detailsViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
[self.detailsViewController didRotateFromInterfaceOrientation:oldOrientation];
|
}
|
if (oldTabBarViewController != newTabBarViewController) {
|
UIInterfaceOrientation oldOrientation = self.tabBarViewController.interfaceOrientation;
|
[self.tabBarViewController willRotateToInterfaceOrientation:correctOrientation duration:0];
|
[self.tabBarViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
[self.tabBarViewController didRotateFromInterfaceOrientation:oldOrientation];
|
}
|
if (oldSideMenuViewController != newSideMenuViewController) {
|
UIInterfaceOrientation oldOrientation = self.sideMenuViewController.interfaceOrientation;
|
[self.sideMenuViewController willRotateToInterfaceOrientation:correctOrientation duration:0];
|
[self.sideMenuViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
[self.sideMenuViewController didRotateFromInterfaceOrientation:oldOrientation];
|
}
|
}
|
}
|
|
if (currentViewDescription == nil) {
|
return;
|
}
|
|
if (tabBar != nil) {
|
if (currentViewDescription.tabBarEnabled != [tabBar boolValue]) {
|
currentViewDescription.tabBarEnabled = [tabBar boolValue];
|
} else {
|
tabBar = nil; // No change = No Update
|
}
|
}
|
|
if (statusBar != nil) {
|
if (currentViewDescription.statusBarEnabled != [statusBar boolValue]) {
|
currentViewDescription.statusBarEnabled = [statusBar boolValue];
|
} else {
|
statusBar = nil; // No change = No Update
|
}
|
}
|
|
if (sideMenu != nil) {
|
if (currentViewDescription.sideMenuEnabled != [sideMenu boolValue]) {
|
currentViewDescription.sideMenuEnabled = [sideMenu boolValue];
|
if (currentViewDescription.sideMenuEnabled) {
|
[_sideMenuViewController viewWillAppear:YES];
|
} else {
|
[_sideMenuViewController viewWillDisappear:YES];
|
}
|
} else {
|
sideMenu = nil; // No change = No Update
|
}
|
}
|
|
if (fullscreen != nil) {
|
if (currentViewDescription.fullscreen != [fullscreen boolValue]) {
|
currentViewDescription.fullscreen = [fullscreen boolValue];
|
[[UIApplication sharedApplication] setStatusBarHidden:currentViewDescription.fullscreen
|
withAnimation:UIStatusBarAnimationSlide];
|
} else {
|
fullscreen = nil; // No change = No Update
|
}
|
} else {
|
[[UIApplication sharedApplication] setStatusBarHidden:currentViewDescription.fullscreen
|
withAnimation:UIStatusBarAnimationNone];
|
}
|
|
// Start animation
|
if (tabBar != nil || statusBar != nil || sideMenu != nil || fullscreen != nil) {
|
[UIView beginAnimations:@"resize" context:nil];
|
[UIView setAnimationDuration:0.35];
|
}
|
|
// Compute frame for each elements
|
CGRect viewFrame = self.view.frame;
|
int origin = currentViewDescription.fullscreen ? 0 : [PhoneMainView iphoneStatusBarHeight];
|
|
|
// 1. status bar - fixed size on top
|
CGRect statusBarFrame = self.statusBarView.frame;
|
if (self.statusBarViewController != nil && currentViewDescription.statusBarEnabled) {
|
statusBarFrame.origin.y = origin;
|
// move origin below status bar
|
origin += statusBarFrame.size.height;
|
} else {
|
statusBarFrame.origin.y = -statusBarFrame.size.height;
|
}
|
|
// 2. side menu - fixed size, always starting below status bar (hack: except in fullscreen)
|
CGRect sideMenuFrame = viewFrame;
|
sideMenuFrame.origin.y = origin - (currentViewDescription.fullscreen ? statusBarFrame.size.height : 0);
|
sideMenuFrame.size.height -= sideMenuFrame.origin.y;
|
if (!currentViewDescription.sideMenuEnabled) {
|
// hack bis: really hide; -width won't be enough since some animations may use this...
|
sideMenuFrame.origin.x = -3 * sideMenuFrame.size.width;
|
}
|
|
// 3. tab bar - on portrait full width at bottom / on landscape on left, starting below status bar
|
// Resize TabBar
|
CGRect tabFrame = self.tabBarView.frame;
|
if (self.tabBarViewController != nil && currentViewDescription.tabBarEnabled) {
|
tabFrame.origin.x = 0;
|
if (UIInterfaceOrientationIsPortrait([self currentOrientation])) {
|
tabFrame.origin.y = viewFrame.size.height - tabFrame.size.height;
|
} else {
|
tabFrame.origin.y = origin;
|
tabFrame.size.height = viewFrame.size.height - tabFrame.origin.y;
|
}
|
} else {
|
tabFrame.origin.x = -tabFrame.size.width;
|
tabFrame.origin.y = viewFrame.size.height;
|
}
|
|
// 4. main view and details view - space left width of 35%/65% each
|
CGRect mainFrame = viewFrame;
|
mainFrame.origin.y = origin;
|
mainFrame.size.height -= mainFrame.origin.y;
|
if (!currentViewDescription.fullscreen) {
|
if (UIInterfaceOrientationIsPortrait([self currentOrientation])) {
|
mainFrame.size.height -= viewFrame.size.height - tabFrame.origin.y;
|
} else {
|
mainFrame.origin.x = tabFrame.origin.x + tabFrame.size.width;
|
mainFrame.size.width -= mainFrame.origin.x;
|
}
|
}
|
CGRect detailsFrame = mainFrame;
|
if (self.detailsViewController != nil) {
|
detailsFrame = mainFrame;
|
mainFrame.size.width = ceil(mainFrame.size.width * .35);
|
detailsFrame.size.width -= mainFrame.size.width;
|
detailsFrame.origin.x += mainFrame.size.width;
|
}
|
|
// Set frames
|
// 1. main view and details view
|
self.mainView.frame = mainFrame;
|
self.mainViewController.view.frame = self.mainView.bounds;
|
self.detailsView.frame = detailsFrame;
|
self.detailsViewController.view.frame = self.detailsView.bounds;
|
|
// 2. tab bar
|
self.tabBarView.frame = tabFrame;
|
CGRect frame = self.tabBarViewController.view.frame;
|
frame.size = self.tabBarView.bounds.size;
|
self.tabBarViewController.view.frame = frame;
|
|
// 3. status bar
|
self.statusBarView.frame = statusBarFrame;
|
frame = self.statusBarViewController.view.frame;
|
frame.size = self.statusBarView.bounds.size;
|
self.statusBarViewController.view.frame = frame;
|
|
// 4. side menu
|
self.sideMenuView.frame = sideMenuFrame;
|
self.sideMenuViewController.view.frame = self.sideMenuView.bounds;
|
|
// Commit animation
|
if (tabBar != nil || statusBar != nil || sideMenu != nil || fullscreen != nil) {
|
[UIView commitAnimations];
|
}
|
|
// Change view
|
if (description != nil) {
|
if (oldMainViewController == nil || oldMainViewController != self.tabBarViewController) {
|
[UICompositeView addSubView:self.mainViewController view:self.mainView];
|
}
|
if (oldDetailsViewController == nil || oldDetailsViewController != self.detailsViewController) {
|
[UICompositeView addSubView:self.detailsViewController view:self.detailsView];
|
}
|
if (oldTabBarViewController == nil || oldTabBarViewController != self.tabBarViewController) {
|
[UICompositeView addSubView:self.tabBarViewController view:self.tabBarView];
|
}
|
if (oldStatusBarViewController == nil || oldStatusBarViewController != self.statusBarViewController) {
|
[UICompositeView addSubView:self.statusBarViewController view:self.statusBarView];
|
}
|
if (oldSideMenuViewController == nil || oldSideMenuViewController != self.sideMenuViewController) {
|
[UICompositeView addSubView:self.sideMenuViewController view:self.sideMenuView];
|
}
|
}
|
if (currentViewDescription.sideMenuEnabled) {
|
[_sideMenuViewController viewDidAppear:YES];
|
} else {
|
[_sideMenuViewController viewDidDisappear:YES];
|
}
|
// Dealloc old view description
|
UIView *viewToRemove = [self.view viewWithTag:999];
|
[viewToRemove removeFromSuperview];
|
}
|
|
- (void)changeView:(UICompositeViewDescription *)description {
|
[self view]; // Force view load
|
[self update:description tabBar:nil statusBar:nil sideMenu:nil fullscreen:nil];
|
}
|
|
- (void)setFullscreen:(BOOL)enabled {
|
[self update:nil tabBar:nil statusBar:nil sideMenu:nil fullscreen:[NSNumber numberWithBool:enabled]];
|
}
|
|
- (void)hideTabBar:(BOOL)hidden {
|
[self update:nil tabBar:[NSNumber numberWithBool:!hidden] statusBar:nil sideMenu:nil fullscreen:nil];
|
}
|
|
- (void)hideStatusBar:(BOOL)hidden {
|
[self update:nil tabBar:nil statusBar:[NSNumber numberWithBool:!hidden] sideMenu:nil fullscreen:nil];
|
}
|
|
- (void)hideSideMenu:(BOOL)hidden {
|
[self update:nil tabBar:nil statusBar:nil sideMenu:[NSNumber numberWithBool:!hidden] fullscreen:nil];
|
}
|
- (UIViewController *)getCurrentViewController {
|
return self.mainViewController;
|
}
|
|
- (BOOL)currentViewSupportsLandscape {
|
return currentViewDescription ? currentViewDescription.landscapeMode : FALSE;
|
}
|
|
@end
|
