small changes for format and memory issue.

Author: olddonkey

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
  }
 
  }

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)
 
  }
 

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)

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()
  }
  }
 }

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
  }
  }
 }