//

//  MGSplitViewController.m

//  MGSplitView

//

//  Created by Matt Gemmell on 26/07/2010.

//  Copyright 2010 Instinctive Code.

//

#import "MGSplitViewController.h"

#import "MGSplitDividerView.h"

#import "MGSplitCornersView.h"

#define MG_DEFAULT_SPLIT_POSITION		320.0	// default width of master view in UISplitViewController.

#define MG_DEFAULT_SPLIT_WIDTH			1.0		// default width of split-gutter in UISplitViewController.

#define MG_DEFAULT_CORNER_RADIUS		5.0		// default corner-radius of overlapping split-inner corners on the master and detail views.

#define MG_DEFAULT_CORNER_COLOR			[UIColor blackColor]	// default color of intruding inner corners (and divider background).

#define MG_PANESPLITTER_CORNER_RADIUS	0.0		// corner-radius of split-inner corners for MGSplitViewDividerStylePaneSplitter style.

#define MG_PANESPLITTER_SPLIT_WIDTH		25.0	// width of split-gutter for MGSplitViewDividerStylePaneSplitter style.

#define MG_MIN_VIEW_WIDTH				200.0	// minimum width a view is allowed to become as a result of changing the splitPosition.

#define MG_ANIMATION_CHANGE_SPLIT_ORIENTATION	@"ChangeSplitOrientation"	// Animation ID for internal use.

#define MG_ANIMATION_CHANGE_SUBVIEWS_ORDER		@"ChangeSubviewsOrder"	// Animation ID for internal use.

@interface MGSplitViewController (MGPrivateMethods)

- (void)setup;

- (CGSize)splitViewSizeForOrientation:(UIInterfaceOrientation)theOrientation;

- (void)layoutSubviews;

- (void)layoutSubviewsWithAnimation:(BOOL)animate;

- (void)layoutSubviewsForInterfaceOrientation:(UIInterfaceOrientation)theOrientation withAnimation:(BOOL)animate;

- (BOOL)shouldShowMasterForInterfaceOrientation:(UIInterfaceOrientation)theOrientation;

- (BOOL)shouldShowMaster;

- (NSString *)nameOfInterfaceOrientation:(UIInterfaceOrientation)theOrientation;

- (void)reconfigureForMasterInPopover:(BOOL)inPopover;

@end

@implementation MGSplitViewController

#pragma mark -

#pragma mark Orientation helpers

- (NSString *)nameOfInterfaceOrientation:(UIInterfaceOrientation)theOrientation

{

	NSString *orientationName = nil;

	switch (theOrientation) {

		case UIInterfaceOrientationPortrait:

			orientationName = @"Portrait"; // Home button at bottom

			break;

		case UIInterfaceOrientationPortraitUpsideDown:

			orientationName = @"Portrait (Upside Down)"; // Home button at top

			break;

		case UIInterfaceOrientationLandscapeLeft:

			orientationName = @"Landscape (Left)"; // Home button on left

			break;

		case UIInterfaceOrientationLandscapeRight:

			orientationName = @"Landscape (Right)"; // Home button on right

			break;

		default:

			break;

	}

	return orientationName;

}

- (BOOL)isLandscape

{

	return UIInterfaceOrientationIsLandscape(self.interfaceOrientation);

}

- (BOOL)shouldShowMasterForInterfaceOrientation:(UIInterfaceOrientation)theOrientation

{

	// Returns YES if master view should be shown directly embedded in the splitview, instead of hidden in a popover.

	return ((UIInterfaceOrientationIsLandscape(theOrientation)) ? _showsMasterInLandscape : _showsMasterInPortrait);

}

- (BOOL)shouldShowMaster

{

	return [self shouldShowMasterForInterfaceOrientation:self.interfaceOrientation];

}

- (BOOL)isShowingMaster

{

	return [self shouldShowMaster] && self.masterViewController && self.masterViewController.view && ([self.masterViewController.view superview] == self.view);

}

#pragma mark -

#pragma mark Setup and Teardown

- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil

{

	if ((self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil])) {

		[self setup];

	}

	return self;

}

- (id)initWithCoder:(NSCoder *)aDecoder

{

	if ((self = [super initWithCoder:aDecoder])) {

		[self setup];

	}

	return self;

}

- (void)setup

