Swift iPad的侧面板

预期产出：

@L_616_0@

现在,我的输出产生：

电流输出：

如何删除圈子并添加按钮组？

import UIKit
import QuartzCore


public protocol FrostedSidebarDelegate{

    func sidebar(sidebar: FrostedSidebar,willShowOnScreenAnimated animated: Bool)

    func sidebar(sidebar: FrostedSidebar,didShowOnScreenAnimated animated: Bool)

    func sidebar(sidebar: FrostedSidebar,willDismissFromScreenAnimated animated: Bool)

    func sidebar(sidebar: FrostedSidebar,didDismissFromScreenAnimated animated: Bool)

    func sidebar(sidebar: FrostedSidebar,didTapItemATindex index: int)


    func sidebar(sidebar: FrostedSidebar,didEnable itemEnabled: Bool,itemATindex index: int)
}


var sharedSidebar: FrostedSidebar?


public enum SidebarItemSELEctionStyle{

    case None
    se Single

    case All
}


public class FrostedSidebar: UIViewController {


    public var width:                   CGFloat                     = 300.0
    /**
     If the sidebar should show from the right.
    */
    public var showFromRight:           Bool                        = false
    /**
     The speed at which the sidebar is presented/dismissed.
    */
    public var animationDuration:       CGFloat                     = 0.25
    /**
     The size of the sidebar items.
    */
    public var itemSize:                CGSize                      = CGSize(width: 200.0,height: 200.0)
    /**
     The BACkground color of the sidebar items.
    */
    public var itemBACkgroundColor:     UIColor                     = UIColor(white: 1,alpha: 0.25)
    /**
     The width of the ring around SELEcted sidebar items.
    */
    public var borderWidth:             CGFloat                     = 2
    /**
     The sidebar's delegate.
    */
    public var delegate:                FrostedSidebarDelegate?     = nil
    /**
     A Dictionary that holds the actions for each item index.
    */
    public var actionForIndex:          [Int : ()->()]              = [:]
    /**
     The indexes that are SELEcted and have rings around them.
    */
    public var SELEctedInDices:         NSMutableIndexSet           = NSMutableIndexSet()
    /**
     If the sidebar should be positioned beneath a navigation bar that is on screen.
    */
    public var adjustForNavigationBar:  Bool                        = false
    /**
     Returns whether or not the sidebar is currently being displayed
    */
    public var isCurrentlyOpen:         Bool                        = false
    /**
     The SELEction style for the sidebar.
    */
    public var SELEctionStyle:          SidebarItemSELEctionStyle   = .None{
        didSet{
            if case .All = SELEctionStyle{
                SELEctedInDices = NSMutableIndexSet(indexesInRange: NSRange(LOCATIOn: 0,length: images.count))
            }
        }
    }

    //MARK: Private Properties

    private var contentView:            UIScrollView                = UIScrollView()
    private var blurView:               UIVisualEffectView          = UIVisualEffectView(effect: UIBlurEffect(style: .Dark))
    private var dimView:                UIView                      = UIView()
    private var tapGesture:             UITapGestureRecognizer?     = nil
    private var images:                 [UIImage]                   = []
    private var borderColors:           [UIColor]?                  = nil
    private var itemViews:              [CalloutItem]               = []

    //MARK: Public Methods

