//
|
// SlideMenuController.m
|
// btWeighBase
|
//
|
// Created by ChipSea on 16/1/28.
|
// Copyright © 2016年 Chipsea. All rights reserved.
|
//
|
|
#import "SlideMenuController.h"
|
|
typedef enum {
|
SlideActionOpen,
|
SlideActionClose
|
}SlideAction;
|
|
struct PanInfo {
|
SlideAction action;
|
BOOL shouldBounce;
|
CGFloat velocity;
|
};
|
|
@implementation SlideMenuOption
|
|
|
-(instancetype)init {
|
self = [super init];
|
if (self) {
|
_leftViewWitdth = 250;
|
_leftBezelWidth = 16.0;
|
_contentViewScale = 1.0;
|
_contentViewOpacity = 0.5;
|
_shadowOpacity = 0.0;
|
_shadowRadius = 0.0;
|
_shadowOffset = CGSizeMake(0, 0);
|
_panFromBezel = YES;
|
_animationDuration = .4;
|
_rightViewWidth = 250;
|
_rightBezelWidth = 16.0;
|
_rightPanFromBezel = YES;
|
_hideStatusBar = YES;
|
_pointOfNoReturnWidth = 44;
|
_simultaneousGestureRecognizers = YES;
|
_opacityViewBackgroundColor = [UIColor blackColor];
|
}
|
return self;
|
}
|
|
@end
|
|
/**
|
* Instead of the struct static variables
|
* Instead of LeftPanState and RightPanState
|
*/
|
static CGRect LPSFrameAtStartOfPan = {0,0,0,0};
|
static CGPoint LPSStartPointOfPan = {0,0};
|
static BOOL LPSWasOpenAtStartOfPan = NO;
|
static BOOL LPSWasHiddenAtStartOfPan = NO;
|
static CGRect RPSFrameAtStartOfPan = {0,0,0,0};
|
static UIGestureRecognizerState LPSLastState = UIGestureRecognizerStateEnded;
|
static CGPoint RPSStartPointOfPan = {0,0};
|
static BOOL RPSWasOpenAtStartOfPan = NO;
|
static BOOL RPSWasHiddenAtStartOfPan = NO;
|
static UIGestureRecognizerState RPSLastState = UIGestureRecognizerStateEnded;
|
|
@interface SlideMenuController () {
|
|
|
SlideMenuOption *options;
|
}
|
|
@end
|
|
@implementation SlideMenuController
|
|
-(instancetype)init {
|
self = [super init];
|
if (self) {
|
_mainContainerView = [UIView new];
|
_leftContainerView = [UIView new];
|
_rightContainerView = [UIView new];
|
options = [[SlideMenuOption alloc] init];
|
}
|
return self;
|
}
|
|
-(instancetype)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil {
|
return [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
|
}
|
|
-(instancetype)initWithCoder:(NSCoder *)aDecoder {
|
return [super initWithCoder:aDecoder];
|
}
|
|
-(instancetype)initWithMainViewController:(UIViewController *)tMainController leftMenuViewController:(UIViewController *)tLeftMenuController {
|
self = [self init];
|
if (self) {
|
_mainViewController = tMainController;
|
_leftViewController = tLeftMenuController;
|
[self initView];
|
}
|
return self;
|
}
|
|
-(instancetype)initWithMainViewController:(UIViewController *)tMainController rightMenuViewController:(UIViewController *)tRightMenuController {
|
self = [self init];
|
if (self) {
|
_mainViewController = tMainController;
|
_rightViewController = tRightMenuController;
|
[self initView];
|
}
|
return self;
|
}
|
|
-(instancetype)initWithMainViewController:(UIViewController *)tMainController leftMenuViewController:(UIViewController *)tLeftMenuController rightMenuViewController:(UIViewController *)tRightMenuController {
|
self = [self init];
|
if (self) {
|
_mainViewController = tMainController;
|
_leftViewController = tLeftMenuController;
|
_rightViewController = tRightMenuController;
|
[self initView];
|
}
|
return self;
|
}
|
|
-(void)awakeFromNib {
|
[super awakeFromNib];
|
[self initView];
|
}
|
|
-(void)initView {
|
_mainContainerView = [[UIView alloc] initWithFrame:self.view.bounds];
|
_mainContainerView.backgroundColor = [UIColor clearColor];
|
_mainContainerView.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
|
[self.view insertSubview:_mainContainerView atIndex:0];
|
|
CGRect opacityFrame = self.view.bounds;
|
CGFloat opacityOffset = 0;
|
opacityFrame.origin.y = opacityFrame.origin.y + opacityOffset;
|
opacityFrame.size.height = opacityFrame.size.height - opacityOffset;
|
_opacityView = [[UIView alloc] initWithFrame:opacityFrame];
|
_opacityView.backgroundColor = options.opacityViewBackgroundColor;
|
_opacityView.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
|
_opacityView.layer.opacity = 0.0;
|
[self.view insertSubview:_opacityView atIndex:1];
|
|
CGRect leftFrame = self.view.bounds;
|
leftFrame.size.width = options.leftViewWitdth;
|
leftFrame.origin.x = [self leftMinOrigin];
|
CGFloat leftOffset = 0;
|
leftFrame.origin.y = leftFrame.origin.y + leftOffset;
|
leftFrame.size.height = leftFrame.size.height - leftOffset;
|
_leftContainerView = [[UIView alloc] initWithFrame:leftFrame];
|
_leftContainerView.backgroundColor = [UIColor clearColor];
|
_leftContainerView.autoresizingMask = UIViewAutoresizingFlexibleHeight;
|
[self.view insertSubview:_leftContainerView atIndex:2];
|
|
CGRect rightFrame = self.view.bounds;
|
rightFrame.size.width = options.rightViewWidth;
|
rightFrame.origin.x = [self rightMinOrigin];
|
CGFloat rightOffset = 0;
|
rightFrame.origin.y = rightFrame.origin.y + rightOffset;
|
rightFrame.size.height = rightFrame.size.height - rightOffset;
|
_rightContainerView = [[UIView alloc] initWithFrame:rightFrame];
|
_rightContainerView.backgroundColor = [UIColor clearColor];
|
_rightContainerView.autoresizingMask = UIViewAutoresizingFlexibleHeight ;
|
[self.view insertSubview:_rightContainerView atIndex:3];
|
|
[self addLeftGestures];
|
[self addRightGestures];
|
}
|
|
-(SlideMenuOption *)getOption {
|
return options;
|
}
|
|
-(void)setOption:(SlideMenuOption *)option {
|
options = option;
|
}
|
|
|
//-(void)willRotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation duration:(NSTimeInterval)duration {
|
// [super willRotateToInterfaceOrientation:toInterfaceOrientation duration:duration];
|
-(void)viewWillTransitionToSize:(CGSize)size withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
|
[super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
|
_mainContainerView.transform = CGAffineTransformMakeScale(1.0, 1.0);
|
_leftContainerView.hidden = YES;
|
_rightContainerView.hidden = YES;
|
|
__block typeof(self) weakSelf = self;
|
[coordinator animateAlongsideTransition:^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
|
|
} completion:^(id<UIViewControllerTransitionCoordinatorContext> _Nonnull context) {
|
[weakSelf closeLeftNonAnimation];
|
[weakSelf closeRightNonAnimation];
|
weakSelf.leftContainerView.hidden = NO;
|
weakSelf.rightContainerView.hidden = NO;
|
|
if (weakSelf.leftPanGesture != nil && weakSelf.leftTapGesture != nil) {
|
[weakSelf removeLeftGestures];
|
[weakSelf addLeftGestures];
|
}
|
if (weakSelf.rightPanGesture != nil && weakSelf.rightTapGesture != nil) {
|
[weakSelf removeRightGestures];
|
[weakSelf addRightGestures];
|
}
|
}];
|
}
|
|
-(void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)fromInterfaceOrientation {
|
[super didRotateFromInterfaceOrientation:fromInterfaceOrientation];
|
[self closeLeftNonAnimation];
|
[self closeRightNonAnimation];
|
_leftContainerView.hidden = NO;
|
_rightContainerView.hidden = NO;
|
|
[self removeLeftGestures];
|
[self removeRightGestures];
|
[self addLeftGestures];
|
[self addRightGestures];
|
}
|
|
|
- (void)viewDidLoad {
|
[super viewDidLoad];
|
self.edgesForExtendedLayout = UIRectEdgeNone;
|
}
|
|
-(UIInterfaceOrientationMask)supportedInterfaceOrientations {
|
if (_mainViewController != nil) {
|
return [_mainViewController supportedInterfaceOrientations];
|
}
|
return UIInterfaceOrientationMaskAll;
|
}
|
|
-(void)viewWillLayoutSubviews {
|
[self setUpViewController:_mainContainerView targetViewController:_mainViewController];
|
[self setUpViewController:_leftContainerView targetViewController:_leftViewController];
|
[self setUpViewController:_rightContainerView targetViewController:_rightViewController];
|
}
|
|
-(void)openLeft {
|
if (_leftViewController == nil) {
|
return;
|
}
|
|
if (_delegate != nil && [_delegate respondsToSelector:@selector(leftWillOpen)]) {
|
[_delegate leftWillOpen];
|
}
|
|
[self setOpenWindowLevel];
|
|
if (_leftViewController != nil) {
|
[_leftViewController beginAppearanceTransition:[self isLeftHidden] animated:YES];
|
}
|
|
[self openLeftWithVelocity:0.0];
|
|
[self track:TrackActionLeftTapOpen];
|
}
|
|
-(void)openRight {
|
if (_rightViewController == nil) {
|
return;
|
}
|
|
if (_delegate != nil && [_delegate respondsToSelector:@selector(rightWillOpen)]) {
|
[_delegate rightWillOpen];
|
}
|
|
[self setOpenWindowLevel];
|
if (_rightViewController != nil) {
|
[_rightViewController beginAppearanceTransition:[self isRightHidden] animated:YES];
|
}
|
[self openRightWithVelocity:0.0];
|
|
[self track:TrackActionRightTapOpen];
|
}
|
|
-(void)closeLeft {
|
if (_leftViewController == nil) {
|
return;
|
}
|
|
if (_delegate != nil && [_delegate respondsToSelector:@selector(leftWillClose)]) {
|
[_delegate leftWillClose];
|
}
|
|
[_leftViewController beginAppearanceTransition:[self isLeftHidden] animated:YES];
|
[self closeLeftWithVelocity:0.0];
|
[self setCloseWindowLebel];
|
}
|
|
-(void)closeRight {
|
if (_rightViewController == nil) {
|
return;
|
}
|
|
if (_delegate != nil && [_delegate respondsToSelector:@selector(rightWillClose)]) {
|
[_delegate rightWillClose];
|
}
|
|
[_rightViewController beginAppearanceTransition:[self isRightHidden] animated:YES];
|
[self closeRightWithVelocity:0.0];
|
[self setCloseWindowLebel];
|
}
|
|
-(void)addLeftGestures {
|
if (_leftViewController != nil) {
|
// if (self.leftPanGesture == nil) {
|
// self.leftPanGesture = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(handleLeftPanGesture:)];
|
// self.leftPanGesture.delegate = self;
|
// [self.view addGestureRecognizer:self.leftPanGesture];
|
// }
|
|
if (self.leftTapGesture == nil) {
|
self.leftTapGesture = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(toggleLeft)];
|
self.leftTapGesture.delegate = self;
|
[self.view addGestureRecognizer:self.leftTapGesture];
|
}
|
}
|
}
|
|
-(void)addRightGestures {
|
if (_rightViewController != nil) {
|
if (self.rightPanGesture == nil) {
|
self.rightPanGesture = [[UIPanGestureRecognizer alloc] initWithTarget:self action:@selector(handleRightPanGesture:)];
|
self.rightPanGesture.delegate = self;
|
[self.view addGestureRecognizer:self.rightPanGesture];
|
}
|
|
if (self.rightTapGesture == nil) {
|
self.rightTapGesture = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(toggleRight)];
|
self.rightTapGesture.delegate = self;
|
[self.view addGestureRecognizer:self.rightTapGesture];
|
}
|
}
|
}
|
|
-(void)removeLeftGestures {
|
if (self.leftPanGesture != nil) {
|
[self.view removeGestureRecognizer:self.leftPanGesture];
|
self.leftPanGesture = nil;
|
}
|
|
if (self.leftTapGesture != nil) {
|
[self.view removeGestureRecognizer:self.leftTapGesture];
|
self.leftTapGesture = nil;
|
}
|
}
|
|
-(void)removeRightGestures {
|
if (self.rightPanGesture != nil) {
|
[self.view removeGestureRecognizer:self.rightPanGesture];
|
self.rightPanGesture = nil;
|
}
|
|
if (self.rightTapGesture != nil) {
|
[self.view removeGestureRecognizer:self.rightTapGesture];
|
self.rightTapGesture = nil;
|
}
|
}
|
|
-(BOOL)isTagetViewController {
|
// Function to determine the target ViewController
|
// Please to override it if necessary
|
return YES;
|
}
|
|
-(void)track:(TrackAction)action {
|
// function is for tracking
|
// Please to override it if necessary
|
}
|
|
-(void)handleLeftPanGesture:(UIPanGestureRecognizer *)panGesture {
|
if (![self isTagetViewController]) {
|
return;
|
}
|
|
if (![self isRightHidden]) {
|
return;
|
}
|
switch (panGesture.state) {
|
case UIGestureRecognizerStateBegan: {
|
if (LPSLastState != UIGestureRecognizerStateEnded) {
|
return;
|
}
|
|
if (_delegate != nil) {
|
if ([self isLeftHidden]) {
|
if ([_delegate respondsToSelector:@selector(leftWillOpen)]) {
|
[_delegate leftWillOpen];
|
}
|
} else {
|
if ([_delegate respondsToSelector:@selector(leftWillClose)]) {
|
[_delegate leftWillClose];
|
}
|
}
|
}
|
|
LPSFrameAtStartOfPan = _leftContainerView.frame;
|
LPSStartPointOfPan = [panGesture locationInView:self.view];
|
LPSWasOpenAtStartOfPan = [self isLeftOpen];
|
LPSWasHiddenAtStartOfPan = [self isLeftHidden];
|
|
if (_leftViewController != nil) {
|
[_leftViewController beginAppearanceTransition:LPSWasHiddenAtStartOfPan animated:YES];
|
}
|
[self addShadowToView:_leftContainerView];
|
[self setOpenWindowLevel];
|
|
break;
|
}
|
case UIGestureRecognizerStateChanged: {
|
if (LPSLastState != UIGestureRecognizerStateBegan && LPSLastState != UIGestureRecognizerStateChanged) {
|
return;
|
}
|
CGPoint translation = [panGesture translationInView:panGesture.view];
|
_leftContainerView.frame = [self applyLeftTranslation:translation toFrame:LPSFrameAtStartOfPan];
|
[self applyLeftOpacity];
|
[self applyLeftContentViewScale];
|
break;
|
}
|
case UIGestureRecognizerStateEnded: {
|
if (LPSLastState != UIGestureRecognizerStateChanged) {
|
return;
|
}
|
CGPoint velocity = [panGesture velocityInView:panGesture.view];
|
struct PanInfo panInfo = [self panLeftResultInfoForVelocity:velocity];
|
|
if (panInfo.action == SlideActionOpen) {
|
if (LPSWasHiddenAtStartOfPan && _leftViewController != nil) {
|
[_leftViewController beginAppearanceTransition:YES animated:YES];
|
}
|
[self openLeftWithVelocity:panInfo.velocity];
|
[self track:TrackActionLeftFlickOpen];
|
} else {
|
if (LPSWasHiddenAtStartOfPan && _leftViewController != nil) {
|
[_leftViewController beginAppearanceTransition:NO animated:YES];
|
}
|
[self closeLeftWithVelocity:panInfo.velocity];
|
[self setCloseWindowLebel];
|
[self track:TrackActionLeftTapClose];
|
}
|
break;
|
}
|
default:
|
break;
|
}
|
LPSLastState = panGesture.state;
|
}
|
|
-(void)handleRightPanGesture:(UIPanGestureRecognizer *)panGesture {
|
if (![self isTagetViewController]) {
|
return;
|
}
|
|
if (![self isLeftHidden]) {
|
return;
|
}
|
switch (panGesture.state) {
|
case UIGestureRecognizerStateBegan: {
|
if (RPSLastState != UIGestureRecognizerStateEnded) {
|
return;
|
}
|
|
if (_delegate != nil) {
|
if ([self isLeftHidden]) {
|
if ([_delegate respondsToSelector:@selector(rightWillOpen)]) {
|
[_delegate rightWillOpen];
|
}
|
} else {
|
if ([_delegate respondsToSelector:@selector(rightWillClose)]) {
|
[_delegate rightWillClose];
|
}
|
}
|
}
|
|
RPSFrameAtStartOfPan = _rightContainerView.frame;
|
RPSStartPointOfPan = [panGesture locationInView:self.view];
|
RPSWasOpenAtStartOfPan = [self isRightOpen];
|
RPSWasHiddenAtStartOfPan = [self isRightHidden];
|
|
if (_rightViewController != nil) {
|
[_rightViewController beginAppearanceTransition:RPSWasHiddenAtStartOfPan animated:YES];
|
}
|
[self addShadowToView:_rightContainerView];
|
[self setOpenWindowLevel];
|
|
break;
|
}
|
case UIGestureRecognizerStateChanged: {
|
if (RPSLastState != UIGestureRecognizerStateBegan && RPSLastState != UIGestureRecognizerStateChanged) {
|
return;
|
}
|
CGPoint translation = [panGesture translationInView:panGesture.view];
|
_rightContainerView.frame = [self applyRightTranslation:translation toFrame:RPSFrameAtStartOfPan];
|
[self applyRightOpacity];
|
[self applyRightContentViewScale];
|
NSLog(@"handleRightPanGesture --> Changed frame:%@", NSStringFromCGRect(_rightContainerView.frame));
|
break;
|
}
|
case UIGestureRecognizerStateEnded: {
|
if (RPSLastState != UIGestureRecognizerStateChanged) {
|
return;
|
}
|
CGPoint velocity = [panGesture velocityInView:panGesture.view];
|
struct PanInfo panInfo = [self panRightResultInfoForVelocity:velocity];
|
|
if (panInfo.action == SlideActionOpen) {
|
if (RPSWasHiddenAtStartOfPan && _rightViewController != nil) {
|
[_rightViewController beginAppearanceTransition:YES animated:YES];
|
}
|
[self openRightWithVelocity:panInfo.velocity];
|
} else {
|
if (RPSWasHiddenAtStartOfPan && _rightViewController != nil) {
|
[_rightViewController beginAppearanceTransition:NO animated:YES];
|
}
|
[self closeRightWithVelocity:panInfo.velocity];
|
[self setCloseWindowLebel];
|
}
|
NSLog(@"handleRightPanGesture --> Ended frame:%@", NSStringFromCGRect(_rightContainerView.frame));
|
break;
|
}
|
default:
|
break;
|
}
|
RPSLastState = panGesture.state;
|
}
|
|
-(void)openLeftWithVelocity:(CGFloat)velocity {
|
CGFloat xOrigin = _leftContainerView.frame.origin.x;
|
|
CGFloat finalXOrigin = 0.0;
|
|
CGRect frame = _leftContainerView.frame;
|
frame.origin.x = finalXOrigin;
|
|
NSTimeInterval duration = options.animationDuration;
|
if (velocity != 0.0) {
|
duration = fabs(xOrigin - finalXOrigin) / velocity;
|
duration = fmax(0.1, fmin(1.0, duration));
|
}
|
|
[self addShadowToView:_leftContainerView];
|
__block typeof(self) weakSelf = self;
|
[UIView animateWithDuration:duration delay:0.0 options:UIViewAnimationOptionCurveEaseInOut animations:^{
|
weakSelf.leftContainerView.frame = frame;
|
weakSelf.opacityView.layer.opacity = options.contentViewOpacity;
|
weakSelf.mainContainerView.transform = CGAffineTransformMakeScale(options.contentViewScale, options.contentViewScale);
|
} completion:^(BOOL finished) {
|
[weakSelf disableContentInteraction];
|
[weakSelf.leftViewController endAppearanceTransition];
|
|
if (weakSelf.delegate != nil && [weakSelf.delegate respondsToSelector:@selector(leftDidOpen)]) {
|
[weakSelf.delegate leftDidOpen];
|
}
|
}];
|
}
|
|
-(void)openRightWithVelocity:(CGFloat)velocity {
|
CGFloat xOrigin = _rightContainerView.frame.origin.x;
|
|
CGFloat finalXOrigin = CGRectGetWidth(self.view.bounds) - _rightContainerView.frame.size.width;
|
|
CGRect frame = _rightContainerView.frame;
|
frame.origin.x = finalXOrigin;
|
|
NSTimeInterval duration = options.animationDuration;
|
if (velocity != 0.0) {
|
duration = fabs(xOrigin - CGRectGetWidth(self.view.bounds)) / velocity;
|
duration = fmax(0.1, fmin(1.0, duration));
|
}
|
|
[self addShadowToView:_rightContainerView];
|
__block typeof(self) weakSelf = self;
|
[UIView animateWithDuration:duration delay:0.0 options:UIViewAnimationOptionCurveEaseInOut animations:^{
|
weakSelf.rightContainerView.frame = frame;
|
weakSelf.opacityView.layer.opacity = options.contentViewOpacity;
|
weakSelf.mainContainerView.transform = CGAffineTransformMakeScale(options.contentViewScale, options.contentViewScale);
|
} completion:^(BOOL finished) {
|
[weakSelf disableContentInteraction];
|
[weakSelf.rightViewController endAppearanceTransition];
|
|
if (weakSelf.delegate != nil && [weakSelf.delegate respondsToSelector:@selector(rightDidOpen)]) {
|
[weakSelf.delegate rightDidOpen];
|
}
|
}];
|
}
|
|
-(void)closeLeftWithVelocity:(CGFloat) velocity {
|
CGFloat xOrigin = _leftContainerView.frame.origin.x;
|
CGFloat finalXOrigin = [self leftMinOrigin];
|
|
CGRect frame = _leftContainerView.frame;
|
frame.origin.x = finalXOrigin;
|
|
NSTimeInterval duration = options.animationDuration;
|
if (velocity != 0.0) {
|
duration = fabs(xOrigin - finalXOrigin) / velocity;
|
duration = fmax(0.1, fmin(1.0, duration));
|
}
|
__block typeof(self) weakSelf = self;
|
[UIView animateWithDuration:duration delay:0.0 options:UIViewAnimationOptionCurveEaseInOut animations:^{
|
weakSelf.leftContainerView.frame = frame;
|
weakSelf.opacityView.layer.opacity = 0.0;
|
weakSelf.mainContainerView.transform = CGAffineTransformMakeScale(1.0, 1.0);
|
} completion:^(BOOL finished) {
|
[weakSelf removeShadow:weakSelf.leftContainerView];
|
[weakSelf enableContentInteraction];
|
[weakSelf.leftViewController endAppearanceTransition];
|
|
if (weakSelf.delegate != nil && [weakSelf.delegate respondsToSelector:@selector(leftDidClose)]) {
|
[weakSelf.delegate leftDidClose];
|
}
|
}];
|
}
|
|
-(void)closeRightWithVelocity:(CGFloat) velocity {
|
CGFloat xOrigin = _rightContainerView.frame.origin.x;
|
CGFloat finalXOrigin = CGRectGetWidth(self.view.bounds);
|
|
CGRect frame = _rightContainerView.frame;
|
frame.origin.x = finalXOrigin;
|
|
NSTimeInterval duration = options.animationDuration;
|
if (velocity != 0.0) {
|
duration = fabs(xOrigin - CGRectGetWidth(self.view.bounds)) / velocity;
|
duration = fmax(0.1, fmin(1.0, duration));
|
}
|
__block typeof(self) weakSelf = self;
|
[UIView animateWithDuration:duration delay:0.0 options:UIViewAnimationOptionCurveEaseInOut animations:^{
|
weakSelf.rightContainerView.frame = frame;
|
weakSelf.opacityView.layer.opacity = 0.0;
|
weakSelf.mainContainerView.transform = CGAffineTransformMakeScale(1.0, 1.0);
|
} completion:^(BOOL finished) {
|
[weakSelf removeShadow:weakSelf.rightContainerView];
|
[weakSelf enableContentInteraction];
|
[weakSelf.rightViewController endAppearanceTransition];
|
|
if (weakSelf.delegate != nil && [weakSelf.delegate respondsToSelector:@selector(rightDidClose)]) {
|
[weakSelf.delegate rightDidClose];
|
}
|
}];
|
}
|
|
-(void)toggleLeft {
|
if ([self isLeftOpen]) {
|
[self closeLeft];
|
[self setCloseWindowLebel];
|
[self track:TrackActionLeftTapClose];
|
} else {
|
[self openLeft];
|
}
|
}
|
|
-(BOOL)isLeftOpen {
|
return _leftViewController != nil && _leftContainerView.frame.origin.x == 0.0;
|
}
|
|
-(BOOL)isLeftHidden {
|
return _leftContainerView.frame.origin.x <= [self leftMinOrigin];
|
}
|
|
-(void)toggleRight {
|
if ([self isRightOpen]) {
|
[self closeRight];
|
[self setCloseWindowLebel];
|
[self track:TrackActionRightTapClose];
|
} else {
|
[self openRight];
|
}
|
}
|
|
-(BOOL)isRightOpen {
|
return _rightViewController != nil && _rightContainerView.frame.origin.x == CGRectGetWidth(self.view.bounds) - _rightContainerView.frame.size.width;
|
}
|
|
-(BOOL)isRightHidden {
|
return _rightContainerView.frame.origin.x >= CGRectGetWidth(self.view.bounds);
|
}
|
|
-(void)setPanFromBezel:(BOOL)panFromBezel {
|
options.panFromBezel = panFromBezel;
|
}
|
|
-(void)changeMainViewController:(UIViewController *)newMainController close:(BOOL)close {
|
[self removeViewController:_mainViewController];
|
_mainViewController = newMainController;
|
[self setUpViewController:_mainContainerView targetViewController:_mainViewController];
|
if (close) {
|
[self closeLeft];
|
[self closeRight];
|
}
|
}
|
|
-(void)changeLeftViewWidth:(CGFloat)width {
|
options.leftViewWitdth = width;
|
CGRect leftFrame = self.view.bounds;
|
leftFrame.size.width = width;
|
leftFrame.origin.x = [self leftMinOrigin];
|
CGFloat leftOffset = 0;
|
leftFrame.origin.y = leftFrame.origin.y + leftOffset;
|
leftFrame.size.height = leftFrame.size.height - leftOffset;
|
_leftContainerView.frame = leftFrame;
|
}
|
|
-(void)changeRightViewWidth:(CGFloat)width {
|
options.rightBezelWidth = width;
|
CGRect rightFrame = self.view.bounds;
|
rightFrame.size.width = width;
|
rightFrame.origin.x = [self rightMinOrigin];
|
CGFloat rightOffset = 0;
|
rightFrame.origin.y = rightFrame.origin.y + rightOffset;
|
rightFrame.size.height = rightFrame.size.height - rightOffset;
|
_leftContainerView.frame = rightFrame;
|
}
|
|
-(void)changeLeftViewController:(UIViewController *)newLeftController close:(BOOL) close {
|
[self removeViewController:_leftViewController];
|
_leftViewController = newLeftController;
|
[self setUpViewController:_leftContainerView targetViewController:_leftViewController];
|
if (close) {
|
[self closeLeft];
|
}
|
}
|
|
-(void)changeRightViewController:(UIViewController *)newRightController close:(BOOL) close {
|
[self removeViewController:_rightViewController];
|
_rightViewController = newRightController;
|
[self setUpViewController:_rightContainerView targetViewController:_rightViewController];
|
if (close) {
|
[self closeRight];
|
}
|
}
|
|
-(CGFloat)leftMinOrigin {
|
return -options.leftViewWitdth;
|
}
|
|
-(CGFloat)rightMinOrigin {
|
return CGRectGetWidth(self.view.bounds);
|
}
|
|
-(struct PanInfo)panLeftResultInfoForVelocity:(CGPoint)velocity {
|
CGFloat thresholdVelocity = 1000.0;
|
CGFloat pointOfNoReturn = floor([self leftMinOrigin]) + options.pointOfNoReturnWidth;
|
CGFloat leftOrigin = _leftContainerView.frame.origin.x;
|
|
struct PanInfo panInfo = {SlideActionClose, NO, 0.0};
|
panInfo.action = leftOrigin <= pointOfNoReturn ? SlideActionClose : SlideActionOpen;
|
if (velocity.x >= thresholdVelocity) {
|
panInfo.action = SlideActionOpen;
|
panInfo.velocity = velocity.x;
|
} else if (velocity.x <= (-1.0 * thresholdVelocity)) {
|
panInfo.action = SlideActionClose;
|
panInfo.velocity = velocity.x;
|
}
|
return panInfo;
|
}
|
|
-(struct PanInfo)panRightResultInfoForVelocity:(CGPoint)velocity {
|
CGFloat thresholdVelocity = -1000;
|
CGFloat pointOfNoReturn = floor(CGRectGetWidth(self.view.bounds)) - options.pointOfNoReturnWidth;
|
CGFloat rightOrigin = _rightContainerView.frame.origin.x;
|
struct PanInfo panInfo = {SlideActionClose, NO, 0.0};
|
panInfo.action = rightOrigin >= pointOfNoReturn ? SlideActionClose : SlideActionOpen;
|
if (velocity.x <= thresholdVelocity) {
|
panInfo.action = SlideActionOpen;
|
panInfo.velocity = velocity.x;
|
} else if (velocity.x >= (-1.0 * thresholdVelocity)) {
|
panInfo.action = SlideActionClose;
|
panInfo.velocity = velocity.x;
|
}
|
return panInfo;
|
}
|
|
-(CGRect)applyLeftTranslation:(CGPoint)translation toFrame:(CGRect)frame {
|
CGFloat newOrigin = frame.origin.x;
|
newOrigin += translation.x;
|
CGFloat minOrigin = [self leftMinOrigin];
|
CGFloat maxOrigin = 0.0;
|
CGRect newFrame = frame;
|
if (newOrigin < minOrigin) {
|
newOrigin = minOrigin;
|
} else if(newOrigin > maxOrigin) {
|
newOrigin = maxOrigin;
|
}
|
newFrame.origin.x = newOrigin;
|
return newFrame;
|
}
|
|
-(CGRect)applyRightTranslation:(CGPoint)translation toFrame:(CGRect)frame {
|
CGFloat newOrigin = frame.origin.x;
|
newOrigin += translation.x;
|
CGFloat minOrigin = [self rightMinOrigin];
|
CGFloat maxOrigin = [self rightMinOrigin] - _rightContainerView.frame.size.width;
|
CGRect newFrame = frame;
|
if (newOrigin > minOrigin) {
|
newOrigin = minOrigin;
|
} else if (newOrigin < maxOrigin) {
|
newOrigin = maxOrigin;
|
}
|
newFrame.origin.x = newOrigin;
|
return newFrame;
|
}
|
|
-(CGFloat)getOpenedLeftRatio {
|
CGFloat width = _leftContainerView.frame.size.width;
|
CGFloat currentPosition = _leftContainerView.frame.origin.x - [self leftMinOrigin];
|
return currentPosition / width;
|
}
|
|
-(CGFloat)getOpenedRightRatio {
|
CGFloat width = _rightContainerView.frame.size.width;
|
CGFloat currentPosition = _rightContainerView.frame.origin.x;
|
return -(currentPosition - CGRectGetWidth(self.view.bounds))/width;
|
}
|
|
-(void)applyLeftOpacity {
|
CGFloat openedLeftRatio = [self getOpenedLeftRatio];
|
CGFloat opacity = options.contentViewOpacity * openedLeftRatio;
|
_opacityView.layer.opacity = opacity;
|
}
|
|
-(void)applyRightOpacity {
|
CGFloat openedRightRatio = [self getOpenedRightRatio];
|
CGFloat opacity = options.contentViewOpacity * openedRightRatio;
|
_opacityView.layer.opacity = opacity;
|
}
|
|
-(void)applyLeftContentViewScale {
|
CGFloat openedLeftRadio = [self getOpenedLeftRatio];
|
CGFloat scale = 1.0 - ((1.0 - options.contentViewScale) * openedLeftRadio);
|
_mainContainerView.transform = CGAffineTransformMakeScale(scale, scale);
|
}
|
|
-(void)applyRightContentViewScale {
|
CGFloat openedRightRatio = [self getOpenedRightRatio];
|
CGFloat scale = 1.0 - ((1.0 - options.contentViewScale) * openedRightRatio);
|
_mainContainerView.transform = CGAffineTransformMakeScale(scale, scale);
|
}
|
|
-(void)addShadowToView:(UIView *)targetContainerView {
|
targetContainerView.layer.masksToBounds = NO;
|
targetContainerView.layer.shadowOffset = options.shadowOffset;
|
targetContainerView.layer.shadowOpacity = options.shadowOpacity;
|
targetContainerView.layer.shadowRadius = options.shadowRadius;
|
targetContainerView.layer.shadowPath = [UIBezierPath bezierPathWithRect:targetContainerView.bounds].CGPath;
|
|
}
|
|
-(void)removeShadow:(UIView *)targetContainerView {
|
targetContainerView.layer.masksToBounds = YES;
|
_mainContainerView.layer.opacity = 1.0;
|
}
|
|
-(void)removeContentOpacity {
|
_opacityView.layer.opacity = 0.0;
|
}
|
|
-(void)addContentOpacity {
|
_opacityView.layer.opacity = options.contentViewOpacity;
|
}
|
|
-(void)disableContentInteraction {
|
_mainContainerView.userInteractionEnabled = NO;
|
}
|
|
-(void)enableContentInteraction {
|
_mainContainerView.userInteractionEnabled = YES;
|
}
|
|
-(void)setOpenWindowLevel {
|
if (options.hideStatusBar) {
|
dispatch_async(dispatch_get_main_queue(), ^{
|
if ([UIApplication sharedApplication].keyWindow != nil) {
|
[UIApplication sharedApplication].keyWindow.windowLevel = UIWindowLevelStatusBar + 1;
|
}
|
});
|
}
|
}
|
|
-(void)setCloseWindowLebel {
|
if (options.hideStatusBar) {
|
dispatch_async(dispatch_get_main_queue(), ^{
|
if ([UIApplication sharedApplication].keyWindow != nil) {
|
[UIApplication sharedApplication].keyWindow.windowLevel = UIWindowLevelNormal;
|
}
|
});
|
}
|
}
|
|
-(void)setUpViewController:(UIView *)targetView targetViewController:(UIViewController *)targetViewController {
|
if (targetViewController != nil) {
|
[self addChildViewController:targetViewController];
|
targetViewController.view.frame = targetView.bounds;
|
[targetView addSubview:targetViewController.view];
|
[targetViewController didMoveToParentViewController:self];
|
}
|
}
|
|
-(void)removeViewController:(UIViewController *)viewController {
|
if (viewController != nil) {
|
[viewController willMoveToParentViewController:nil];
|
[viewController.view removeFromSuperview];
|
[viewController removeFromParentViewController];
|
}
|
}
|
|
-(void)closeLeftNonAnimation {
|
[self setCloseWindowLebel];
|
CGFloat finalXOrigin = [self leftMinOrigin];
|
CGRect frame = _leftContainerView.frame;
|
frame.origin.x = finalXOrigin;
|
_leftContainerView.frame = frame;
|
_opacityView.layer.opacity = 0.0;
|
_mainContainerView.transform = CGAffineTransformMakeScale(1.0, 1.0);
|
[self removeShadow:_leftContainerView];
|
[self enableContentInteraction];
|
}
|
|
-(void)closeRightNonAnimation {
|
[self setCloseWindowLebel];
|
CGFloat finalXOrigin = CGRectGetWidth(self.view.bounds);
|
CGRect frame = _rightContainerView.frame;
|
frame.origin.x = finalXOrigin;
|
_rightContainerView.frame = frame;
|
_opacityView.layer.opacity = 0.0;
|
_mainContainerView.transform = CGAffineTransformMakeScale(1.0, 1.0);
|
[self removeShadow:_rightContainerView];
|
[self enableContentInteraction];
|
}
|
|
#pragma mark - UIGestureRecognizerDelegate
|
-(BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldReceiveTouch:(UITouch *)touch {
|
CGPoint point = [touch locationInView:self.view];
|
if (gestureRecognizer == _leftPanGesture) {
|
return [self slideLeftForGestureRecognizer:gestureRecognizer inPoint:point];
|
} else if (gestureRecognizer == _rightPanGesture) {
|
return [self slideRightViewForGestureRecognizer:gestureRecognizer withTouchPoint:point];
|
} else if (gestureRecognizer == _leftTapGesture) {
|
return [self isLeftOpen] && ![self isPointContainedWithinLeftRect:point];
|
} else if (gestureRecognizer == _rightTapGesture) {
|
return [self isRightOpen] && ![self isPointContainedWithinRightRect:point];
|
}
|
return YES;
|
}
|
|
-(BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {
|
return options.simultaneousGestureRecognizers;
|
}
|
|
-(BOOL)slideLeftForGestureRecognizer:(UIGestureRecognizer *)gesture inPoint:(CGPoint)point {
|
return [self isLeftOpen] || (options.panFromBezel && [self isLeftPointContainedWithinBezelRect:point]);
|
}
|
|
-(BOOL)isLeftPointContainedWithinBezelRect:(CGPoint)point {
|
CGRect leftBezelRect = CGRectZero;
|
CGRect tempRect = CGRectZero;
|
CGFloat bezelWidth = CGRectGetWidth(self.view.bounds) - options.leftBezelWidth;
|
CGRectDivide(self.view.bounds, &leftBezelRect, &tempRect, bezelWidth, CGRectMinXEdge);
|
return CGRectContainsPoint(leftBezelRect, point);
|
}
|
|
-(BOOL)isPointContainedWithinLeftRect:(CGPoint)point {
|
return CGRectContainsPoint(_leftContainerView.frame, point);;
|
}
|
|
-(BOOL)slideRightViewForGestureRecognizer:(UIGestureRecognizer *)gesture withTouchPoint:(CGPoint)point {
|
return [self isRightOpen] || (options.rightPanFromBezel && [self isRightPointContainedWithinBezelRect:point]);
|
}
|
|
-(BOOL)isRightPointContainedWithinBezelRect:(CGPoint)point {
|
CGRect rightBezelRect = CGRectZero;
|
CGRect tempRect = CGRectZero;
|
CGFloat bezelWidth = CGRectGetWidth(self.view.bounds) - options.rightBezelWidth;
|
CGRectDivide(self.view.bounds, &tempRect, &rightBezelRect, bezelWidth, CGRectMinXEdge);
|
return CGRectContainsPoint(rightBezelRect, point);
|
}
|
|
-(BOOL)isPointContainedWithinRightRect:(CGPoint)point {
|
return CGRectContainsPoint(_rightContainerView.frame, point);
|
}
|
|
@end
|
|
|
@interface UIViewController(SlideMenuVC)
|
|
@property (retain, nonatomic, readonly, getter=slideMenuController) SlideMenuController *slideMenuController;
|
|
|
@end
|
|
@implementation UIViewController(SlideMenuVC)
|
|
-(SlideMenuController *)slideMenuController {
|
UIViewController *controller = self;
|
while (controller != nil) {
|
if ([controller isKindOfClass:[SlideMenuController class]]) {
|
return (SlideMenuController *)controller;
|
}
|
controller = [controller parentViewController];
|
}
|
return nil;
|
}
|
|
-(void)addLeftBarButtonWithImage:(UIImage *)buttonImage {
|
UIBarButtonItem *leftButton = [[UIBarButtonItem alloc] initWithImage:buttonImage style:UIBarButtonItemStyleBordered target:self action:@selector(toggleLeft)];
|
self.navigationItem.leftBarButtonItem = leftButton;
|
}
|
|
-(void)addRightBarButtonWithImage:(UIImage *)buttonImage {
|
UIBarButtonItem *leftButton = [[UIBarButtonItem alloc] initWithImage:buttonImage style:UIBarButtonItemStyleBordered target:self action:@selector(toggleRight)];
|
self.navigationItem.rightBarButtonItem = leftButton;
|
}
|
|
-(void)toggleLeft {
|
if (self.slideMenuController != nil) {
|
[self.slideMenuController toggleLeft];
|
}
|
}
|
|
-(void)toggleRight {
|
if (self.slideMenuController != nil) {
|
[self.slideMenuController toggleRight];
|
}
|
}
|
|
-(void)openLeft {
|
if (self.slideMenuController != nil) {
|
[self.slideMenuController openLeft];
|
}
|
}
|
|
-(void)openRight {
|
if (self.slideMenuController != nil) {
|
[self.slideMenuController openRight];
|
}
|
}
|
|
-(void)closeLeft {
|
if (self.slideMenuController != nil) {
|
[self.slideMenuController closeLeft];
|
}
|
}
|
|
-(void)closeRight {
|
if (self.slideMenuController != nil) {
|
[self.slideMenuController closeRight];
|
}
|
}
|
|
-(void)addPriorityToMenuGesture:(UIScrollView *) targetScrollView {
|
if (self.slideMenuController != nil) {
|
NSArray *recognizers = self.slideMenuController.view.gestureRecognizers;
|
for (UIGestureRecognizer *recognizer in recognizers) {
|
if ([recognizer isKindOfClass:[UIPanGestureRecognizer class]]) {
|
[targetScrollView.panGestureRecognizer requireGestureRecognizerToFail:recognizer];
|
}
|
}
|
}
|
}
|
|
@end
|
