mirror of
https://gitlab.linphone.org/BC/public/linphone-iphone.git
synced 2026-01-17 11:08:06 +00:00
680 lines
27 KiB
Objective-C
680 lines
27 KiB
Objective-C
/* UICompositeViewController.m
|
|
*
|
|
* Copyright (C) 2012 Belledonne Comunications, Grenoble, France
|
|
*
|
|
* 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 2 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 Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#import "UICompositeViewController.h"
|
|
|
|
#import "LinphoneAppDelegate.h"
|
|
|
|
@implementation UICompositeViewDescription
|
|
|
|
@synthesize name;
|
|
@synthesize content;
|
|
@synthesize stateBar;
|
|
@synthesize stateBarEnabled;
|
|
@synthesize tabBar;
|
|
@synthesize tabBarEnabled;
|
|
@synthesize fullscreen;
|
|
@synthesize landscapeMode;
|
|
@synthesize portraitMode;
|
|
|
|
- (id)copy {
|
|
UICompositeViewDescription *copy = [UICompositeViewDescription alloc];
|
|
copy.content = self.content;
|
|
copy.stateBar = self.stateBar;
|
|
copy.stateBarEnabled = self.stateBarEnabled;
|
|
copy.tabBar = self.tabBar;
|
|
copy.tabBarEnabled = self.tabBarEnabled;
|
|
copy.fullscreen = self.fullscreen;
|
|
copy.landscapeMode = self.landscapeMode;
|
|
copy.portraitMode = self.portraitMode;
|
|
return copy;
|
|
}
|
|
|
|
- (BOOL)equal:(UICompositeViewDescription*) description {
|
|
return [self.name compare:description.name] == NSOrderedSame;
|
|
}
|
|
|
|
- (id)init:(NSString *)aname content:(NSString *)acontent stateBar:(NSString*)astateBar
|
|
stateBarEnabled:(BOOL) astateBarEnabled
|
|
tabBar:(NSString*)atabBar
|
|
tabBarEnabled:(BOOL) atabBarEnabled
|
|
fullscreen:(BOOL) afullscreen
|
|
landscapeMode:(BOOL) alandscapeMode
|
|
portraitMode:(BOOL) aportraitMode {
|
|
self.name = aname;
|
|
self.content = acontent;
|
|
self.stateBar = astateBar;
|
|
self.stateBarEnabled = astateBarEnabled;
|
|
self.tabBar = atabBar;
|
|
self.tabBarEnabled = atabBarEnabled;
|
|
self.fullscreen = afullscreen;
|
|
self.landscapeMode = alandscapeMode;
|
|
self.portraitMode = aportraitMode;
|
|
|
|
return self;
|
|
}
|
|
|
|
- (void)dealloc {
|
|
[name release];
|
|
[content release];
|
|
[stateBar release];
|
|
[tabBar release];
|
|
[super dealloc];
|
|
}
|
|
|
|
@end
|
|
@interface UICompositeViewController ()
|
|
|
|
@property (nonatomic, retain) UIViewController *stateBarViewController;
|
|
@property (nonatomic, retain) UIViewController *tabBarViewController;
|
|
@property (nonatomic, retain) UIViewController *contentViewController;
|
|
|
|
@end
|
|
|
|
@implementation UICompositeViewController
|
|
|
|
@synthesize stateBarView;
|
|
@synthesize contentView;
|
|
@synthesize tabBarView;
|
|
@synthesize tabBarViewController = _tabBarViewController;
|
|
@synthesize stateBarViewController = _stateBarViewController;
|
|
@synthesize contentViewController = _contentViewController;
|
|
|
|
@synthesize viewTransition;
|
|
|
|
|
|
#pragma mark - Lifecycle Functions
|
|
|
|
- (void)initUICompositeViewController {
|
|
viewControllerCache = [[NSMutableDictionary alloc] init];
|
|
currentOrientation = UIDeviceOrientationUnknown;
|
|
}
|
|
|
|
- (id)init{
|
|
self = [super init];
|
|
if (self) {
|
|
[self initUICompositeViewController];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil {
|
|
self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
|
|
if (self) {
|
|
[self initUICompositeViewController];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (id)initWithCoder:(NSCoder *)decoder {
|
|
self = [super initWithCoder:decoder];
|
|
if (self) {
|
|
[self initUICompositeViewController];
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (void)dealloc {
|
|
[[NSNotificationCenter defaultCenter] removeObserver:self];
|
|
|
|
[self.stateBarViewController release];
|
|
[self.tabBarViewController release];
|
|
[self.contentViewController release];
|
|
|
|
[contentView release];
|
|
[stateBarView release];
|
|
[tabBarView release];
|
|
[viewControllerCache release];
|
|
[viewTransition release];
|
|
[currentViewDescription release];
|
|
|
|
[super dealloc];
|
|
}
|
|
|
|
|
|
#pragma mark - Property Functions
|
|
|
|
- (UIViewController*)stateBarViewController {
|
|
return _stateBarViewController;
|
|
}
|
|
|
|
- (UIViewController*)contentViewController {
|
|
return _contentViewController;
|
|
}
|
|
|
|
- (UIViewController*)tabBarViewController {
|
|
return _tabBarViewController;
|
|
}
|
|
|
|
|
|
#pragma mark - ViewController Functions
|
|
|
|
- (void)viewDidLoad {
|
|
/* Force landscape view to match portrait view */
|
|
CGRect frame = [portraitView frame];
|
|
int height = frame.size.width;
|
|
frame.size.width = frame.size.height;
|
|
frame.size.height = height;
|
|
[landscapeView setFrame:frame];
|
|
[super viewDidLoad];
|
|
}
|
|
|
|
- (void)viewWillAppear:(BOOL)animated {
|
|
[super viewWillAppear:animated];
|
|
[self.contentViewController viewWillAppear:animated];
|
|
[self.tabBarViewController viewWillAppear:animated];
|
|
[self.stateBarViewController viewWillAppear:animated];
|
|
|
|
[[NSNotificationCenter defaultCenter] addObserver:self
|
|
selector:@selector(orientationDidChange:)
|
|
name:UIDeviceOrientationDidChangeNotification
|
|
object:nil];
|
|
[[UIDevice currentDevice] beginGeneratingDeviceOrientationNotifications];
|
|
}
|
|
|
|
- (void)viewDidAppear:(BOOL)animated {
|
|
[super viewDidAppear:animated];
|
|
[self.contentViewController viewDidAppear:animated];
|
|
[self.tabBarViewController viewDidAppear:animated];
|
|
[self.stateBarViewController viewDidAppear:animated];
|
|
}
|
|
|
|
- (void)viewWillDisappear:(BOOL)animated {
|
|
[super viewWillDisappear:animated];
|
|
[self.contentViewController viewWillDisappear:animated];
|
|
[self.tabBarViewController viewWillDisappear:animated];
|
|
[self.stateBarViewController viewWillDisappear:animated];
|
|
|
|
[[UIDevice currentDevice] endGeneratingDeviceOrientationNotifications];
|
|
|
|
[[NSNotificationCenter defaultCenter] removeObserver:self
|
|
name:UIDeviceOrientationDidChangeNotification
|
|
object:nil];
|
|
}
|
|
|
|
- (void)viewDidDisappear:(BOOL)animated {
|
|
[super viewDidDisappear:animated];
|
|
[self.contentViewController viewDidDisappear:animated];
|
|
[self.tabBarViewController viewDidDisappear:animated];
|
|
[self.stateBarViewController viewDidDisappear:animated];
|
|
}
|
|
|
|
- (void)willRotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation duration:(NSTimeInterval)duration {
|
|
currentOrientation = toInterfaceOrientation;
|
|
[super willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
|
[self.contentViewController willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
|
[self.tabBarViewController willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
|
[self.stateBarViewController willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
|
}
|
|
|
|
- (void)willAnimateRotationToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation duration:(NSTimeInterval)duration {
|
|
[super willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
|
[self.contentViewController willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
|
[self.tabBarViewController willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
|
[self.stateBarViewController willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
|
[self update:nil tabBar:nil stateBar:nil fullscreen:nil];
|
|
}
|
|
|
|
- (void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)fromInterfaceOrientation {
|
|
[super didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
|
[self.contentViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
|
[self.tabBarViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
|
[self.stateBarViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
|
}
|
|
|
|
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation {
|
|
if(interfaceOrientation == currentOrientation)
|
|
return YES;
|
|
return NO;
|
|
}
|
|
|
|
|
|
#pragma mark - Event Functions
|
|
|
|
- (void)orientationDidChange:(NSNotification*)notif {
|
|
if([LinphoneManager isLcReady]) {
|
|
// Update rotation
|
|
UIInterfaceOrientation correctOrientation = [self getCorrectInterfaceOrientation:[[UIDevice currentDevice] orientation]];
|
|
if(currentOrientation != correctOrientation) {
|
|
[UICompositeViewController setOrientation:correctOrientation animated:currentOrientation != UIDeviceOrientationUnknown];
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
/*
|
|
Will simulate a device rotation
|
|
*/
|
|
+ (void)setOrientation:(UIInterfaceOrientation)orientation animated:(BOOL)animated {
|
|
UIView *firstResponder = nil;
|
|
for(UIWindow *window in [[UIApplication sharedApplication] windows]) {
|
|
if([NSStringFromClass(window.class) isEqualToString:@"UITextEffectsWindow"] ||
|
|
[NSStringFromClass(window.class) isEqualToString:@"_UIAlertOverlayWindow"] ) {
|
|
continue;
|
|
}
|
|
UIView *view = window;
|
|
UIViewController *controller = nil;
|
|
CGRect frame = [view frame];
|
|
if([window isKindOfClass:[UILinphoneWindow class]]) {
|
|
controller = window.rootViewController;
|
|
view = controller.view;
|
|
}
|
|
UIInterfaceOrientation oldOrientation = controller.interfaceOrientation;
|
|
|
|
NSTimeInterval animationDuration = 0.0;
|
|
if(animated) {
|
|
animationDuration = 0.3f;
|
|
}
|
|
[controller willRotateToInterfaceOrientation:orientation duration:animationDuration];
|
|
if(animated) {
|
|
[UIView beginAnimations:nil context:nil];
|
|
[UIView setAnimationDuration:animationDuration];
|
|
}
|
|
switch (orientation) {
|
|
case UIInterfaceOrientationPortrait:
|
|
[view setTransform: CGAffineTransformMakeRotation(0)];
|
|
break;
|
|
case UIInterfaceOrientationPortraitUpsideDown:
|
|
[view setTransform: CGAffineTransformMakeRotation(M_PI)];
|
|
break;
|
|
case UIInterfaceOrientationLandscapeLeft:
|
|
[view setTransform: CGAffineTransformMakeRotation(-M_PI / 2)];
|
|
break;
|
|
case UIInterfaceOrientationLandscapeRight:
|
|
[view setTransform: CGAffineTransformMakeRotation(M_PI / 2)];
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if([window isKindOfClass:[UILinphoneWindow class]]) {
|
|
[view setFrame:frame];
|
|
}
|
|
[controller willAnimateRotationToInterfaceOrientation:orientation duration:animationDuration];
|
|
if(animated) {
|
|
[UIView commitAnimations];
|
|
}
|
|
[controller didRotateFromInterfaceOrientation:oldOrientation];
|
|
if(firstResponder == nil) {
|
|
firstResponder = [UICompositeViewController findFirstResponder: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 = [UICompositeViewController findFirstResponder:subView];
|
|
if (ret != nil)
|
|
return ret;
|
|
}
|
|
return nil;
|
|
}
|
|
|
|
- (void)clearCache:(NSArray *)exclude {
|
|
for(NSString *key in [viewControllerCache allKeys]) {
|
|
bool remove = true;
|
|
if(exclude != nil) {
|
|
for (UICompositeViewDescription *description in exclude) {
|
|
if([key isEqualToString:description.content] ||
|
|
[key isEqualToString:description.stateBar] ||
|
|
[key isEqualToString:description.tabBar]
|
|
) {
|
|
remove = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(remove) {
|
|
[LinphoneLogger log:LinphoneLoggerLog format:@"Free cached view: %@", key];
|
|
UIViewController *vc = [viewControllerCache objectForKey:key];
|
|
if ([[UIDevice currentDevice].systemVersion doubleValue] >= 5.0) {
|
|
[vc viewWillUnload];
|
|
}
|
|
[vc viewDidUnload];
|
|
[viewControllerCache removeObjectForKey:key];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (UIInterfaceOrientation)currentOrientation {
|
|
return currentOrientation;
|
|
}
|
|
|
|
+ (void)addSubView:(UIViewController*)controller view:(UIView*)view {
|
|
if(controller != nil) {
|
|
if ([[UIDevice currentDevice].systemVersion doubleValue] < 5.0) {
|
|
[controller viewWillAppear:NO];
|
|
}
|
|
[view addSubview: controller.view];
|
|
if ([[UIDevice currentDevice].systemVersion doubleValue] < 5.0) {
|
|
[controller viewDidAppear:NO];
|
|
}
|
|
}
|
|
}
|
|
|
|
+ (void)removeSubView:(UIViewController*)controller {
|
|
if(controller != nil) {
|
|
if ([[UIDevice currentDevice].systemVersion doubleValue] < 5.0) {
|
|
[controller viewWillDisappear:NO];
|
|
}
|
|
[controller.view removeFromSuperview];
|
|
if ([[UIDevice currentDevice].systemVersion doubleValue] < 5.0) {
|
|
[controller viewDidDisappear:NO];
|
|
}
|
|
}
|
|
}
|
|
|
|
- (UIViewController*)getCachedController:(NSString*)name {
|
|
UIViewController *controller = nil;
|
|
if(name != nil) {
|
|
controller = [viewControllerCache objectForKey:name];
|
|
if(controller == nil) {
|
|
controller = [[[NSClassFromString(name) alloc] init] autorelease];
|
|
[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;
|
|
}
|
|
|
|
NSString* rotationPreference = [[LinphoneManager instance] lpConfigStringForKey:@"rotation_preference"];
|
|
if([rotationPreference isEqualToString:@"auto"]) {
|
|
// Don't rotate in UIDeviceOrientationFaceUp UIDeviceOrientationFaceDown
|
|
if(!UIDeviceOrientationIsPortrait(deviceOrientation) && !UIDeviceOrientationIsLandscape(deviceOrientation)) {
|
|
if(currentOrientation == UIDeviceOrientationUnknown) {
|
|
return [UIApplication sharedApplication].statusBarOrientation;
|
|
}
|
|
deviceOrientation = currentOrientation;
|
|
}
|
|
if (UIDeviceOrientationIsPortrait(deviceOrientation)) {
|
|
if ([currentViewDescription portraitMode]) {
|
|
return deviceOrientation;
|
|
} else {
|
|
return UIInterfaceOrientationLandscapeLeft;
|
|
}
|
|
}
|
|
if (UIDeviceOrientationIsLandscape(deviceOrientation)) {
|
|
if ([currentViewDescription landscapeMode]) {
|
|
return deviceOrientation;
|
|
} else {
|
|
return UIInterfaceOrientationPortrait;
|
|
}
|
|
}
|
|
} else if([rotationPreference isEqualToString:@"portrait"]) {
|
|
if ([currentViewDescription portraitMode]) {
|
|
if (UIDeviceOrientationIsPortrait(deviceOrientation)) {
|
|
return deviceOrientation;
|
|
} else {
|
|
if(UIInterfaceOrientationIsPortrait([UIApplication sharedApplication].statusBarOrientation)) {
|
|
return [UIApplication sharedApplication].statusBarOrientation;
|
|
} else {
|
|
return UIInterfaceOrientationPortrait;
|
|
}
|
|
}
|
|
} else {
|
|
return UIInterfaceOrientationLandscapeLeft;
|
|
}
|
|
} else if([rotationPreference isEqualToString:@"landscape"]) {
|
|
if ([currentViewDescription landscapeMode]) {
|
|
if (UIDeviceOrientationIsLandscape(deviceOrientation)) {
|
|
return deviceOrientation;
|
|
} else {
|
|
if(UIInterfaceOrientationIsLandscape([UIApplication sharedApplication].statusBarOrientation)) {
|
|
return [UIApplication sharedApplication].statusBarOrientation;
|
|
} else {
|
|
return UIInterfaceOrientationLandscapeLeft;
|
|
}
|
|
}
|
|
} else {
|
|
return UIInterfaceOrientationPortrait;
|
|
}
|
|
}
|
|
}
|
|
return UIInterfaceOrientationPortrait;
|
|
}
|
|
|
|
#define IPHONE_STATUSBAR_HEIGHT 20
|
|
|
|
- (void)update: (UICompositeViewDescription*) description tabBar:(NSNumber*)tabBar stateBar:(NSNumber*)stateBar fullscreen:(NSNumber*)fullscreen {
|
|
|
|
UIViewController *oldContentViewController = self.contentViewController;
|
|
UIViewController *oldStateBarViewController = self.stateBarViewController;
|
|
UIViewController *oldTabBarViewController = self.tabBarViewController;
|
|
// Copy view description
|
|
UICompositeViewDescription *oldViewDescription = nil;
|
|
|
|
if(description != nil) {
|
|
oldViewDescription = currentViewDescription;
|
|
currentViewDescription = [description copy];
|
|
|
|
// Animate only with a previous screen
|
|
if(oldViewDescription != nil && viewTransition != nil) {
|
|
[contentView.layer removeAnimationForKey:@"transition"];
|
|
[contentView.layer addAnimation:viewTransition forKey:@"transition"];
|
|
if(oldViewDescription.stateBar != currentViewDescription.stateBar ||
|
|
oldViewDescription.stateBarEnabled != currentViewDescription.stateBarEnabled ||
|
|
[stateBarView.layer animationForKey:@"transition"] != nil) {
|
|
[stateBarView.layer removeAnimationForKey:@"transition"];
|
|
[stateBarView.layer addAnimation:viewTransition forKey:@"transition"];
|
|
}
|
|
if(oldViewDescription.tabBar != currentViewDescription.tabBar ||
|
|
oldViewDescription.tabBarEnabled != currentViewDescription.tabBarEnabled ||
|
|
[tabBarView.layer animationForKey:@"transition"] != nil) {
|
|
[tabBarView.layer removeAnimationForKey:@"transition"];
|
|
[tabBarView.layer addAnimation:viewTransition forKey:@"transition"];
|
|
}
|
|
}
|
|
|
|
UIViewController *newContentViewController = [self getCachedController:description.content];
|
|
UIViewController *newStateBarViewController = [self getCachedController:description.stateBar];
|
|
UIViewController *newTabBarViewController = [self getCachedController:description.tabBar];
|
|
|
|
[UICompositeViewController removeSubView: oldContentViewController];
|
|
if(oldTabBarViewController != nil && oldTabBarViewController != newTabBarViewController) {
|
|
[UICompositeViewController removeSubView:oldTabBarViewController];
|
|
}
|
|
if(oldStateBarViewController != nil && oldStateBarViewController != newStateBarViewController) {
|
|
[UICompositeViewController removeSubView:oldStateBarViewController];
|
|
}
|
|
|
|
self.stateBarViewController = newStateBarViewController;
|
|
self.contentViewController = newContentViewController;
|
|
self.tabBarViewController = newTabBarViewController;
|
|
|
|
// Update rotation
|
|
UIInterfaceOrientation correctOrientation = [self getCorrectInterfaceOrientation:[[UIDevice currentDevice] orientation]];
|
|
if(currentOrientation != correctOrientation) {
|
|
[UICompositeViewController setOrientation:correctOrientation animated:currentOrientation!=UIDeviceOrientationUnknown];
|
|
} else {
|
|
if(oldContentViewController != newContentViewController) {
|
|
UIInterfaceOrientation oldOrientation = self.contentViewController.interfaceOrientation;
|
|
[self.contentViewController willRotateToInterfaceOrientation:correctOrientation duration:0];
|
|
[self.contentViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
|
[self.contentViewController 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(oldStateBarViewController != newStateBarViewController) {
|
|
UIInterfaceOrientation oldOrientation = self.stateBarViewController.interfaceOrientation;
|
|
[self.stateBarViewController willRotateToInterfaceOrientation:correctOrientation duration:0];
|
|
[self.stateBarViewController willAnimateRotationToInterfaceOrientation:correctOrientation duration:0];
|
|
[self.stateBarViewController didRotateFromInterfaceOrientation:oldOrientation];
|
|
}
|
|
}
|
|
} else {
|
|
oldViewDescription = (currentViewDescription != nil)? [currentViewDescription copy]: nil;
|
|
}
|
|
|
|
if(currentViewDescription == nil) {
|
|
return;
|
|
}
|
|
|
|
if(tabBar != nil) {
|
|
if(currentViewDescription.tabBarEnabled != [tabBar boolValue]) {
|
|
currentViewDescription.tabBarEnabled = [tabBar boolValue];
|
|
} else {
|
|
tabBar = nil; // No change = No Update
|
|
}
|
|
}
|
|
|
|
if(stateBar != nil) {
|
|
if(currentViewDescription.stateBarEnabled != [stateBar boolValue]) {
|
|
currentViewDescription.stateBarEnabled = [stateBar boolValue];
|
|
} else {
|
|
stateBar = 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 || stateBar != nil || fullscreen != nil) {
|
|
[UIView beginAnimations:@"resize" context:nil];
|
|
[UIView setAnimationDuration:0.35];
|
|
[UIView setAnimationBeginsFromCurrentState:TRUE];
|
|
}
|
|
|
|
CGRect contentFrame = contentView.frame;
|
|
CGRect viewFrame = [self.view frame];
|
|
|
|
// Resize StateBar
|
|
CGRect stateBarFrame = stateBarView.frame;
|
|
int origin = IPHONE_STATUSBAR_HEIGHT;
|
|
if(currentViewDescription.fullscreen)
|
|
origin = 0;
|
|
|
|
if(self.stateBarViewController != nil && currentViewDescription.stateBarEnabled) {
|
|
contentFrame.origin.y = origin + stateBarFrame.size.height;
|
|
stateBarFrame.origin.y = origin;
|
|
} else {
|
|
contentFrame.origin.y = origin;
|
|
stateBarFrame.origin.y = origin - stateBarFrame.size.height;
|
|
}
|
|
|
|
// Resize TabBar
|
|
CGRect tabFrame = tabBarView.frame;
|
|
if(self.tabBarViewController != nil && currentViewDescription.tabBarEnabled) {
|
|
tabFrame.origin.y = viewFrame.size.height;
|
|
tabFrame.origin.x = viewFrame.size.width;
|
|
tabFrame.size.height = self.tabBarViewController.view.frame.size.height;
|
|
//tabFrame.size.width = self.tabBarViewController.view.frame.size.width;
|
|
tabFrame.origin.y -= tabFrame.size.height;
|
|
tabFrame.origin.x -= tabFrame.size.width;
|
|
contentFrame.size.height = tabFrame.origin.y - contentFrame.origin.y;
|
|
for (UIView *view in self.tabBarViewController.view.subviews) {
|
|
if(view.tag == -1) {
|
|
contentFrame.size.height += view.frame.origin.y;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
contentFrame.size.height = viewFrame.size.height - contentFrame.origin.y;
|
|
tabFrame.origin.y = viewFrame.size.height;
|
|
}
|
|
|
|
if(currentViewDescription.fullscreen) {
|
|
contentFrame.origin.y = origin;
|
|
contentFrame.size.height = viewFrame.size.height - contentFrame.origin.y;
|
|
}
|
|
|
|
// Set frames
|
|
[contentView setFrame: contentFrame];
|
|
[self.contentViewController.view setFrame: [contentView bounds]];
|
|
[tabBarView setFrame: tabFrame];
|
|
CGRect frame = [self.tabBarViewController.view frame];
|
|
frame.size.width = [tabBarView bounds].size.width;
|
|
[self.tabBarViewController.view setFrame:frame];
|
|
[stateBarView setFrame: stateBarFrame];
|
|
frame = [self.stateBarViewController.view frame];
|
|
frame.size.width = [stateBarView bounds].size.width;
|
|
[self.stateBarViewController.view setFrame:frame];
|
|
|
|
// Commit animation
|
|
if(tabBar != nil || stateBar != nil || fullscreen != nil) {
|
|
[UIView commitAnimations];
|
|
}
|
|
|
|
// Change view
|
|
if(description != nil) {
|
|
[UICompositeViewController addSubView: self.contentViewController view:contentView];
|
|
if(oldTabBarViewController == nil || oldTabBarViewController != self.tabBarViewController) {
|
|
[UICompositeViewController addSubView: self.tabBarViewController view:tabBarView];
|
|
}
|
|
if(oldStateBarViewController == nil || oldStateBarViewController != self.stateBarViewController) {
|
|
[UICompositeViewController addSubView: self.stateBarViewController view:stateBarView];
|
|
}
|
|
}
|
|
|
|
// Dealloc old view description
|
|
if(oldViewDescription != nil) {
|
|
[oldViewDescription release];
|
|
}
|
|
}
|
|
|
|
- (void) changeView:(UICompositeViewDescription *)description {
|
|
[self view]; // Force view load
|
|
[self update:description tabBar:nil stateBar:nil fullscreen:nil];
|
|
}
|
|
|
|
- (void) setFullScreen:(BOOL) enabled {
|
|
[self update:nil tabBar:nil stateBar:nil fullscreen:[NSNumber numberWithBool:enabled]];
|
|
}
|
|
|
|
- (void) setToolBarHidden:(BOOL) hidden {
|
|
[self update:nil tabBar:[NSNumber numberWithBool:!hidden] stateBar:nil fullscreen:nil];
|
|
}
|
|
|
|
- (void) setStateBarHidden:(BOOL) hidden {
|
|
[self update:nil tabBar: nil stateBar:[NSNumber numberWithBool:!hidden] fullscreen:nil];
|
|
}
|
|
|
|
- (UIViewController *) getCurrentViewController {
|
|
return [[self.contentViewController retain] autorelease];
|
|
}
|
|
|
|
@end
|