--- /dev/null
+//
+// SideMenuTransition.swift
+// Pods
+//
+// Created by Jon Kent on 1/14/16.
+//
+//
+
+import UIKit
+
+open class SideMenuTransition: UIPercentDrivenInteractiveTransition {
+
+ fileprivate var presenting = false
+ fileprivate var interactive = false
+ fileprivate weak var originalSuperview: UIView?
+ fileprivate weak var activeGesture: UIGestureRecognizer?
+ fileprivate var switchMenus = false {
+ didSet {
+ if switchMenus {
+ cancel()
+ }
+ }
+ }
+ fileprivate var menuWidth: CGFloat {
+ get {
+ let overriddenWidth = menuViewController?.menuWidth ?? 0
+ if overriddenWidth > CGFloat.ulpOfOne {
+ return overriddenWidth
+ }
+ return sideMenuManager.menuWidth
+ }
+ }
+ internal weak var sideMenuManager: SideMenuManager!
+ internal weak var mainViewController: UIViewController?
+ internal weak var menuViewController: UISideMenuNavigationController? {
+ get {
+ return presentDirection == .left ? sideMenuManager.menuLeftNavigationController : sideMenuManager.menuRightNavigationController
+ }
+ }
+ internal var presentDirection: UIRectEdge = .left
+ internal weak var tapView: UIView? {
+ didSet {
+ guard let tapView = tapView else {
+ return
+ }
+
+ tapView.autoresizingMask = [.flexibleHeight, .flexibleWidth]
+ let exitPanGesture = UIPanGestureRecognizer()
+ exitPanGesture.addTarget(self, action:#selector(SideMenuTransition.handleHideMenuPan(_:)))
+ let exitTapGesture = UITapGestureRecognizer()
+ exitTapGesture.addTarget(self, action: #selector(SideMenuTransition.handleHideMenuTap(_:)))
+ tapView.addGestureRecognizer(exitPanGesture)
+ tapView.addGestureRecognizer(exitTapGesture)
+ }
+ }
+ internal weak var statusBarView: UIView? {
+ didSet {
+ guard let statusBarView = statusBarView else {
+ return
+ }
+
+ statusBarView.backgroundColor = sideMenuManager.menuAnimationBackgroundColor ?? UIColor.black
+ statusBarView.isUserInteractionEnabled = false
+ }
+ }
+
+ required public init(sideMenuManager: SideMenuManager) {
+ super.init()
+
+ NotificationCenter.default.addObserver(self, selector:#selector(handleNotification), name: NSNotification.Name.UIApplicationDidEnterBackground, object: nil)
+ NotificationCenter.default.addObserver(self, selector:#selector(handleNotification), name: NSNotification.Name.UIApplicationWillChangeStatusBarFrame, object: nil)
+ self.sideMenuManager = sideMenuManager
+ }
+
+ deinit {
+ NotificationCenter.default.removeObserver(self)
+ }
+
+ fileprivate static var visibleViewController: UIViewController? {
+ get {
+ return getVisibleViewController(forViewController: UIApplication.shared.keyWindow?.rootViewController)
+ }
+ }
+
+ fileprivate class func getVisibleViewController(forViewController: UIViewController?) -> UIViewController? {
+ if let navigationController = forViewController as? UINavigationController {
+ return getVisibleViewController(forViewController: navigationController.visibleViewController)
+ }
+ if let tabBarController = forViewController as? UITabBarController {
+ return getVisibleViewController(forViewController: tabBarController.selectedViewController)
+ }
+ if let splitViewController = forViewController as? UISplitViewController {
+ return getVisibleViewController(forViewController: splitViewController.viewControllers.last)
+ }
+ if let presentedViewController = forViewController?.presentedViewController {
+ return getVisibleViewController(forViewController: presentedViewController)
+ }
+
+ return forViewController
+ }
+
+ @objc internal func handlePresentMenuLeftScreenEdge(_ edge: UIScreenEdgePanGestureRecognizer) {
+ presentDirection = .left
+ handlePresentMenuPan(edge)
+ }
+
+ @objc internal func handlePresentMenuRightScreenEdge(_ edge: UIScreenEdgePanGestureRecognizer) {
+ presentDirection = .right
+ handlePresentMenuPan(edge)
+ }
+
+ @objc internal func handlePresentMenuPan(_ pan: UIPanGestureRecognizer) {
+ if activeGesture == nil {
+ activeGesture = pan
+ } else if pan != activeGesture {
+ pan.isEnabled = false
+ pan.isEnabled = true
+ return
+ } else if pan.state != .began && pan.state != .changed {
+ activeGesture = nil
+ }
+
+ // how much distance have we panned in reference to the parent view?
+ guard let view = mainViewController?.view ?? pan.view else {
+ return
+ }
+
+ let transform = view.transform
+ view.transform = .identity
+ let translation = pan.translation(in: pan.view!)
+ view.transform = transform
+
+ // do some math to translate this to a percentage based value
+ if !interactive {
+ if translation.x == 0 {
+ return // not sure which way the user is swiping yet, so do nothing
+ }
+
+ if !(pan is UIScreenEdgePanGestureRecognizer) {
+ presentDirection = translation.x > 0 ? .left : .right
+ }
+
+ if let menuViewController = menuViewController, let visibleViewController = SideMenuTransition.visibleViewController {
+ interactive = true
+ visibleViewController.present(menuViewController, animated: true, completion: nil)
+ } else {
+ return
+ }
+ }
+
+ let direction: CGFloat = presentDirection == .left ? 1 : -1
+ let distance = translation.x / menuWidth
+ // now lets deal with different states that the gesture recognizer sends
+ switch (pan.state) {
+ case .began, .changed:
+ if pan is UIScreenEdgePanGestureRecognizer {
+ update(min(distance * direction, 1))
+ } else if distance > 0 && presentDirection == .right && sideMenuManager.menuLeftNavigationController != nil {
+ presentDirection = .left
+ switchMenus = true
+ } else if distance < 0 && presentDirection == .left && sideMenuManager.menuRightNavigationController != nil {
+ presentDirection = .right
+ switchMenus = true
+ } else {
+ update(min(distance * direction, 1))
+ }
+ default:
+ interactive = false
+ view.transform = .identity
+ let velocity = pan.velocity(in: pan.view!).x * direction
+ view.transform = transform
+ if velocity >= 100 || velocity >= -50 && abs(distance) >= 0.5 {
+ // bug workaround: animation briefly resets after call to finishInteractiveTransition() but before animateTransition completion is called.
+ if ProcessInfo().operatingSystemVersion.majorVersion == 8 && percentComplete > 1 - CGFloat.ulpOfOne {
+ update(0.9999)
+ }
+ finish()
+ } else {
+ cancel()
+ }
+ }
+ }
+
+ @objc internal func handleHideMenuPan(_ pan: UIPanGestureRecognizer) {
+ if activeGesture == nil {
+ activeGesture = pan
+ } else if pan != activeGesture {
+ pan.isEnabled = false
+ pan.isEnabled = true
+ return
+ }
+
+ let translation = pan.translation(in: pan.view!)
+ let direction:CGFloat = presentDirection == .left ? -1 : 1
+ let distance = translation.x / menuWidth * direction
+
+ switch (pan.state) {
+
+ case .began:
+ interactive = true
+ mainViewController?.dismiss(animated: true, completion: nil)
+ case .changed:
+ update(max(min(distance, 1), 0))
+ default:
+ interactive = false
+ let velocity = pan.velocity(in: pan.view!).x * direction
+ if velocity >= 100 || velocity >= -50 && distance >= 0.5 {
+ // bug workaround: animation briefly resets after call to finishInteractiveTransition() but before animateTransition completion is called.
+ if ProcessInfo().operatingSystemVersion.majorVersion == 8 && percentComplete > 1 - CGFloat.ulpOfOne {
+ update(0.9999)
+ }
+ finish()
+ activeGesture = nil
+ } else {
+ cancel()
+ activeGesture = nil
+ }
+ }
+ }
+
+ @objc internal func handleHideMenuTap(_ tap: UITapGestureRecognizer) {
+ menuViewController?.dismiss(animated: true, completion: nil)
+ }
+
+ @discardableResult internal func hideMenuStart() -> SideMenuTransition {
+ let menuView = menuViewController?.view
+ let mainView = mainViewController?.view
+
+ mainView?.transform = .identity
+ mainView?.alpha = 1
+ mainView?.frame.origin = .zero
+ menuView?.transform = .identity
+ menuView?.frame.origin.y = 0
+ menuView?.frame.size.width = menuWidth
+ menuView?.frame.size.height = mainView?.frame.height ?? 0 // in case status bar height changed
+ var statusBarFrame = UIApplication.shared.statusBarFrame
+ let statusBarOffset = SideMenuManager.appScreenRect.size.height - (mainView?.frame.maxY ?? 0)
+ // For in-call status bar, height is normally 40, which overlaps view. Instead, calculate height difference
+ // of view and set height to fill in remaining space.
+ if statusBarOffset >= CGFloat.ulpOfOne {
+ statusBarFrame.size.height = statusBarOffset
+ }
+ statusBarView?.frame = statusBarFrame
+ statusBarView?.alpha = 0
+
+ switch sideMenuManager.menuPresentMode {
+
+ case .viewSlideOut:
+ menuView?.alpha = 1 - sideMenuManager.menuAnimationFadeStrength
+ menuView?.frame.origin.x = presentDirection == .left ? 0 : (mainView?.frame.width ?? 0) - menuWidth
+ menuView?.transform = CGAffineTransform(scaleX: sideMenuManager.menuAnimationTransformScaleFactor, y: sideMenuManager.menuAnimationTransformScaleFactor)
+
+ case .viewSlideInOut:
+ menuView?.alpha = 1
+ menuView?.frame.origin.x = presentDirection == .left ? -menuView!.frame.width : mainView!.frame.width
+
+ case .menuSlideIn:
+ menuView?.alpha = 1
+ menuView?.frame.origin.x = presentDirection == .left ? -menuView!.frame.width : mainView!.frame.width
+
+ case .menuDissolveIn:
+ menuView?.alpha = 0
+ menuView?.frame.origin.x = presentDirection == .left ? 0 : mainView!.frame.width - menuWidth
+ }
+
+ return self
+ }
+
+ @discardableResult internal func hideMenuComplete() -> SideMenuTransition {
+ let menuView = menuViewController?.view
+ let mainView = mainViewController?.view
+
+ tapView?.removeFromSuperview()
+ statusBarView?.removeFromSuperview()
+ mainView?.motionEffects.removeAll()
+ mainView?.layer.shadowOpacity = 0
+ menuView?.layer.shadowOpacity = 0
+ if let topNavigationController = mainViewController as? UINavigationController {
+ topNavigationController.interactivePopGestureRecognizer!.isEnabled = true
+ }
+ if let originalSuperview = originalSuperview, let mainView = mainViewController?.view {
+ originalSuperview.addSubview(mainView)
+ let y = originalSuperview.bounds.height - mainView.frame.size.height
+ mainView.frame.origin.y = max(y, 0)
+ }
+
+ originalSuperview = nil
+ mainViewController = nil
+
+ return self
+ }
+
+ @discardableResult internal func presentMenuStart() -> SideMenuTransition {
+ let menuView = menuViewController?.view
+ let mainView = mainViewController?.view
+
+ menuView?.alpha = 1
+ menuView?.transform = .identity
+ menuView?.frame.size.width = menuWidth
+ let size = SideMenuManager.appScreenRect.size
+ menuView?.frame.origin.x = presentDirection == .left ? 0 : size.width - menuWidth
+ mainView?.transform = .identity
+ mainView?.frame.size.width = size.width
+ let statusBarOffset = size.height - (menuView?.bounds.height ?? 0)
+ mainView?.bounds.size.height = size.height - max(statusBarOffset, 0)
+ mainView?.frame.origin.y = 0
+ var statusBarFrame = UIApplication.shared.statusBarFrame
+ // For in-call status bar, height is normally 40, which overlaps view. Instead, calculate height difference
+ // of view and set height to fill in remaining space.
+ if statusBarOffset >= CGFloat.ulpOfOne {
+ statusBarFrame.size.height = statusBarOffset
+ }
+ tapView?.transform = .identity
+ tapView?.bounds = mainView!.bounds
+ statusBarView?.frame = statusBarFrame
+ statusBarView?.alpha = 1
+
+ switch sideMenuManager.menuPresentMode {
+
+ case .viewSlideOut, .viewSlideInOut:
+ mainView?.layer.shadowColor = sideMenuManager.menuShadowColor.cgColor
+ mainView?.layer.shadowRadius = sideMenuManager.menuShadowRadius
+ mainView?.layer.shadowOpacity = sideMenuManager.menuShadowOpacity
+ mainView?.layer.shadowOffset = CGSize(width: 0, height: 0)
+ let direction:CGFloat = presentDirection == .left ? 1 : -1
+ mainView?.frame.origin.x = direction * (menuView!.frame.width)
+
+ case .menuSlideIn, .menuDissolveIn:
+ if sideMenuManager.menuBlurEffectStyle == nil {
+ menuView?.layer.shadowColor = sideMenuManager.menuShadowColor.cgColor
+ menuView?.layer.shadowRadius = sideMenuManager.menuShadowRadius
+ menuView?.layer.shadowOpacity = sideMenuManager.menuShadowOpacity
+ menuView?.layer.shadowOffset = CGSize(width: 0, height: 0)
+ }
+ mainView?.frame.origin.x = 0
+ }
+
+ if sideMenuManager.menuPresentMode != .viewSlideOut {
+ mainView?.transform = CGAffineTransform(scaleX: sideMenuManager.menuAnimationTransformScaleFactor, y: sideMenuManager.menuAnimationTransformScaleFactor)
+ if sideMenuManager.menuAnimationTransformScaleFactor > 1 {
+ tapView?.transform = mainView!.transform
+ }
+ mainView?.alpha = 1 - sideMenuManager.menuAnimationFadeStrength
+ }
+
+ return self
+ }
+
+ @discardableResult internal func presentMenuComplete() -> SideMenuTransition {
+ switch sideMenuManager.menuPresentMode {
+ case .menuSlideIn, .menuDissolveIn, .viewSlideInOut:
+ if let mainView = mainViewController?.view, sideMenuManager.menuParallaxStrength != 0 {
+ let horizontal = UIInterpolatingMotionEffect(keyPath: "center.x", type: .tiltAlongHorizontalAxis)
+ horizontal.minimumRelativeValue = -sideMenuManager.menuParallaxStrength
+ horizontal.maximumRelativeValue = sideMenuManager.menuParallaxStrength
+
+ let vertical = UIInterpolatingMotionEffect(keyPath: "center.y", type: .tiltAlongVerticalAxis)
+ vertical.minimumRelativeValue = -sideMenuManager.menuParallaxStrength
+ vertical.maximumRelativeValue = sideMenuManager.menuParallaxStrength
+
+ let group = UIMotionEffectGroup()
+ group.motionEffects = [horizontal, vertical]
+ mainView.addMotionEffect(group)
+ }
+ case .viewSlideOut: break;
+ }
+ if let topNavigationController = mainViewController as? UINavigationController {
+ topNavigationController.interactivePopGestureRecognizer!.isEnabled = false
+ }
+
+ return self
+ }
+
+ @objc internal func handleNotification(notification: NSNotification) {
+ guard menuViewController?.presentedViewController == nil &&
+ menuViewController?.presentingViewController != nil else {
+ return
+ }
+
+ if let originalSuperview = originalSuperview, let mainViewController = mainViewController {
+ originalSuperview.addSubview(mainViewController.view)
+ }
+
+ if notification.name == NSNotification.Name.UIApplicationDidEnterBackground {
+ hideMenuStart().hideMenuComplete()
+ menuViewController?.dismiss(animated: false, completion: nil)
+ return
+ }
+
+ UIView.animate(withDuration: sideMenuManager.menuAnimationDismissDuration,
+ delay: 0,
+ usingSpringWithDamping: sideMenuManager.menuAnimationUsingSpringWithDamping,
+ initialSpringVelocity: sideMenuManager.menuAnimationInitialSpringVelocity,
+ options: sideMenuManager.menuAnimationOptions,
+ animations: {
+ self.hideMenuStart()
+ }) { (finished) -> Void in
+ self.hideMenuComplete()
+ self.menuViewController?.dismiss(animated: false, completion: nil)
+ }
+ }
+
+}
+
+extension SideMenuTransition: UIViewControllerAnimatedTransitioning {
+
+ // animate a change from one viewcontroller to another
+ open func animateTransition(using transitionContext: UIViewControllerContextTransitioning) {
+
+ // get reference to our fromView, toView and the container view that we should perform the transition in
+ let container = transitionContext.containerView
+ // prevent any other menu gestures from firing
+ container.isUserInteractionEnabled = false
+
+ if let menuBackgroundColor = sideMenuManager.menuAnimationBackgroundColor {
+ container.backgroundColor = menuBackgroundColor
+ }
+
+ let fromViewController = transitionContext.viewController(forKey: UITransitionContextViewControllerKey.from)!
+ let toViewController = transitionContext.viewController(forKey: UITransitionContextViewControllerKey.to)!
+
+ // assign references to our menu view controller and the 'bottom' view controller from the tuple
+ // remember that our menuViewController will alternate between the from and to view controller depending if we're presenting or dismissing
+ mainViewController = presenting ? fromViewController : toViewController
+
+ let menuView = menuViewController!.view!
+ let topView = mainViewController!.view!
+
+ // prepare menu items to slide in
+ if presenting {
+ originalSuperview = topView.superview
+
+ // add the both views to our view controller
+ switch sideMenuManager.menuPresentMode {
+ case .viewSlideOut, .viewSlideInOut:
+ container.addSubview(menuView)
+ container.addSubview(topView)
+ case .menuSlideIn, .menuDissolveIn:
+ container.addSubview(topView)
+ container.addSubview(menuView)
+ }
+
+ if sideMenuManager.menuFadeStatusBar {
+ let statusBarView = UIView()
+ self.statusBarView = statusBarView
+ container.addSubview(statusBarView)
+ }
+
+ hideMenuStart()
+ }
+
+ let animate = {
+ if self.presenting {
+ self.presentMenuStart()
+ } else {
+ self.hideMenuStart()
+ }
+ }
+
+ let complete = {
+ container.isUserInteractionEnabled = true
+
+ // tell our transitionContext object that we've finished animating
+ if transitionContext.transitionWasCancelled {
+ let viewControllerForPresentedMenu = self.mainViewController
+
+ if self.presenting {
+ self.hideMenuComplete()
+ } else {
+ self.presentMenuComplete()
+ }
+
+ transitionContext.completeTransition(false)
+
+ if self.switchMenus {
+ self.switchMenus = false
+ viewControllerForPresentedMenu?.present(self.menuViewController!, animated: true, completion: nil)
+ }
+
+ return
+ }
+
+ if self.presenting {
+ self.presentMenuComplete()
+ transitionContext.completeTransition(true)
+ switch self.sideMenuManager.menuPresentMode {
+ case .viewSlideOut, .viewSlideInOut:
+ container.addSubview(topView)
+ case .menuSlideIn, .menuDissolveIn:
+ container.insertSubview(topView, at: 0)
+ }
+ if !self.sideMenuManager.menuPresentingViewControllerUserInteractionEnabled {
+ let tapView = UIView()
+ container.insertSubview(tapView, aboveSubview: topView)
+ tapView.bounds = container.bounds
+ tapView.center = topView.center
+ if self.sideMenuManager.menuAnimationTransformScaleFactor > 1 {
+ tapView.transform = topView.transform
+ }
+ self.tapView = tapView
+ }
+ if let statusBarView = self.statusBarView {
+ container.bringSubview(toFront: statusBarView)
+ }
+
+ return
+ }
+
+ self.hideMenuComplete()
+ transitionContext.completeTransition(true)
+ menuView.removeFromSuperview()
+ }
+
+ // perform the animation!
+ let duration = transitionDuration(using: transitionContext)
+ if interactive {
+ UIView.animate(withDuration: duration,
+ delay: duration, // HACK: If zero, the animation briefly flashes in iOS 11. UIViewPropertyAnimators (iOS 10+) may resolve this.
+ options: .curveLinear,
+ animations: {
+ animate()
+ }, completion: { (finished) in
+ complete()
+ })
+ } else {
+ UIView.animate(withDuration: duration,
+ delay: 0,
+ usingSpringWithDamping: sideMenuManager.menuAnimationUsingSpringWithDamping,
+ initialSpringVelocity: sideMenuManager.menuAnimationInitialSpringVelocity,
+ options: sideMenuManager.menuAnimationOptions,
+ animations: {
+ animate()
+ }) { (finished) -> Void in
+ complete()
+ }
+ }
+ }
+
+ // return how many seconds the transiton animation will take
+ open func transitionDuration(using transitionContext: UIViewControllerContextTransitioning?) -> TimeInterval {
+ if interactive {
+ return sideMenuManager.menuAnimationCompleteGestureDuration
+ }
+ return presenting ? sideMenuManager.menuAnimationPresentDuration : sideMenuManager.menuAnimationDismissDuration
+ }
+
+ open override func update(_ percentComplete: CGFloat) {
+ guard !switchMenus else {
+ return
+ }
+
+ super.update(percentComplete)
+ }
+
+}
+
+extension SideMenuTransition: UIViewControllerTransitioningDelegate {
+
+ // return the animator when presenting a viewcontroller
+ // rememeber that an animator (or animation controller) is any object that aheres to the UIViewControllerAnimatedTransitioning protocol
+ open func animationController(forPresented presented: UIViewController, presenting: UIViewController, source: UIViewController) -> UIViewControllerAnimatedTransitioning? {
+ self.presenting = true
+ presentDirection = presented == sideMenuManager.menuLeftNavigationController ? .left : .right
+ return self
+ }
+
+ // return the animator used when dismissing from a viewcontroller
+ open func animationController(forDismissed dismissed: UIViewController) -> UIViewControllerAnimatedTransitioning? {
+ presenting = false
+ return self
+ }
+
+ open func interactionControllerForPresentation(using animator: UIViewControllerAnimatedTransitioning) -> UIViewControllerInteractiveTransitioning? {
+ // if our interactive flag is true, return the transition manager object
+ // otherwise return nil
+ return interactive ? self : nil
+ }
+
+ open func interactionControllerForDismissal(using animator: UIViewControllerAnimatedTransitioning) -> UIViewControllerInteractiveTransitioning? {
+ return interactive ? self : nil
+ }
+
+}
fnp / wl-app.git / blobdiff