{

	// Configure default behaviour.

	_viewControllers = [[NSMutableArray alloc] initWithObjects:[NSNull null], [NSNull null], nil];

	_splitWidth = MG_DEFAULT_SPLIT_WIDTH;

	_showsMasterInPortrait = NO;

	_showsMasterInLandscape = YES;

	_reconfigurePopup = NO;

	_vertical = YES;

	_masterBeforeDetail = YES;

	_splitPosition = MG_DEFAULT_SPLIT_POSITION;

	CGRect divRect = self.view.bounds;

	if ([self isVertical]) {

		divRect.origin.y = _splitPosition;

		divRect.size.height = _splitWidth;

	} else {

		divRect.origin.x = _splitPosition;

		divRect.size.width = _splitWidth;

	}

	_dividerView = [[MGSplitDividerView alloc] initWithFrame:divRect];

	_dividerView.splitViewController = self;

	_dividerView.backgroundColor = MG_DEFAULT_CORNER_COLOR;

	_dividerStyle = MGSplitViewDividerStyleThin;

}

- (void)dealloc

{

	_delegate = nil;

	[self.view.subviews makeObjectsPerformSelector:@selector(removeFromSuperview)];

	[_viewControllers release];

	[_barButtonItem release];

	[_hiddenPopoverController release];

	[_dividerView release];

	[_cornerViews release];

	[super dealloc];

}

#pragma mark -

#pragma mark View management

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation

{

    return YES;

}

- (void)willRotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation duration:(NSTimeInterval)duration

{

	[self.masterViewController willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];

	[self.detailViewController willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];

}

- (void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)fromInterfaceOrientation

{

	[self.masterViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];

	[self.detailViewController didRotateFromInterfaceOrientation:fromInterfaceOrientation];

}

- (void)willAnimateRotationToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation 

										 duration:(NSTimeInterval)duration

{

	[self.masterViewController willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];

	[self.detailViewController willAnimateRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];

	// Hide popover.

	if (_hiddenPopoverController && _hiddenPopoverController.popoverVisible) {

		[_hiddenPopoverController dismissPopoverAnimated:NO];

	}

	// Re-tile views.

	_reconfigurePopup = YES;

	[self layoutSubviewsForInterfaceOrientation:toInterfaceOrientation withAnimation:YES];

}

- (void)willAnimateFirstHalfOfRotationToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation duration:(NSTimeInterval)duration

{

	[self.masterViewController willAnimateFirstHalfOfRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];

	[self.detailViewController willAnimateFirstHalfOfRotationToInterfaceOrientation:toInterfaceOrientation duration:duration];

}

- (void)didAnimateFirstHalfOfRotationToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation

{

	[self.masterViewController didAnimateFirstHalfOfRotationToInterfaceOrientation:toInterfaceOrientation];

	[self.detailViewController didAnimateFirstHalfOfRotationToInterfaceOrientation:toInterfaceOrientation];

}

- (void)willAnimateSecondHalfOfRotationFromInterfaceOrientation:(UIInterfaceOrientation)fromInterfaceOrientation duration:(NSTimeInterval)duration

{

	[self.masterViewController willAnimateSecondHalfOfRotationFromInterfaceOrientation:fromInterfaceOrientation duration:duration];

	[self.detailViewController willAnimateSecondHalfOfRotationFromInterfaceOrientation:fromInterfaceOrientation duration:duration];

}

- (CGSize)splitViewSizeForOrientation:(UIInterfaceOrientation)theOrientation

{

	UIScreen *screen = [UIScreen mainScreen];

	CGRect fullScreenRect = screen.bounds; // always implicitly in Portrait orientation.

	CGRect appFrame = screen.applicationFrame;

	// Find status bar height by checking which dimension of the applicationFrame is narrower than screen bounds.

	// Little bit ugly looking, but it'll still work even if they change the status bar height in future.

	float statusBarHeight = MAX((fullScreenRect.size.width - appFrame.size.width), (fullScreenRect.size.height - appFrame.size.height));

	// Initially assume portrait orientation.

	float width = fullScreenRect.size.width;

	float height = fullScreenRect.size.height;

	// Correct for orientation.

	if (UIInterfaceOrientationIsLandscape(theOrientation)) {

		width = height;

		height = fullScreenRect.size.width;

	}

	// Account for status bar, which always subtracts from the height (since it's always at the top of the screen).

	height -= statusBarHeight;

	return CGSizeMake(width, height);

}

- (void)layoutSubviewsForInterfaceOrientation:(UIInterfaceOrientation)theOrientation withAnimation:(BOOL)animate

