Utils Cleanup

Source/Charts/Utils/Fill.swift

@@ -27,79 +27,25 @@ public enum FillType: Int
 @objc(ChartFill)
 open class Fill: NSObject
 {
-    private var _type: FillType = FillType.empty
-    private var _color: CGColor?
-    private var _gradient: CGGradient?
-    private var _gradientAngle: CGFloat = 0.0
-    private var _gradientStartOffsetPercent: CGPoint = CGPoint()
-    private var _gradientStartRadiusPercent: CGFloat = 0.0
-    private var _gradientEndOffsetPercent: CGPoint = CGPoint()
-    private var _gradientEndRadiusPercent: CGFloat = 0.0
-    private var _image: CGImage?
-    private var _layer: CGLayer?
-
     // MARK: Properties
-
-    @objc open var type: FillType
-    {
-        return _type
-    }
-
-    @objc open var color: CGColor?
-    {
-        return _color
-    }
-
-    @objc open var gradient: CGGradient?
-    {
-        return _gradient
-    }
-
-    @objc open var gradientAngle: CGFloat
-    {
-        return _gradientAngle
-    }
-
-    @objc open var gradientStartOffsetPercent: CGPoint
-    {
-        return _gradientStartOffsetPercent
-    }
-
-    @objc open var gradientStartRadiusPercent: CGFloat
-    {
-        return _gradientStartRadiusPercent
-    }
-
-    @objc open var gradientEndOffsetPercent: CGPoint
-    {
-        return _gradientEndOffsetPercent
-    }
-
-    @objc open var gradientEndRadiusPercent: CGFloat
-    {
-        return _gradientEndRadiusPercent
-    }
-
-    @objc open var image: CGImage?
-    {
-        return _image
-    }
-
-    @objc open var layer: CGLayer?
-    {
-        return _layer
-    }
-
+
+    @objc open private(set) var type: FillType = .empty
+    @objc open private(set) var color: CGColor?
+    @objc open private(set) var gradient: CGGradient?
+    @objc open private(set) var gradientAngle: CGFloat = 0.0
+    @objc open private(set) var gradientStartOffsetPercent = CGPoint.zero
+    @objc open private(set) var gradientStartRadiusPercent: CGFloat = 0.0
+    @objc open private(set) var gradientEndOffsetPercent = CGPoint.zero
+    @objc open private(set) var gradientEndRadiusPercent: CGFloat = 0.0
+    @objc open private(set) var image: CGImage?
+    @objc open private(set) var layer: CGLayer?
+
     // MARK: Constructors
-
-    public override init()
-    {
-    }
-
+
     @objc public init(CGColor: CGColor)
     {
-        _type = .color
-        _color = CGColor
+        type = .color
+        color = CGColor
     }
 
     @objc public convenience init(color: NSUIColor)
@@ -109,9 +55,9 @@ open class Fill: NSObject
 
     @objc public init(linearGradient: CGGradient, angle: CGFloat)
     {
-        _type = .linearGradient
-        _gradient = linearGradient
-        _gradientAngle = angle
+        type = .linearGradient
+        gradient = linearGradient
+        gradientAngle = angle
     }
 
     @objc public init(
@@ -122,12 +68,12 @@ open class Fill: NSObject
         endRadiusPercent: CGFloat
         )
     {
-        _type = .radialGradient
-        _gradient = radialGradient
-        _gradientStartOffsetPercent = startOffsetPercent
-        _gradientStartRadiusPercent = startRadiusPercent
-        _gradientEndOffsetPercent = endOffsetPercent
-        _gradientEndRadiusPercent = endRadiusPercent
+        type = .radialGradient
+        gradient = radialGradient
+        gradientStartOffsetPercent = startOffsetPercent
+        gradientStartRadiusPercent = startRadiusPercent
+        gradientEndOffsetPercent = endOffsetPercent
+        gradientEndRadiusPercent = endRadiusPercent
     }
 
     @objc public convenience init(radialGradient: CGGradient)
@@ -141,31 +87,21 @@ open class Fill: NSObject
         )
     }
 
-    @objc public init(CGImage: CGImage, tiled: Bool)
+    @objc public init(CGImage: CGImage, tiled: Bool = false)
     {
-        _type = tiled ? .tiledImage : .image
-        _image = CGImage
+        type = tiled ? .tiledImage : .image
+        image = CGImage
     }
 
-    @objc public convenience init(image: NSUIImage, tiled: Bool)
+    @objc public convenience init(image: NSUIImage, tiled: Bool = false)
     {
         self.init(CGImage: image.cgImage!, tiled: tiled)
     }
