updated helper

Signed-off-by: Matt Bruce <matt.bruce@verizon.com>

VDSSample/Classes/Helper.swift

@@ -10,24 +10,114 @@ import VDS
 import UIKit
 
 extension UIView {
+    
+    public class ViewConstraints {
+        public var topConstraint: NSLayoutConstraint?
+        public var leadingConstraint: NSLayoutConstraint?
+        public var trailingConstraint: NSLayoutConstraint?
+        public var bottomConstraint: NSLayoutConstraint?
+        public weak var view: UIView?
+        public var allConstraints: [NSLayoutConstraint] {
+            [topConstraint, leadingConstraint, trailingConstraint, bottomConstraint].compactMap{ $0 }
+        }
+        
+        public var isActive: Bool = true {
+            didSet {
+                allConstraints.forEach { $0.isActive = isActive }
+            }
+        }
+        
+        public init(view: UIView){
+            self.view = view
+        }
+        
+        public func removeConstraint(edges: [UIRectEdge]) {
+            edges.forEach { edge in
+                switch edge {
+                case .all:
+                    if let leadingConstraint {
+                        view?.removeConstraint(leadingConstraint)
+                    }
+                    if let trailingConstraint {
+                        view?.removeConstraint(trailingConstraint)
+                    }
+                    if let topConstraint {
+                        view?.removeConstraint(topConstraint)
+                    }
+                    if let bottomConstraint {
+                        view?.removeConstraint(bottomConstraint)
+                    }                    
+                case .left:
+                    if let leadingConstraint {
+                        view?.removeConstraint(leadingConstraint)
+                    }
+                case .right:
+                    if let trailingConstraint {
+                        view?.removeConstraint(trailingConstraint)
+                    }
+                case .top:
+                    if let topConstraint {
+                        view?.removeConstraint(topConstraint)
+                    }
+                case .bottom:
+                    if let bottomConstraint {
+                        view?.removeConstraint(bottomConstraint)
+                    }
+                default:
+                    break
+                }
+            }
+        }
+    }
+
     public static func makeWrapper(for view: UIView, edgeSpacing: CGFloat = 0.0, isTrailing: Bool = true) -> UIView {
+        return makeWrappedView(for: view, edgeSpacing: edgeSpacing, isTrailing: isTrailing).view
+    }
+    
+    public class WrappedViewHelper {
+        public var view: UIView
+        public var constraints: ViewConstraints
+        
+        var viewPadding: CGFloat = 0 {
+            didSet {
+                constraints.topConstraint?.constant = viewPadding
+                constraints.leadingConstraint?.constant = viewPadding
+                constraints.trailingConstraint?.constant = -viewPadding
+                constraints.bottomConstraint?.constant = -viewPadding
+            }
+        }
+        
+        public init(view: UIView, constraints: ViewConstraints) {
+            self.view = view
+            self.constraints = constraints
+        }
+    }
+    
+    public static func makeWrappedView(for view: UIView, edgeSpacing: CGFloat = 0.0, isTrailing: Bool = true) -> WrappedViewHelper {
         let wrapper = UIView().with {
             $0.translatesAutoresizingMaskIntoConstraints = false
         }
         wrapper.addSubview(view)
-        view
+        let constraints = view.addConstraints(to: wrapper, edgeSpacing: edgeSpacing, isTrailing: isTrailing)
-            .pinTop(edgeSpacing)
+        return WrappedViewHelper(view: wrapper, constraints: constraints)
-            .pinBottom(edgeSpacing)
+    }
+    
+    public func addConstraints(to view: UIView, edgeSpacing: CGFloat = 0.0, isTrailing: Bool = true) -> ViewConstraints {
+        let constraints = ViewConstraints(view: self)
+        constraints.topConstraint = topAnchor.constraint(equalTo: view.topAnchor)
+        constraints.bottomConstraint = bottomAnchor.constraint(equalTo: view.bottomAnchor)
 
         if isTrailing {
-            view.pinLeading(edgeSpacing)
+            constraints.leadingConstraint = leadingAnchor.constraint(equalTo: view.leadingAnchor)
-            view.trailingAnchor.constraint(lessThanOrEqualTo: wrapper.trailingAnchor).isActive = true
+            constraints.trailingConstraint = trailingAnchor.constraint(lessThanOrEqualTo: view.trailingAnchor)
+            
         } else {
-            view.leadingAnchor.constraint(greaterThanOrEqualTo: wrapper.leadingAnchor).isActive = true
+            constraints.leadingConstraint = leadingAnchor.constraint(equalTo: view.leadingAnchor)
-            view.pinTrailing(edgeSpacing)
+            constraints.trailingConstraint = trailingAnchor.constraint(equalTo: view.trailingAnchor)
         }
-        return wrapper
+        constraints.isActive = true
-    }
+        return constraints
+    }    
 }
 
 extension ButtonBase {

VDSSample/ViewControllers/BaseViewController.swift

@@ -116,9 +116,13 @@ public class BaseViewController<Component: UIView>: UIViewController, Initable {
     
     lazy var debugViewSwitch = Toggle().with{
         $0.onChange =  { [weak self] sender in
-            self?.component.debugBorder(show: sender.isOn, color: .blue)
+            self?.showDebug(show: sender.isOn)
         }
     }
+    
+    open func showDebug(show: Bool) {
+        self.component.debugBorder(show: show, color: .blue)
+    }
 
     public var contentView: UIView = {
         return UIView().with {

VDSSample/ViewControllers/DropShawdowViewController.swift

@@ -60,53 +60,102 @@ class DropShadowViewController: BaseViewController<View> {
     var shadowDarkColor: UIColor.VDSColor = .backgroundPrimaryLight { didSet { updateView() }}
     var viewLightColor: UIColor.VDSColor = .paletteGray65 { didSet { updateView() }}
     var viewDarkColor: UIColor.VDSColor = .backgroundPrimaryLight { didSet { updateView() }}
-
+    
+    var viewPaddingRange = Slider()
     var viewRadiusRange = Slider()
     var opacityRange = Slider()
     var radiusRange = Slider()
     var offsetXRange = Slider()
     var offsetYRange = Slider()
-
+    var viewSpacerRange = Slider()
-    var viewSize: CGFloat = 100.0
     
+    var viewSize: CGFloat = 100.0
+    var wrappedHelper: UIView.WrappedViewHelper!
+    var secondView = View()
+    var thirdView = View()
+
     lazy var dropShadowLightColorPickerSelectorView = {
         PickerSelectorView(title: "",
-                            picker: self.picker,
+                           picker: self.picker,
                            items: UIColor.VDSColor.allCases)
     }()
-
+    
     lazy var dropShadowDarkColorPickerSelectorView = {
         PickerSelectorView(title: "",
-                            picker: self.picker,
+                           picker: self.picker,
                            items: UIColor.VDSColor.allCases)
     }()
-
+    
     lazy var viewLightColorPickerSelectorView = {
         PickerSelectorView(title: "",
-                            picker: self.picker,
+                           picker: self.picker,
                            items: UIColor.VDSColor.allCases)
     }()
-
+    
     lazy var viewDarkColorPickerSelectorView = {
         PickerSelectorView(title: "",
-                            picker: self.picker,
+                           picker: self.picker,
                            items: UIColor.VDSColor.allCases)
     }()
+    
+    var spacer: Float = 0 {
+        didSet {
+            spacings.forEach{ $0.constant = CGFloat(spacer) }
+        }
+    }
 
-    let spacer: Float = 50
+    var spacings = [NSLayoutConstraint]()
+    
     override func viewDidLoad() {
         super.viewDidLoad()
+        
+        wrappedHelper = UIView.makeWrappedView(for: component, isTrailing: false)
+        contentTopView.addSubview(wrappedHelper.view)
+        contentTopView.addSubview(secondView)
+        contentTopView.addSubview(thirdView)
+
         component.widthAnchor.constraint(equalToConstant: viewSize).isActive = true
         component.heightAnchor.constraint(equalToConstant: viewSize).isActive = true
-        addContentTopView(view: .makeWrapper(for: component, edgeSpacing: Double(spacer)), edgeSpacing: 0.0)
+        
+        secondView.widthAnchor.constraint(equalToConstant: viewSize).isActive = true
+        secondView.heightAnchor.constraint(equalToConstant: viewSize).isActive = true
+
+        thirdView.widthAnchor.constraint(equalToConstant: viewSize).isActive = true
+        thirdView.heightAnchor.constraint(equalToConstant: viewSize).isActive = true
+        
+        wrappedHelper.view.pinTop().pinLeading()
+        secondView.pinTop()
+        thirdView.pinLeading().pinBottom()
+        
+        secondView.trailingAnchor.constraint(lessThanOrEqualTo: contentTopView.trailingAnchor).isActive = true
+        secondView.bottomAnchor.constraint(lessThanOrEqualTo: contentTopView.bottomAnchor).isActive = true
+        thirdView.trailingAnchor.constraint(lessThanOrEqualTo: contentTopView.trailingAnchor).isActive = true
+        
+        spacings.append(thirdView.topAnchor.constraint(equalTo: wrappedHelper.view.bottomAnchor))
+        spacings.append(secondView.leadingAnchor.constraint(equalTo: wrappedHelper.view.trailingAnchor))
+        spacings.forEach{ $0.isActive = true }
+
+        spacer = 10
+        wrappedHelper.viewPadding = 10
+        
         setupPicker()
         setupModel()
         updateView()
     }
     
+    override func showDebug(show: Bool) {
+        super.showDebug(show: show)
+        component.debugBorder(show: false)
+        wrappedHelper.view.debugBorder(show: show, color: .green)
+        secondView.debugBorder(show: show, color: .green)
+        thirdView.debugBorder(show: show, color: .green)
+    }
+        
     override func setupForm(){
         super.setupForm()
         addFormRow(label: "Surface", view: surfacePickerSelectorView)
+        addFormRow(label: "Space Between Views", view: viewSpacerRange)
+        addFormRow(label: "View Padding", view: viewPaddingRange)
         addFormRow(label: "View Corner Radius", view: viewRadiusRange)
         addFormRow(label: "View Light", view: viewLightColorPickerSelectorView)
         addFormRow(label: "View Dark", view: viewDarkColorPickerSelectorView)
@@ -145,6 +194,14 @@ class DropShadowViewController: BaseViewController<View> {
         offsetYRange.publisher(for: .valueChanged).sink(receiveValue: { [weak self] slider in
             self?.updateView()
         }).store(in: &subscribers)
+                
+        viewPaddingRange.maximumValue = 50.0
+        viewPaddingRange.minimumValue = 0.0
+        viewPaddingRange.value = 2.0
+        viewPaddingRange.publisher(for: .valueChanged).sink(receiveValue: { [weak self] slider in
+            self?.wrappedHelper.viewPadding = CGFloat(slider.value)
+            self?.updateView()
+        }).store(in: &subscribers)
         
         viewRadiusRange.maximumValue = Float(viewSize / 2)
         viewRadiusRange.minimumValue = 0
@@ -153,6 +210,13 @@ class DropShadowViewController: BaseViewController<View> {
             self?.updateView()
         }).store(in: &subscribers)
         
+        viewSpacerRange.maximumValue = 50
+        viewSpacerRange.minimumValue = 0
+        viewSpacerRange.value = 10.0        
+        viewSpacerRange.publisher(for: .valueChanged).sink(receiveValue: { [weak self] slider in
+            self?.spacer = slider.value
+        }).store(in: &subscribers)
+                
         dropShadowLightColorPickerSelectorView.text = shadowLightColor.rawValue
         dropShadowDarkColorPickerSelectorView.text = shadowDarkColor.rawValue
         viewLightColorPickerSelectorView.text = viewLightColor.rawValue
@@ -166,13 +230,16 @@ class DropShadowViewController: BaseViewController<View> {
     
     override func updateView() {
         let surface = surfacePickerSelectorView.selectedItem
-        let dropshadowColorConfiguration = SurfaceColorConfiguration(shadowLightColor.uiColor, shadowDarkColor.uiColor)
+        let dropshadowColor = SurfaceColorConfiguration(shadowLightColor.uiColor, shadowDarkColor.uiColor).getColor(surface)
-        let viewColorConfiguration = SurfaceColorConfiguration(viewLightColor.uiColor, viewDarkColor.uiColor)
+        let viewColor = SurfaceColorConfiguration(viewLightColor.uiColor, viewDarkColor.uiColor).getColor(surface)
+        
+        secondView.backgroundColor = .red
+        thirdView.backgroundColor = .purple
         
         component.layer.cornerRadius = CGFloat(viewRadiusRange.value)
         component.layer.masksToBounds = false
-        component.backgroundColor = viewColorConfiguration.getColor(surface)
+        component.backgroundColor = viewColor
-        component.layer.shadowColor = dropshadowColorConfiguration.getColor(surface).cgColor
+        component.layer.shadowColor = dropshadowColor.cgColor
         component.layer.shadowOpacity = Float(opacityRange.value)
         component.layer.shadowOffset = .init(width: CGFloat(offsetXRange.value), height: CGFloat(offsetYRange.value))
         component.layer.shadowRadius = CGFloat(radiusRange.value)