Merge pull request #1 from olddonkey/master

PierrePerrin · web-flow · commit 6620c621491a · 2017-08-03T00:22:58.000-04:00
diff --git a/ShadowView/ShadowView/ShadowView+BlurProcess.swift b/ShadowView/ShadowView/ShadowView+BlurProcess.swift
@@ -17,34 +17,34 @@ extension ShadowView{
         }
         
         let imageView = UIImageView()
-        imageView.frame.size = self.frame.size.scaled(by: shadowScale)
-        imageView.center = CGPoint(x:self.bounds.midX,y:self.bounds.midY)
+        imageView.frame.size = frame.size.scaled(by: shadowScale)
+        imageView.center = CGPoint(x:bounds.midX,y:bounds.midY)
         imageView.layer.masksToBounds = false
-        self.shadowImageView = imageView
-        self.insertSubview(imageView,at:0)
+        shadowImageView = imageView
+        insertSubview(imageView,at:0)
     }
     
     
     
     func updateShadow(){
         
         self.shadowImageView.image = nil
-        DispatchQueue.global(qos: DispatchQoS.QoSClass.utility).async {
-            self.createLayerImage()
+        DispatchQueue.global(qos: DispatchQoS.QoSClass.utility).async { [weak self] in
+            self?.createLayerImage()
         }
     }
     
     private func createLayerImage(){
         
-        let image = self.asImage
+        let image = asImage
         let containerLayer = CALayer()
         let imageSize = image.size
-        containerLayer.frame = CGRect(origin: .zero, size: imageSize.scaled(by:self.scaleImageConstant))
+        containerLayer.frame = CGRect(origin: .zero, size: imageSize.scaled(by:scaleImageConstant))
         containerLayer.backgroundColor = UIColor.clear.cgColor
         let blurImageLayer = CALayer()
         blurImageLayer.frame = CGRect(origin: .zero,size: imageSize)
         blurImageLayer.position = CGPoint(x:containerLayer.bounds.midX,y:containerLayer.bounds.midY)
-        blurImageLayer.contents = image.applyBlurWithRadius(0, tintColor: self.shadowColor, saturationDeltaFactor: self.shadowSaturation)?.cgImage
+        blurImageLayer.contents = image.applyBlurWithRadius(0, tintColor: shadowColor, saturationDeltaFactor: shadowSaturation)?.cgImage
         
         blurImageLayer.masksToBounds = false
         containerLayer.addSublayer(blurImageLayer)
@@ -53,15 +53,15 @@ extension ShadowView{
         
         let resizeImageConstant :CGFloat = 1
         guard let resizedContainerImage = containerImage.resized(withPercentage: resizeImageConstant),
-            let blurredImage = resizedContainerImage.applyBlur(blurRadius: self.blurRadius)
+            let blurredImage = resizedContainerImage.applyBlur(blurRadius: blurRadius)
             else {
                 return
         }
         
-        self.layer.masksToBounds = false
+        layer.masksToBounds = false
         
-        DispatchQueue.main.async {
-            self.shadowImageView?.image = blurredImage
+        DispatchQueue.main.async { [weak self] in
+            self?.shadowImageView?.image = blurredImage
         }
         
     }
diff --git a/ShadowView/ShadowView/ShadowView.swift b/ShadowView/ShadowView/ShadowView.swift
@@ -10,60 +10,53 @@ import UIKit
 
 class ShadowView: UIView {
     
-    lazy var blurOperationQueue : OperationQueue = {
-        let operationQueue = OperationQueue.init()
-        operationQueue.maxConcurrentOperationCount = 1
-        operationQueue.qualityOfService = .userInteractive
-        return operationQueue
-    }()
-    internal var blurWork : DispatchWorkItem?
     internal var blurRadius :CGFloat = 5.0
     var shadowImageView : UIImageView!
     let scaleImageConstant :CGFloat = 3
     var correctShadowScale : CGFloat{
-        return self.shadowScale + scaleImageConstant - 1
+        return shadowScale + scaleImageConstant - 1
     }
     
     override init(frame: CGRect) {
         super.init(frame: frame)
-        self.addImageView()
+        addImageView()
     }
     
     required init?(coder aDecoder: NSCoder) {
         super.init(coder: aDecoder)
-        self.addImageView()
+        addImageView()
     }
     
     @IBInspectable var shadowScale : CGFloat = 1{
         didSet{
-            self.layoutSubviews()
+            layoutSubviews()
         }
     }
     
     @IBInspectable var shadowSaturation : CGFloat = 1{
         didSet{
-            self.updateShadow()
+            updateShadow()
         }
     }
     private var shadowTintColor : UIColor?
     override var shadowColor: UIColor?{
         get{
             return shadowTintColor
         }set{
-            self.shadowTintColor = newValue
+            shadowTintColor = newValue
         }
     }
     
     override public var shadowOffset : CGSize{
         didSet{
-            self.layoutSubviews()
+            layoutSubviews()
         }
     }
     
     override public var shadowRadius : CGFloat{
         set{
-            self.blurRadius = newValue
-            self.updateShadow()
+            blurRadius = newValue
+            updateShadow()
         }
         get{
             return blurRadius
@@ -72,24 +65,24 @@ class ShadowView: UIView {
     
     override var shadowOpacity: Float{
         set{
-            self.shadowImageView.alpha = CGFloat(newValue)
+            shadowImageView.alpha = CGFloat(newValue)
         }
         get{
-            return Float(self.shadowImageView.alpha)
+            return Float(shadowImageView.alpha)
         }
     }
     
     override func didMoveToSuperview() {
         super.didMoveToSuperview()
-        self.updateShadow()
+        updateShadow()
     }
     
     //Reload the image if the view changed.
     override func layoutSubviews() {
         super.layoutSubviews()
         
-        self.shadowImageView.frame.size = self.frame.size.scaled(by: correctShadowScale)
-        self.shadowImageView.center = CGPoint(x:self.bounds.midX + self.shadowOffset.width,y:self.bounds.midY + self.shadowOffset.height)
+        shadowImageView.frame.size = frame.size.scaled(by: correctShadowScale)
+        shadowImageView.center = CGPoint(x:bounds.midX + shadowOffset.width,y:bounds.midY + shadowOffset.height)
         
     }
     
diff --git a/ShadowView/ShadowView/UIImage+Size.swift b/ShadowView/ShadowView/UIImage+Size.swift
@@ -34,7 +34,7 @@ extension UIImage{
     
     func applyBlur(blurRadius:CGFloat) -> UIImage?{
         
-        guard let ciImage = CIImage.init(image: self) else{return nil}
+        guard let ciImage = CIImage(image: self) else {return nil}
         
         if let filter = CIFilter(name: "CIGaussianBlur") {
             
@@ -46,8 +46,8 @@ extension UIImage{
                     ??  EAGLContext(api: EAGLRenderingAPI.openGLES1)
             
             let context = eaglContext == nil ?
-                CIContext.init(options: nil)
-                : CIContext.init(eaglContext: eaglContext!)
+                CIContext(options: nil)
+                : CIContext(eaglContext: eaglContext!)
             
             if let output = filter.outputImage,
                 let cgimg = context.createCGImage(output, from: ciImage.extent)
diff --git a/ShadowView/ShadowView/UIView+Image.swift b/ShadowView/ShadowView/UIView+Image.swift
@@ -20,14 +20,14 @@ extension CALayer{
     
     ///Returns a UIImage copy of the layer
     var asImage : UIImage{
-        UIGraphicsBeginImageContext(self.frame.size)
-        self.render(in: UIGraphicsGetCurrentContext()!)
+        UIGraphicsBeginImageContext(frame.size)
+        render(in: UIGraphicsGetCurrentContext()!)
         let image = UIGraphicsGetImageFromCurrentImageContext()
         UIGraphicsEndImageContext()
         if let cgImage = image?.cgImage {
-            return UIImage.init(cgImage: cgImage)
+            return UIImage(cgImage: cgImage)
         } else {
-            return UIImage.init()
+            return UIImage()
         }
     }
 }
diff --git a/ShadowView/ShadowView/UIView+Shadow.swift b/ShadowView/ShadowView/UIView+Shadow.swift
@@ -12,49 +12,49 @@ extension UIView{
     
     @IBInspectable public var shadowRadius : CGFloat{
         set{
-            self.layer.shadowRadius = newValue
+            layer.shadowRadius = newValue
             layer.masksToBounds = newValue < 0
         }
         get{
-            return self.layer.shadowRadius
+            return layer.shadowRadius
         }
     }
     
     @IBInspectable public var shadowOffset : CGSize{
         set{
-            self.layer.shadowOffset = newValue
+            layer.shadowOffset = newValue
         }
         get{
-            return self.layer.shadowOffset
+            return layer.shadowOffset
         }
     }
     
     
     @IBInspectable public var shadowColor : UIColor?{
         set{
-            self.layer.shadowColor = newValue?.cgColor
+            layer.shadowColor = newValue?.cgColor
         }
         get{
-            return UIColor.init(cgColor: self.layer.shadowColor ?? UIColor().cgColor)
+            return UIColor(cgColor: layer.shadowColor ?? UIColor().cgColor)
         }
     }
     
     @IBInspectable public var shadowOpacity : Float{
         set{
-            self.layer.shadowOpacity = newValue
+            layer.shadowOpacity = newValue
             layer.masksToBounds = newValue < 0
         }
         get{
-            return self.layer.shadowOpacity
+            return layer.shadowOpacity
         }
     }
     
     @IBInspectable var shadowPath : CGPath?{
         set{
-            self.layer.shadowPath = newValue
+            layer.shadowPath = newValue
         }
         get{
-            return self.layer.shadowPath
+            return layer.shadowPath
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -10,60 +10,53 @@ import UIKit`
`10`	`10`
`11`	`11`	`class ShadowView: UIView {`
`12`	`12`
`13`		`- lazy var blurOperationQueue : OperationQueue = {`
`14`		`- let operationQueue = OperationQueue.init()`
`15`		`- operationQueue.maxConcurrentOperationCount = 1`
`16`		`- operationQueue.qualityOfService = .userInteractive`
`17`		`- return operationQueue`
`18`		`- }()`
`19`		`- internal var blurWork : DispatchWorkItem?`
`20`	`13`	`internal var blurRadius :CGFloat = 5.0`
`21`	`14`	`var shadowImageView : UIImageView!`
`22`	`15`	`let scaleImageConstant :CGFloat = 3`
`23`	`16`	`var correctShadowScale : CGFloat{`
`24`		`- return self.shadowScale + scaleImageConstant - 1`
	`17`	`+ return shadowScale + scaleImageConstant - 1`
`25`	`18`	`}`
`26`	`19`
`27`	`20`	`override init(frame: CGRect) {`
`28`	`21`	`super.init(frame: frame)`
`29`		`- self.addImageView()`
	`22`	`+ addImageView()`
`30`	`23`	`}`
`31`	`24`
`32`	`25`	`required init?(coder aDecoder: NSCoder) {`
`33`	`26`	`super.init(coder: aDecoder)`
`34`		`- self.addImageView()`
	`27`	`+ addImageView()`
`35`	`28`	`}`
`36`	`29`
`37`	`30`	`@IBInspectable var shadowScale : CGFloat = 1{`
`38`	`31`	`didSet{`
`39`		`- self.layoutSubviews()`
	`32`	`+ layoutSubviews()`
`40`	`33`	`}`
`41`	`34`	`}`
`42`	`35`
`43`	`36`	`@IBInspectable var shadowSaturation : CGFloat = 1{`
`44`	`37`	`didSet{`
`45`		`- self.updateShadow()`
	`38`	`+ updateShadow()`
`46`	`39`	`}`
`47`	`40`	`}`
`48`	`41`	`private var shadowTintColor : UIColor?`
`49`	`42`	`override var shadowColor: UIColor?{`
`50`	`43`	`get{`
`51`	`44`	`return shadowTintColor`
`52`	`45`	`}set{`
`53`		`- self.shadowTintColor = newValue`
	`46`	`+ shadowTintColor = newValue`
`54`	`47`	`}`
`55`	`48`	`}`
`56`	`49`
`57`	`50`	`override public var shadowOffset : CGSize{`
`58`	`51`	`didSet{`
`59`		`- self.layoutSubviews()`
	`52`	`+ layoutSubviews()`
`60`	`53`	`}`
`61`	`54`	`}`
`62`	`55`
`63`	`56`	`override public var shadowRadius : CGFloat{`
`64`	`57`	`set{`
`65`		`- self.blurRadius = newValue`
`66`		`- self.updateShadow()`
	`58`	`+ blurRadius = newValue`
	`59`	`+ updateShadow()`
`67`	`60`	`}`
`68`	`61`	`get{`
`69`	`62`	`return blurRadius`
`@@ -72,24 +65,24 @@ class ShadowView: UIView {`
`72`	`65`
`73`	`66`	`override var shadowOpacity: Float{`
`74`	`67`	`set{`
`75`		`- self.shadowImageView.alpha = CGFloat(newValue)`
	`68`	`+ shadowImageView.alpha = CGFloat(newValue)`
`76`	`69`	`}`
`77`	`70`	`get{`
`78`		`- return Float(self.shadowImageView.alpha)`
	`71`	`+ return Float(shadowImageView.alpha)`
`79`	`72`	`}`
`80`	`73`	`}`
`81`	`74`
`82`	`75`	`override func didMoveToSuperview() {`
`83`	`76`	`super.didMoveToSuperview()`
`84`		`- self.updateShadow()`
	`77`	`+ updateShadow()`
`85`	`78`	`}`
`86`	`79`
`87`	`80`	`//Reload the image if the view changed.`
`88`	`81`	`override func layoutSubviews() {`
`89`	`82`	`super.layoutSubviews()`
`90`	`83`
`91`		`- self.shadowImageView.frame.size = self.frame.size.scaled(by: correctShadowScale)`
`92`		`- self.shadowImageView.center = CGPoint(x:self.bounds.midX + self.shadowOffset.width,y:self.bounds.midY + self.shadowOffset.height)`
	`84`	`+ shadowImageView.frame.size = frame.size.scaled(by: correctShadowScale)`
	`85`	`+ shadowImageView.center = CGPoint(x:bounds.midX + shadowOffset.width,y:bounds.midY + shadowOffset.height)`
`93`	`86`
`94`	`87`	`}`
`95`	`88`
Original file line number	Diff line number	Diff line change
`@@ -20,14 +20,14 @@ extension CALayer{`
`20`	`20`
`21`	`21`	`///Returns a UIImage copy of the layer`
`22`	`22`	`var asImage : UIImage{`
`23`		`- UIGraphicsBeginImageContext(self.frame.size)`
`24`		`- self.render(in: UIGraphicsGetCurrentContext()!)`
	`23`	`+ UIGraphicsBeginImageContext(frame.size)`
	`24`	`+ render(in: UIGraphicsGetCurrentContext()!)`
`25`	`25`	`let image = UIGraphicsGetImageFromCurrentImageContext()`
`26`	`26`	`UIGraphicsEndImageContext()`
`27`	`27`	`if let cgImage = image?.cgImage {`
`28`		`- return UIImage.init(cgImage: cgImage)`
	`28`	`+ return UIImage(cgImage: cgImage)`
`29`	`29`	`} else {`
`30`		`- return UIImage.init()`
	`30`	`+ return UIImage()`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,49 +12,49 @@ extension UIView{`
`12`	`12`
`13`	`13`	`@IBInspectable public var shadowRadius : CGFloat{`
`14`	`14`	`set{`
`15`		`- self.layer.shadowRadius = newValue`
	`15`	`+ layer.shadowRadius = newValue`
`16`	`16`	`layer.masksToBounds = newValue < 0`
`17`	`17`	`}`
`18`	`18`	`get{`
`19`		`- return self.layer.shadowRadius`
	`19`	`+ return layer.shadowRadius`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`@IBInspectable public var shadowOffset : CGSize{`
`24`	`24`	`set{`
`25`		`- self.layer.shadowOffset = newValue`
	`25`	`+ layer.shadowOffset = newValue`
`26`	`26`	`}`
`27`	`27`	`get{`
`28`		`- return self.layer.shadowOffset`
	`28`	`+ return layer.shadowOffset`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`	`32`
`33`	`33`	`@IBInspectable public var shadowColor : UIColor?{`
`34`	`34`	`set{`
`35`		`- self.layer.shadowColor = newValue?.cgColor`
	`35`	`+ layer.shadowColor = newValue?.cgColor`
`36`	`36`	`}`
`37`	`37`	`get{`
`38`		`- return UIColor.init(cgColor: self.layer.shadowColor ?? UIColor().cgColor)`
	`38`	`+ return UIColor(cgColor: layer.shadowColor ?? UIColor().cgColor)`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`@IBInspectable public var shadowOpacity : Float{`
`43`	`43`	`set{`
`44`		`- self.layer.shadowOpacity = newValue`
	`44`	`+ layer.shadowOpacity = newValue`
`45`	`45`	`layer.masksToBounds = newValue < 0`
`46`	`46`	`}`
`47`	`47`	`get{`
`48`		`- return self.layer.shadowOpacity`
	`48`	`+ return layer.shadowOpacity`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`@IBInspectable var shadowPath : CGPath?{`
`53`	`53`	`set{`
`54`		`- self.layer.shadowPath = newValue`
	`54`	`+ layer.shadowPath = newValue`
`55`	`55`	`}`
`56`	`56`	`get{`
`57`		`- return self.layer.shadowPath`
	`57`	`+ return layer.shadowPath`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`	`}`