{

	if (_reconfigurePopup) {

		[self reconfigureForMasterInPopover:![self shouldShowMasterForInterfaceOrientation:theOrientation]];

	}

	// Layout the master, detail and divider views appropriately, adding/removing subviews as needed.

	// First obtain relevant geometry.

	CGSize fullSize = [self splitViewSizeForOrientation:theOrientation];

	float width = fullSize.width;

	float height = fullSize.height;

	if (NO) { // Just for debugging.

		NSLog(@"Target orientation is %@, dimensions will be %.0f x %.0f", 

			  [self nameOfInterfaceOrientation:theOrientation], width, height);

	}

	// Layout the master, divider and detail views.

	CGRect newFrame = CGRectMake(0, 0, width, height);

	UIViewController *controller;

	UIView *theView;

	BOOL shouldShowMaster = [self shouldShowMasterForInterfaceOrientation:theOrientation];

	BOOL masterFirst = [self isMasterBeforeDetail];

	if ([self isVertical]) {

		// Master on left, detail on right (or vice versa).

		CGRect masterRect, dividerRect, detailRect;

		if (masterFirst) {

			if (!shouldShowMaster) {

				// Move off-screen.

				newFrame.origin.x -= (_splitPosition + _splitWidth);

			}

			newFrame.size.width = _splitPosition;

			masterRect = newFrame;

			newFrame.origin.x += newFrame.size.width;

			newFrame.size.width = _splitWidth;

			dividerRect = newFrame;

			newFrame.origin.x += newFrame.size.width;

			newFrame.size.width = width - newFrame.origin.x;

			detailRect = newFrame;

		} else {

			if (!shouldShowMaster) {

				// Move off-screen.

				newFrame.size.width += (_splitPosition + _splitWidth);

			}

			newFrame.size.width -= (_splitPosition + _splitWidth);

			detailRect = newFrame;

			newFrame.origin.x += newFrame.size.width;

			newFrame.size.width = _splitWidth;

			dividerRect = newFrame;

			newFrame.origin.x += newFrame.size.width;

			newFrame.size.width = _splitPosition;

			masterRect = newFrame;

		}

		// Position master.

		controller = self.masterViewController;

		if (controller && [controller isKindOfClass:[UIViewController class]])  {

			theView = controller.view;

			if (theView) {

				theView.frame = masterRect;

				if (!theView.superview) {

					[controller viewWillAppear:NO];

					[self.view addSubview:theView];

					[controller viewDidAppear:NO];

				}

			}

		}

		// Position divider.

		theView = _dividerView;

		theView.frame = dividerRect;

		if (!theView.superview) {

			[self.view addSubview:theView];

		}

		// Position detail.

		controller = self.detailViewController;

		if (controller && [controller isKindOfClass:[UIViewController class]])  {

			theView = controller.view;

			if (theView) {

				theView.frame = detailRect;

				if (!theView.superview) {

					[self.view insertSubview:theView aboveSubview:self.masterViewController.view];

				} else {

					[self.view bringSubviewToFront:theView];

				}

			}

		}

	} else {

		// Master above, detail below (or vice versa).

		CGRect masterRect, dividerRect, detailRect;

		if (masterFirst) {

			if (!shouldShowMaster) {

				// Move off-screen.

				newFrame.origin.y -= (_splitPosition + _splitWidth);

			}

			newFrame.size.height = _splitPosition;

			masterRect = newFrame;

			newFrame.origin.y += newFrame.size.height;

			newFrame.size.height = _splitWidth;

			dividerRect = newFrame;

			newFrame.origin.y += newFrame.size.height;

			newFrame.size.height = height - newFrame.origin.y;

			detailRect = newFrame;

		} else {

			if (!shouldShowMaster) {

				// Move off-screen.

				newFrame.size.height += (_splitPosition + _splitWidth);

			}

			newFrame.size.height -= (_splitPosition + _splitWidth);

			detailRect = newFrame;

			newFrame.origin.y += newFrame.size.height;

			newFrame.size.height = _splitWidth;

			dividerRect = newFrame;

			newFrame.origin.y += newFrame.size.height;

			newFrame.size.height = _splitPosition;

			masterRect = newFrame;

		}

		// Position master.

		controller = self.masterViewController;

		if (controller && [controller isKindOfClass:[UIViewController class]])  {

			theView = controller.view;

			if (theView) {

				theView.frame = masterRect;

				if (!theView.superview) {

					[controller viewWillAppear:NO];

					[self.view addSubview:theView];

					[controller viewDidAppear:NO];

				}

			}

		}

		// Position divider.

		theView = _dividerView;

		theView.frame = dividerRect;

		if (!theView.superview) {

			[self.view addSubview:theView];

		}

		// Position detail.

		controller = self.detailViewController;

		if (controller && [controller isKindOfClass:[UIViewController class]])  {

			theView = controller.view;

			if (theView) {

				theView.frame = detailRect;

				if (!theView.superview) {

					[self.view insertSubview:theView aboveSubview:self.masterViewController.view];

				} else {

					[self.view bringSubviewToFront:theView];

				}

			}

		}

	}

	// Create corner views if necessary.

	MGSplitCornersView *leadingCorners; // top/left of screen in vertical/horizontal split.

	MGSplitCornersView *trailingCorners; // bottom/right of screen in vertical/horizontal split.

	if (!_cornerViews) {

		CGRect cornerRect = CGRectMake(0, 0, 10, 10); // arbitrary, will be resized below.

		leadingCorners = [[MGSplitCornersView alloc] initWithFrame:cornerRect];

		leadingCorners.splitViewController = self;

		leadingCorners.cornerBackgroundColor = MG_DEFAULT_CORNER_COLOR;

		leadingCorners.cornerRadius = MG_DEFAULT_CORNER_RADIUS;

		trailingCorners = [[MGSplitCornersView alloc] initWithFrame:cornerRect];

		trailingCorners.splitViewController = self;

		trailingCorners.cornerBackgroundColor = MG_DEFAULT_CORNER_COLOR;

		trailingCorners.cornerRadius = MG_DEFAULT_CORNER_RADIUS;

		_cornerViews = [[NSArray alloc] initWithObjects:leadingCorners, trailingCorners, nil];

		[leadingCorners release];

		[trailingCorners release];

	} else if ([_cornerViews count] == 2) {

		leadingCorners = [_cornerViews objectAtIndex:0];

		trailingCorners = [_cornerViews objectAtIndex:1];

	}

	// Configure and layout the corner-views.

	leadingCorners.cornersPosition = (_vertical) ? MGCornersPositionLeadingVertical : MGCornersPositionLeadingHorizontal;

	trailingCorners.cornersPosition = (_vertical) ? MGCornersPositionTrailingVertical : MGCornersPositionTrailingHorizontal;

	leadingCorners.autoresizingMask = (_vertical) ? UIViewAutoresizingFlexibleBottomMargin : UIViewAutoresizingFlexibleRightMargin;

	trailingCorners.autoresizingMask = (_vertical) ? UIViewAutoresizingFlexibleTopMargin : UIViewAutoresizingFlexibleLeftMargin;

	float x, y, cornersWidth, cornersHeight;

	CGRect leadingRect, trailingRect;

	float radius = leadingCorners.cornerRadius;

	if (_vertical) { // left/right split

		cornersWidth = (radius * 2.0) + _splitWidth;

		cornersHeight = radius;

		x = ((shouldShowMaster) ? ((masterFirst) ? _splitPosition : width - (_splitPosition + _splitWidth)) : (0 - _splitWidth)) - radius;

		y = 0;

		leadingRect = CGRectMake(x, y, cornersWidth, cornersHeight); // top corners

		trailingRect = CGRectMake(x, (height - cornersHeight), cornersWidth, cornersHeight); // bottom corners

	} else { // top/bottom split

		x = 0;

		y = ((shouldShowMaster) ? ((masterFirst) ? _splitPosition : height - (_splitPosition + _splitWidth)) : (0 - _splitWidth)) - radius;

		cornersWidth = radius;

		cornersHeight = (radius * 2.0) + _splitWidth;

		leadingRect = CGRectMake(x, y, cornersWidth, cornersHeight); // left corners

		trailingRect = CGRectMake((width - cornersWidth), y, cornersWidth, cornersHeight); // right corners

	}

	leadingCorners.frame = leadingRect;

	trailingCorners.frame = trailingRect;

	// Ensure corners are visible and frontmost.

	if (!leadingCorners.superview) {

		[self.view insertSubview:leadingCorners aboveSubview:self.detailViewController.view];

		[self.view insertSubview:trailingCorners aboveSubview:self.detailViewController.view];

	} else {

		[self.view bringSubviewToFront:leadingCorners];

		[self.view bringSubviewToFront:trailingCorners];

	}

}

- (void)layoutSubviewsWithAnimation:(BOOL)animate

{

	[self layoutSubviewsForInterfaceOrientation:self.interfaceOrientation withAnimation:animate];

}

- (void)layoutSubviews

{

	[self layoutSubviewsForInterfaceOrientation:self.interfaceOrientation withAnimation:YES];

}

- (void)viewWillAppear:(BOOL)animated

{

	[super viewWillAppear:animated];

	if ([self isShowingMaster]) {

		[self.masterViewController viewWillAppear:animated];

	}

	[self.detailViewController viewWillAppear:animated];

	_reconfigurePopup = YES;

	[self layoutSubviews];

}

- (void)viewDidAppear:(BOOL)animated

{

	[super viewDidAppear:animated];

	if ([self isShowingMaster]) {

		[self.masterViewController viewDidAppear:animated];

	}

	[self.detailViewController viewDidAppear:animated];

}

- (void)viewWillDisappear:(BOOL)animated

{

	[super viewWillDisappear:animated];

	if ([self isShowingMaster]) {

		[self.masterViewController viewWillDisappear:animated];

	}

	[self.detailViewController viewWillDisappear:animated];

}