    /**
     Returns an object initialized from data in a given unarchiver.
    */
    required public init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
    }


    /**
     Returns a sidebar initialized with the given data.

     - Parameter itemImages: The images that will be used for each item.
     - Parameter colors: The color of rings around each image.
     - Parameter SELEctionStyle: The SELEction style for the sidebar.

     - Precondition: `colors` is either `nil` or contains the same number of elements as `itemImages`.
    */
    public init(itemImages: [UIImage],colors: [UIColor]?,SELEctionStyle: SidebarItemSELEctionStylE){
        contentView.alwaysBounceHorizontal = false
        contentView.alwaysBounceVertical = true
        contentView.bounces = true
        contentView.clipsToBounds = false
        contentView.showsHorizontalScrollInDicator = false
        contentView.showsVerticalScrollInDicator = false
        if let colors = colors{
            assert(itemImages.count == colors.count,"If item color are supplied,the itemImages and colors arrays must be of the same size.")
        }

        self.SELEctionStyle = SELEctionStyle
        borderColors = colors
        images = itemImages

        for (index,imagE) in images.enumerate(){
            let view = CalloutItem(index: indeX)
            view.clipsToBounds = true
            view.imageView.image = image
            contentView.addSubview(view)
            itemViews += [view]
            if let borderColors = borderColors{
                if SELEctedInDices.containsIndex(indeX){
                    let color = borderColors[index]
                    view.layer.borderColor = color.CGColor
                }
            } else{
                view.layer.borderColor = UIColor.clearColor().CGColor
            }
        }

        super.init(nibName: nil,bundle: nil)
    }

    public override func shouldAutorotate() -> Bool {
        return true
    }

    public override func supportedInterfaceOrientations() -> UIInterfaceOrientationMask {
        return UIInterfaceOrientationMask.All
    }

    public override func viewWillTransitionToSize(size: CGSize,withTransitionCoordinator coordinator: UIViewControllerTransitionCoordinator) {
        super.viewWillTransitionToSize(size,withTransitionCoordinator: coordinator)
        if isViewLoaded(){
            dismissAnimated(false,completion: nil)
        }
    }

    public override func loadView() {
        super.loadView()
        view.BACkgroundColor = UIColor.clearColor()
        view.addSubview(dimView)
        view.addSubview(blurView)
        view.addSubview(contentView)
        tapGesture = UITapGestureRecognizer(target: self,action: #SELEctor(FrostedSidebar.handleTap(_:)))
        view.addGestureRecognizer(tapGesture!)
    }

    /**
     Shows the sidebar in a view controller.

     - Parameter viewController: The view controller in which to show the sidebar.
     - Parameter animated: If the sidebar should be animated.
    */
    public func showInViewController(viewController: UIViewController,animated: Bool){
        layoutItems()
        if let bar = sharedSidebar{
            bar.dismissAnimated(false,completion: nil)
        }

        delegate?.sidebar(self,willShowOnScreenAnimated: animated)

        sharedSidebar = self

        addToParentViewController(viewController,callingAppearanceMethods: truE)
        view.frame = viewController.view.bounds

        dimView.BACkgroundColor = UIColor.blackColor()
        dimView.alpha = 0
        dimView.frame = view.bounds

        let parentWidth = view.bounds.size.width
        var contentFrame = view.bounds
        contentFrame.origin.x = showFromRight ? parentWidth : -width
        contentFrame.size.width = width
        contentView.frame = contentFrame
        contentView.contentOffset = CGPoint(x: 0,y: 0)
        layoutItems()

        var blurFrame = CGRect(x: showFromRight ? view.bounds.size.width : 0,y: 0,width: 0,height: view.bounds.size.height)
        blurView.frame = blurFrame
        blurView.contentMode = showFromRight ? UIViewContentMode.TopRight : UIViewContentMode.TopLeft
        blurView.clipsToBounds = true
        view.insertSubview(blurView,belowSubview: contentView)

        contentFrame.origin.x = showFromRight ? parentWidth - width : 0
        blurFrame.origin.x = contentFrame.origin.x
        blurFrame.size.width = width

        let animations: () -> () = {
            self.contentView.frame = contentFrame
            self.blurView.frame = blurFrame
            self.dimView.alpha = 0.25
        }
        let completion: (Bool) -> Void = { finished in
            if finished{
                self.delegate?.sidebar(self,didShowOnScreenAnimated: animated)
            }
        }

        if animated{
            UIView.animateWithDuration(NSTimeInterval(animationDuration),delay: 0,options: UIViewAnimationOptions(),animations: animations,completion: completion)
        } else{
            animations()
            completion(true)
        }

        for (index,item) in itemViews.enumerate(){
            item.layer.transform = CATransform3DMakeScale(0.3,0.3,1)
            item.alpha = 0
            item.originalBACkgroundColor = itemBACkgroundColor
            item.layer.borderWidth = borderWidth
            animateSpringWithView(item,idx: index,initDelay: animationDuration)
        }

         self.isCurrentlyOpen = true
    }

    /**
     Dismisses the sidebar.

     - Parameter animated: If the sidebar should be animated.
     - Parameter completion: Completion handler called when the sidebar is dismissed.
    */
    public func dismissAnimated(animated: Bool,completion: ((Bool) -> Void)?){
        let completionBlock: (Bool) -> Void = {finished in
            self.removeFromParentViewControllerCallingAppearanceMethods(true)
            self.delegate?.sidebar(self,didDismissFromScreenAnimated: truE)
            self.layoutItems()
            if let completion = completion{
                completion(finished)
            }
        }
        delegate?.sidebar(self,willDismissFromScreenAnimated: animated)
        if animated{
            let parentWidth = view.bounds.size.width
            var contentFrame = contentView.frame
            contentFrame.origin.x = showFromRight ? parentWidth : -width
            var blurFrame = blurView.frame
            blurFrame.origin.x = showFromRight ? parentWidth : 0
            blurFrame.size.width = 0
            UIView.animateWithDuration(NSTimeInterval(animationDuration),options: UIViewAnimationOptions.beginFromCurrentState,animations: {
                self.contentView.frame = contentFrame
                self.blurView.frame = blurFrame
                self.dimView.alpha = 0
                },completion: completionBlock)
        } else{
            completionBlock(true)
        }

        self.isCurrentlyOpen = false
    }

    /**
     SELEcts the item at the given index.

     - Parameter index: The index of the item to SELEct.
    */
    public func SELEctItemATindex(index: int){
        let didEnable = !SELEctedInDices.containsIndex(indeX)
        if let borderColors = borderColors{
            let stroke = borderColors[index]
            let item = itemViews[index]
            if DidEnable{
                if case .Single = SELEctionStyle{
                    SELEctedInDices.removeAllIndexes()
                    for item in itemViews{
                        item.layer.borderColor = UIColor.clearColor().CGColor
                    }
                }
                item.layer.borderColor = stroke.CGColor

                let borderAnimation = CABasicAnimation(keyPath: "borderColor")
                borderAnimation.fromValue = UIColor.clearColor().CGColor
                borderAnimation.toValue = stroke.CGColor
                borderAnimation.duration = 0.5
                item.layer.addAnimation(borderAnimation,forKey: nil)
                SELEctedInDices.addIndex(indeX)

            } else{
                if case .None = SELEctionStyle{
                        item.layer.borderColor = UIColor.clearColor().CGColor
                        SELEctedInDices.removeIndex(indeX)
                }
            }
            let pathFrame = CGRect(x: -CGRectGetMidX(item.bounds),y: -CGRectGetMidY(item.bounds),width: item.bounds.size.width,height: item.bounds.size.height)
            let path = UIBezierPath(roundedRect: pathFrame,cornerRadius: item.layer.cornerRadius)
            let shapePosition = view.convertPoint(item.center,fromView: contentView)
            let circleShape = CAShapeLayer()
            circleShape.path = path.CGPath
            circleShape.position = shapePosition
            circleShape.fillColor = UIColor.clearColor().CGColor
            circleShape.opacity = 0
            circleShape.strokeColor = stroke.CGColor
            circleShape.lineWidth = borderWidth
            view.layer.addSublayer(circleShapE)

            let scaleAnimation = CABasicAnimation(keyPath: "transform.scale")
            scaleAnimation.fromValue = NSValue(CATransform3D: CATransform3DIdentity)
            scaleAnimation.toValue = NSValue(CATransform3D: CATransform3DMakeScale(2.5,2.5,1))
            let alphaAnimation = CABasicAnimation(keyPath: "opacity")
            alphaAnimation.fromValue = 1
            alphaAnimation.toValue = 0
            let animation = CAAnimationGroup()
            animation.animations = [scaleAnimation,alphaAnimation]
            animation.duration = 0.5
            animation.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionEaSEOut)
            circleShape.addAnimation(animation,forKey: nil)
        }
        if let action = actionForIndex[index]{
            action()
        }
        delegate?.sidebar(self,didTapItemATindex: indeX)
        delegate?.sidebar(self,didEnable: didEnable,itemATindex: indeX)
    }

    //MARK: Private Classes

    private class CalloutItem: UIView{
        var imageView:              UIImageView                 = UIImageView()
        var itemIndex:              Int
        var originalBACkgroundColor:UIColor? {
            didSet{
                BACkgroundColor = originalBACkgroundColor
            }
        }

        required init?(coder aDecoder: NSCoder) {
            itemIndex = 0
            super.init(coder: aDecoder)
        }

        init(index: int){
            imageView.BACkgroundColor = UIColor.clearColor()
            imageView.contentMode = UIViewContentMode.ScaleAspectFit
            itemIndex = index
            super.init(frame: CGRect.zero)
            addSubview(imageView)
        }

        override func layoutSubviews() {
            super.layoutSubviews()
            let inset: CGFloat = bounds.size.height/2
            imageView.frame = CGRect(x: 0,width: inset,height: inset)
            imageView.center = CGPoint(x: inset,y: inset)
        }

        override func touchesBegan(touches: Set<UITouch>,withEvent event: UIEvent?) {
            super.touchesBegan(touches,withEvent: event)

            var r: CGFloat = 0,g: CGFloat = 0,b: CGFloat = 0,a: CGFloat = 0
            let darkenFactor: CGFloat = 0.3
            var darkerColor: UIColor
            if originalBACkgroundColor != nil && originalBACkgroundColor!.getRed(&r,green: &g,blue: &b,alpha: &a){
                darkerColor = UIColor(red: max(r - darkenFactor,0),green: max(g - darkenFactor,blue: max(b - darkenFactor,alpha: a)
            } else if originalBACkgroundColor != nil && originalBACkgroundColor!.getWhite(&r,alpha: &a){
                darkerColor = UIColor(white: max(r - darkenFactor,alpha: a)
            } else{
                darkerColor = UIColor.clearColor()
                assert(false,"Item color should be RBG of White/Alpha in order to darken the button")
            }
            BACkgroundColor = darkerColor
        }

        override func touchesEnded(touches: Set<UITouch>,withEvent event: UIEvent?) {
            super.touchesEnded(touches,withEvent: event)
            BACkgroundColor = originalBACkgroundColor
        }

        override func touchesCancelled(touches: Set<UITouch>?,withEvent event: UIEvent?) {
            super.touchesCancelled(touches,withEvent: event)
            BACkgroundColor = originalBACkgroundColor
        }

    }

    //MARK: Private Methods

    private func animateSpringWithView(view: CalloutItem,idx: Int,initDelay: CGFloat){
        let delay: NSTimeInterval = NSTimeInterval(initDelay) + NSTimeInterval(idX) * 0.1
        UIView.animateWithDuration(0.5,delay: delay,usingSpringWithDamping: 10.0,initialSpringVeLocity: 50.0,animations: {
                view.layer.transform = CATransform3DIdentity
                view.alpha = 1
            },completion: nil)
    }

    @objc private func handleTap(recognizer: UITapGestureRecognizer){
        let LOCATIOn = recognizer.LOCATIOnInView(view)
        if !CGRectContainsPoint(contentView.frame,LOCATIOn){
            dismissAnimated(true,completion: nil)
        } else{
            let tapIndex = indexOfTap(recognizer.LOCATIOnInView(contentView))
            if let tapIndex = tapIndex{
                SELEctItemATindex(tapIndeX)
            }
        }
    }

    private func layoutSubviews(){
        let x = showFromRight ? parentViewController!.view.bounds.size.width - width : 0
        contentView.frame = CGRect(x: x,width: width,height: parentViewController!.view.bounds.size.height)
        blurView.frame = contentView.frame
        layoutItems()
    }

    private func layoutItems(){
        let leftPadding: CGFloat = (width - itemSize.width) / 2
        let toPPADding: CGFloat = leftPadding
        for (index,item) in itemViews.enumerate(){
            let idx: CGFloat = adjustForNavigationBar ? CGFloat(indeX) + 0.5 : CGFloat(indeX)

            let frame = CGRect(x: leftPadding,y: toPPADding*idx + itemSize.height*idx + toPPADding,width:itemSize.width,height: itemSize.height)
            item.frame = frame
            item.layer.cornerRadius = frame.size.width / 2
            item.layer.borderColor = UIColor.clearColor().CGColor
            item.alpha = 0
            if SELEctedInDices.containsIndex(indeX){
                if let borderColors = borderColors{
                    item.layer.borderColor = borderColors[index].CGColor
                }
            }
        }
        let itemCount = CGFloat(itemViews.count)
        if adjustForNavigationBar{
            contentView.contentSize = CGSizeMake(0,(itemCount + 0.5) * (itemSize.height + toPPADding) + toPPADding)
        } else {
            contentView.contentSize = CGSizeMake(0,itemCount * (itemSize.height + toPPADding) + toPPADding)
        }
    }

    private func indexOfTap(LOCATIOn: CGPoint) -> Int? {
        var index: Int?
        for (idx,item) in itemViews.enumerate(){
            if CGRectContainsPoint(item.frame,LOCATIOn){
                index = idx
                break
            }
        }
        return index
    }

    private func addToParentViewController(viewController: UIViewController,callingAppearanceMethods: Bool){
        if let _ = parentViewController{
            removeFromParentViewControllerCallingAppearanceMethods(callingAppearanceMethods)
        }
        if callingAppearanceMethods{
            beginAppearanCETransition(true,animated: falsE)
        }
        viewController.addChildViewController(self)
        viewController.view.addSubview(view)
        didMoveToParentViewController(self)
        if callingAppearanceMethods{
            endAppearanCETransition()
        }
    }

    private func removeFromParentViewControllerCallingAppearanceMethods(callAppearanceMethods: Bool){

        if callAppearanceMethods{
            beginAppearanCETransition(false,animated: falsE)
        }
        willMoveToParentViewController(nil)
        view.removeFromSuperview()
        removeFromParentViewController()
        if callAppearanceMethods{
            endAppearanCETransition()
        }
    }
}