-
-    @objc public convenience init(CGImage: CGImage)
-    {
-        self.init(CGImage: CGImage, tiled: false)
-    }
-
-    @objc public convenience init(image: NSUIImage)
-    {
-        self.init(image: image, tiled: false)
-    }
-
+
     @objc public init(CGLayer: CGLayer)
     {
-        _type = .layer
-        _layer = CGLayer
+        type = .layer
+        layer = CGLayer
     }
 
     // MARK: Constructors
@@ -209,26 +145,16 @@ open class Fill: NSObject
         return Fill(radialGradient: radialGradient)
     }
 
-    @objc open class func fillWithCGImage(_ CGImage: CGImage, tiled: Bool) -> Fill
+    @objc open class func fillWithCGImage(_ CGImage: CGImage, tiled: Bool = false) -> Fill
     {
         return Fill(CGImage: CGImage, tiled: tiled)
     }
 
-    @objc open class func fillWithImage(_ image: NSUIImage, tiled: Bool) -> Fill
+    @objc open class func fillWithImage(_ image: NSUIImage, tiled: Bool = false) -> Fill
     {
         return Fill(image: image, tiled: tiled)
     }
-
-    @objc open class func fillWithCGImage(_ CGImage: CGImage) -> Fill
-    {
-        return Fill(CGImage: CGImage)
-    }
-
-    @objc open class func fillWithImage(_ image: NSUIImage) -> Fill
-    {
-        return Fill(image: image)
-    }
-
+
     @objc open class func fillWithCGLayer(_ CGLayer: CGLayer) -> Fill
     {
         return Fill(CGLayer: CGLayer)
@@ -241,39 +167,40 @@ open class Fill: NSObject
         context: CGContext,
         rect: CGRect)
     {
-        let fillType = _type
+        let fillType = type
         if fillType == .empty
         {
             return
         }
 
         context.saveGState()
+        defer { context.restoreGState() }
 
         switch fillType
         {
         case .color:
 
-            context.setFillColor(_color!)
+            context.setFillColor(color!)
             context.fillPath()
 
         case .image:
 
             context.clip()
-            context.draw(_image!, in: rect)
+            context.draw(image!, in: rect)
 
         case .tiledImage:
 
             context.clip()
-            context.draw(_image!, in: rect, byTiling: true)
+            context.draw(image!, in: rect, byTiling: true)
 
         case .layer:
 
             context.clip()
-            context.draw(_layer!, in: rect)
+            context.draw(layer!, in: rect)
 
         case .linearGradient:
 
-            let radians = (360.0 - _gradientAngle).DEG2RAD
+            let radians = (360.0 - gradientAngle).DEG2RAD
             let centerPoint = CGPoint(x: rect.midX, y: rect.midY)
             let xAngleDelta = cos(radians) * rect.width / 2.0
             let yAngleDelta = sin(radians) * rect.height / 2.0
@@ -287,7 +214,7 @@ open class Fill: NSObject
             )
 
             context.clip()
-            context.drawLinearGradient(_gradient!,
+            context.drawLinearGradient(gradient!,
                 start: startPoint,
                 end: endPoint,
                 options: [.drawsAfterEndLocation, .drawsBeforeStartLocation]
@@ -299,25 +226,22 @@ open class Fill: NSObject
             let radius = max(rect.width, rect.height) / 2.0
 
             context.clip()
-            context.drawRadialGradient(_gradient!,
+            context.drawRadialGradient(gradient!,
                 startCenter: CGPoint(
-                    x: centerPoint.x + rect.width * _gradientStartOffsetPercent.x,
-                    y: centerPoint.y + rect.height * _gradientStartOffsetPercent.y
+                    x: centerPoint.x + rect.width * gradientStartOffsetPercent.x,
+                    y: centerPoint.y + rect.height * gradientStartOffsetPercent.y
                 ),
-                startRadius: radius * _gradientStartRadiusPercent,
+                startRadius: radius * gradientStartRadiusPercent,
                 endCenter: CGPoint(
-                    x: centerPoint.x + rect.width * _gradientEndOffsetPercent.x,
-                    y: centerPoint.y + rect.height * _gradientEndOffsetPercent.y
+                    x: centerPoint.x + rect.width * gradientEndOffsetPercent.x,
+                    y: centerPoint.y + rect.height * gradientEndOffsetPercent.y
                 ),
-                endRadius: radius * _gradientEndRadiusPercent,
+                endRadius: radius * gradientEndRadiusPercent,
                 options: [.drawsAfterEndLocation, .drawsBeforeStartLocation]
             )
 
         case .empty:
             break
         }
-
-        context.restoreGState()
     }
-
 }

Source/Charts/Utils/Transformer.swift

@@ -17,50 +17,50 @@ import CoreGraphics
 open class Transformer: NSObject
 {
     /// matrix to map the values to the screen pixels
-    internal var _matrixValueToPx = CGAffineTransform.identity
+    internal var matrixValueToPx = CGAffineTransform.identity
 
     /// matrix for handling the different offsets of the chart
-    internal var _matrixOffset = CGAffineTransform.identity
+    internal var matrixOffset = CGAffineTransform.identity
 
-    internal var _viewPortHandler: ViewPortHandler
+    internal var viewPortHandler: ViewPortHandler
 
     @objc public init(viewPortHandler: ViewPortHandler)
     {
-        _viewPortHandler = viewPortHandler
+        self.viewPortHandler = viewPortHandler
     }
 
     /// Prepares the matrix that transforms values to pixels. Calculates the scale factors from the charts size and offsets.
     @objc open func prepareMatrixValuePx(chartXMin: Double, deltaX: CGFloat, deltaY: CGFloat, chartYMin: Double)
     {
-        var scaleX = (_viewPortHandler.contentWidth / deltaX)
-        var scaleY = (_viewPortHandler.contentHeight / deltaY)
+        var scaleX = (viewPortHandler.contentWidth / deltaX)
+        var scaleY = (viewPortHandler.contentHeight / deltaY)
 
-        if CGFloat.infinity == scaleX
+        if .infinity == scaleX
         {
             scaleX = 0.0
         }
-        if CGFloat.infinity == scaleY
+        if .infinity == scaleY
         {
             scaleY = 0.0
         }
 
         // setup all matrices
-        _matrixValueToPx = CGAffineTransform.identity
-        _matrixValueToPx = _matrixValueToPx.scaledBy(x: scaleX, y: -scaleY)
-        _matrixValueToPx = _matrixValueToPx.translatedBy(x: CGFloat(-chartXMin), y: CGFloat(-chartYMin))
+        matrixValueToPx = CGAffineTransform.identity
+            .scaledBy(x: scaleX, y: -scaleY)
+            .translatedBy(x: CGFloat(-chartXMin), y: CGFloat(-chartYMin))
     }
 
     /// Prepares the matrix that contains all offsets.
     @objc open func prepareMatrixOffset(inverted: Bool)
     {
         if !inverted
         {
-            _matrixOffset = CGAffineTransform(translationX: _viewPortHandler.offsetLeft, y: _viewPortHandler.chartHeight - _viewPortHandler.offsetBottom)
+            matrixOffset = CGAffineTransform(translationX: viewPortHandler.offsetLeft, y: viewPortHandler.chartHeight - viewPortHandler.offsetBottom)
         }
         else
         {
-            _matrixOffset = CGAffineTransform(scaleX: 1.0, y: -1.0)
-            _matrixOffset = _matrixOffset.translatedBy(x: _viewPortHandler.offsetLeft, y: -_viewPortHandler.offsetTop)
+            matrixOffset = CGAffineTransform(scaleX: 1.0, y: -1.0)
+                .translatedBy(x: viewPortHandler.offsetLeft, y: -viewPortHandler.offsetTop)
         }
     }
 
@@ -69,10 +69,7 @@ open class Transformer: NSObject
     open func pointValuesToPixel(_ points: inout [CGPoint])
     {
         let trans = valueToPixelMatrix
-        for i in 0 ..< points.count
-        {
-            points[i] = points[i].applying(trans)
-        }
+        points = points.map { $0.applying(trans) }
     }
 
     open func pointValueToPixel(_ point: inout CGPoint)
@@ -126,22 +123,14 @@ open class Transformer: NSObject
     open func rectValuesToPixel(_ rects: inout [CGRect])
     {
         let trans = valueToPixelMatrix
-
-        for i in 0 ..< rects.count
-        {
-            rects[i] = rects[i].applying(trans)
-        }
+        rects = rects.map { $0.applying(trans) }
     }
 
     /// Transforms the given array of touch points (pixels) into values on the chart.
     open func pixelsToValues(_ pixels: inout [CGPoint])
     {
         let trans = pixelToValueMatrix
-
-        for i in 0 ..< pixels.count
-        {
-            pixels[i] = pixels[i].applying(trans)
-        }
+        pixels = pixels.map { $0.applying(trans) }
     }
 
     /// Transforms the given touch point (pixels) into a value on the chart.
@@ -169,8 +158,8 @@ open class Transformer: NSObject
     @objc open var valueToPixelMatrix: CGAffineTransform
     {
         return
-            _matrixValueToPx.concatenating(_viewPortHandler.touchMatrix
-                ).concatenating(_matrixOffset
+            matrixValueToPx.concatenating(viewPortHandler.touchMatrix)
+                .concatenating(matrixOffset
         )
     }