@urvish-procare/react-native-charts-wrapper 0.6.0

package/ios/ReactNativeCharts/formatters/LabelByXValueFormatter.swift

@@ -0,0 +1,35 @@
+import Foundation
+import DGCharts
+
+open class LabelByXValueFormatter: NSObject, ValueFormatter, AxisValueFormatter {
+
+    open var labels = [Double : String]()
+
+    public override init() {
+
+    }
+
+    public init(_ labels: [Double : String]) {
+        self.labels = labels;
+    }
+
+    fileprivate func format(_ value: Double) -> String
+    {
+        return self.labels[value] ?? ""
+    }
+
+    open func stringForValue(
+        _ value: Double, axis: AxisBase?) -> String
+    {
+        return format(value)
+    }
+
+    open func stringForValue(
+        _ value: Double,
+        entry: ChartDataEntry,
+        dataSetIndex: Int,
+        viewPortHandler: ViewPortHandler?) -> String
+    {
+        return format(entry.x)
+    }
+}

package/ios/ReactNativeCharts/formatters/LargeValueFormatter.swift

@@ -0,0 +1,72 @@
+//
+//  LargeValueFormatter.swift
+//  ChartsDemo
+//  Copyright © 2016 dcg. All rights reserved.
+//
+import Foundation
+import DGCharts
+
+open class LargeValueFormatter: NSObject, ValueFormatter, AxisValueFormatter
+{
+    fileprivate static let MAX_LENGTH = 5
+
+    /// Suffix to be appended after the values.
+    ///
+    /// **default**: suffix: ["", "k", "m", "b", "t"]
+    open var suffix = ["", "k", "m", "b", "t"]
+
+    /// An appendix text to be added at the end of the formatted value.
+    open var appendix: String?
+
+    public override init()
+    {
+
+    }
+
+    public init(appendix: String?)
+    {
+        self.appendix = appendix
+    }
+
+    fileprivate func format(_ value: Double) -> String
+    {
+        var sig = abs(value)
+        let sign = value < 0 ? "-" : ""
+        var length = 0
+        let maxLength = suffix.count - 1
+
+        while sig >= 1000.0 && length < maxLength
+        {
+            sig /= 1000.0
+            length += 1
+        }
+
+        let valueFormatter = NumberFormatter()
+        valueFormatter.maximumFractionDigits = 2
+        valueFormatter.minimumFractionDigits = 0
+
+        var r = sign + (valueFormatter.string(from: NSNumber(value: sig)) ?? "") + suffix[length]
+
+        if appendix != nil
+        {
+            r += appendix!
+        }
+
+        return r
+    }
+
+    open func stringForValue(
+        _ value: Double, axis: AxisBase?) -> String
+    {
+        return format(value)
+    }
+
+    open func stringForValue(
+        _ value: Double,
+        entry: ChartDataEntry,
+        dataSetIndex: Int,
+        viewPortHandler: ViewPortHandler?) -> String
+    {
+        return format(value)
+    }
+}

package/ios/ReactNativeCharts/line/LineDataExtract.swift

@@ -0,0 +1,178 @@
+//  Created by xudong wu on 02/03/2017.
+//  Copyright © 2017 wuxudong. All rights reserved.
+//
+
+import Foundation
+
+import SwiftyJSON
+import DGCharts
+import UIKit
+
+class LineDataExtract : DataExtract {
+    override func createData() -> ChartData {
+        return LineChartData();
+    }
+
+    override func createDataSet(_ entries: [ChartDataEntry], label: String) -> ChartDataSetProtocol {
+        return LineChartDataSet(entries: entries, label: label)
+    }
+
+    override func dataSetConfig(_ dataSet: ChartDataSetProtocol, config: JSON) {
+
+
+        let lineDataSet = dataSet as! LineChartDataSet;
+
+        ChartDataSetConfigUtils.commonConfig(lineDataSet, config: config);
+        ChartDataSetConfigUtils.commonBarLineScatterCandleBubbleConfig(lineDataSet, config: config);
+        ChartDataSetConfigUtils.commonLineScatterCandleRadarConfig(lineDataSet, config: config);
+        ChartDataSetConfigUtils.commonLineRadarConfig(lineDataSet, config: config);
+
+        // LineDataSet only config
+        if config["circleRadius"].number != nil {
+            lineDataSet.circleRadius = CGFloat(config["circleRadius"].numberValue)
+        }
+
+
+        if config["drawCircles"].bool != nil {
+            lineDataSet.drawCirclesEnabled = config["drawCircles"].boolValue
+        }
+
+
+        if config["mode"].string != nil {
+            lineDataSet.mode = BridgeUtils.parseLineChartMode(config["mode"].stringValue)
+        }
+
+
+        if config["drawCubicIntensity"].number != nil {
+            lineDataSet.cubicIntensity = CGFloat(config["drawCubicIntensity"].numberValue);
+        }
+
+
+        if config["circleColor"].int != nil {
+            lineDataSet.setCircleColor(RCTConvert.uiColor(config["circleColor"].intValue))
+        }
+
+        if config["circleColors"].array != nil {
+            lineDataSet.circleColors = BridgeUtils.parseColors(config["circleColors"].arrayValue)
+        }
+
+        if config["circleHoleColor"].int != nil {
+            lineDataSet.circleHoleColor = RCTConvert.uiColor(config["circleHoleColor"].intValue)
+        }
+
+
+        if config["drawCircleHole"].bool != nil {
+            lineDataSet.drawCircleHoleEnabled = config["drawCircleHole"].boolValue
+        }
+
+        if config["dashedLine"].exists() {
+            let dashedLine = config["dashedLine"]
+            var lineLength = CGFloat(0);
+            var spaceLength = CGFloat(0);
+            var phase = CGFloat(0);
+
+            if dashedLine["lineLength"].number != nil {
+                lineLength = CGFloat(dashedLine["lineLength"].numberValue)
+            }
+            if dashedLine["spaceLength"].number != nil {
+                spaceLength = CGFloat(dashedLine["spaceLength"].numberValue)
+            }
+            if dashedLine["phase"].number != nil {
+                phase = CGFloat(dashedLine["phase"].numberValue)
+            }
+
+            lineDataSet.lineDashLengths = [lineLength, spaceLength]
+            lineDataSet.lineDashPhase = phase
+        }
+
+        if config["fillFormatter"].exists() {
+            let fillFormatter = config["fillFormatter"];
+            var min = CGFloat(0);
+
+            if fillFormatter["min"].number != nil {
+                min = CGFloat(fillFormatter["min"].numberValue);
+            }
+            lineDataSet.fillFormatter = ConfigurableMinimumLinePositionFillFormatter(min);
+        }
+    }
+
+    override func createEntry(_ values: [JSON], index: Int) -> ChartDataEntry {
+        var entry: ChartDataEntry;
+
+        var x = Double(index);
+        let value = values[index];
+
+        if value.dictionary != nil {
+            let dict = value;
+            var y = Double(index);
+
+            if dict["x"].double != nil {
+                x = Double((dict["x"].doubleValue));
+            }
+
+            if dict["y"].number != nil {
+                y = dict["y"].doubleValue;
+            } else {
+                fatalError("invalid data " + values.description);
+            }
+
+            if dict["icon"].exists() {
+                let icon = dict["icon"]
+                if icon["bundle"].dictionary != nil {
+                    let bundle = icon["bundle"];
+
+                    let uiImage = RCTConvert.uiImage(bundle.dictionaryObject);
+                    let width = CGFloat(icon["width"].numberValue)/4;
+                    let height = CGFloat(icon["height"].numberValue)/4;
+
+                    if let image = uiImage {
+                        let realIconImage = resizeImage(image: image, width: width, height: height);
+                        entry = ChartDataEntry(x: x, y: dict["y"].doubleValue, icon: realIconImage);
+                    } else {
+                        entry = ChartDataEntry(x: x, y: dict["y"].doubleValue, icon: uiImage);
+                    }
+
+
+                } else {
+                    entry = ChartDataEntry(x: x, y: dict["y"].doubleValue, data: dict as AnyObject?);
+                }
+            } else {
+                entry = ChartDataEntry(x: x, y: dict["y"].doubleValue, data: dict as AnyObject?);
+            }
+
+        } else if value.double != nil {
+            entry = ChartDataEntry(x: x, y: value.doubleValue);
+        } else {
+            fatalError("invalid data " + values.description);
+        }
+
+        return entry;
+    }
+
+    func resizeImage(image: UIImage, width: CGFloat, height: CGFloat) -> UIImage {
+      let targetSize = CGSize(width: width, height: height)
+      let size = image.size
+
+      let widthRatio  = targetSize.width  / size.width
+      let heightRatio = targetSize.height / size.height
+
+      // Figure out what our orientation is, and use that to form the rectangle
+      var newSize: CGSize
+      if(widthRatio > heightRatio) {
+          newSize = CGSize(width: size.width * heightRatio, height: size.height * heightRatio)
+      } else {
+          newSize = CGSize(width: size.width * widthRatio,  height: size.height * widthRatio)
+      }
+
+      // This is the rect that we've calculated out and this is what is actually used below
+      let rect = CGRect(x: 0, y: 0, width: newSize.width, height: newSize.height)
+
+      // Actually do the resizing to the rect using the ImageContext stuff
+      UIGraphicsBeginImageContextWithOptions(newSize, false, 1.0)
+      image.draw(in: rect)
+      let newImage = UIGraphicsGetImageFromCurrentImageContext()
+      UIGraphicsEndImageContext()
+
+      return newImage!
+    }
+}

package/ios/ReactNativeCharts/line/RNLineChartManager.swift

@@ -0,0 +1,53 @@
+//  Created by xudong wu on 23/02/2017.
+//  Copyright wuxudong
+//
+
+import UIKit
+
+@objc(RNLineChartManager)
+@objcMembers
+open class RNLineChartManager: RCTViewManager, RNBarLineChartBaseManager {
+  var _bridge: RCTBridge? {get{return self.bridge}}
+  
+  override open func view() -> UIView! {
+    let ins = RNLineChartView()
+    return ins;
+  }
+
+  override public static func requiresMainQueueSetup() -> Bool {
+    return true;
+  }
+  
+  func moveViewToX(_ reactTag: NSNumber, xValue: NSNumber) {
+    (self as RNBarLineChartBaseManager)._moveViewToX(reactTag, xValue: xValue)
+  }
+  
+  func moveViewTo(_ reactTag: NSNumber, xValue: NSNumber, yValue: NSNumber, axisDependency: NSString) {
+    (self as RNBarLineChartBaseManager)._moveViewTo(reactTag, xValue: xValue, yValue: yValue, axisDependency: axisDependency)
+  }
+  
+  func moveViewToAnimated(_ reactTag: NSNumber, xValue: NSNumber, yValue: NSNumber, axisDependency: NSString, duration: NSNumber) {
+    (self as RNBarLineChartBaseManager)._moveViewToAnimated(reactTag, xValue: xValue, yValue: yValue, axisDependency: axisDependency, duration: duration)
+  }
+  
+  func centerViewTo(_ reactTag: NSNumber, xValue: NSNumber, yValue: NSNumber, axisDependency: NSString) {
+    (self as RNBarLineChartBaseManager)._centerViewTo(reactTag, xValue: xValue, yValue: yValue, axisDependency: axisDependency)
+  }
+  
+  func centerViewToAnimated(_ reactTag: NSNumber, xValue: NSNumber, yValue: NSNumber, axisDependency: NSString, duration: NSNumber) {
+    (self as RNBarLineChartBaseManager)._centerViewToAnimated(reactTag, xValue: xValue, yValue: yValue, axisDependency: axisDependency, duration: duration)
+  }
+  
+  func fitScreen(_ reactTag: NSNumber) {
+    (self as RNBarLineChartBaseManager)._fitScreen(reactTag)
+  }
+  
+  func highlights(_ reactTag: NSNumber, config: NSArray) {
+    (self as RNBarLineChartBaseManager)._highlights(reactTag, config: config)
+  }
+
+  func setDataAndLockIndex(_ reactTag: NSNumber, data: NSDictionary) {
+    (self as RNBarLineChartBaseManager)._setDataAndLockIndex(reactTag, data: data)
+  }
+
+}

package/ios/ReactNativeCharts/line/RNLineChartManagerBridge.m

@@ -0,0 +1,14 @@
+//  Created by xudong wu on 24/02/2017.
+//  Copyright © 2017 wuxudong. All rights reserved.
+//
+
+#import "React/RCTViewManager.h"
+#import "RNChartManagerBridge.h"
+#import "RNYAxisChartManagerBridge.h"
+#import "RNBarLineChartManagerBridge.h"
+
+@interface RCT_EXTERN_MODULE(RNLineChartManager, RCTViewManager)
+
+EXPORT_BAR_LINE_CHART_BASE_PROPERTIES
+
+@end

package/ios/ReactNativeCharts/line/RNLineChartView.swift

@@ -0,0 +1,41 @@
+//  Created by xudong wu on 24/02/2017.
+//  Copyright wuxudong
+//
+
+import DGCharts
+import SwiftyJSON
+
+class RNLineChartView: RNBarLineChartViewBase {
+    let _chart: LineChartView;
+    let _dataExtract : LineDataExtract;
+
+    override var chart: LineChartView {
+        return _chart
+    }
+
+    override var dataExtract: DataExtract {
+        return _dataExtract
+    }
+
+    override init(frame: CoreGraphics.CGRect) {
+
+        self._chart = LineChartView(frame: frame)
+        self._dataExtract = LineDataExtract()
+
+        super.init(frame: frame);
+
+        self._chart.delegate = self
+        self.addSubview(_chart);
+
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        _chart.frame = self.bounds // Adjust the chart's frame to fill the entire component's bounds
+    }
+    
+    required init?(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+}

package/ios/ReactNativeCharts/pie/PieDataExtract.swift

@@ -0,0 +1,97 @@
+//  Created by xudong wu on 02/03/2017.
+//  Copyright © 2017 wuxudong. All rights reserved.
+//
+
+import Foundation
+
+import SwiftyJSON
+import DGCharts
+
+class PieDataExtract : DataExtract {
+    override func createData() -> ChartData {
+        return PieChartData();
+    }
+
+    override func createDataSet(_ entries: [ChartDataEntry], label: String) -> ChartDataSetProtocol {
+        return PieChartDataSet(entries: entries, label: label)
+    }
+
+    override func dataSetConfig(_ dataSet: ChartDataSetProtocol, config: JSON) {
+        let pieDataSet = dataSet as! PieChartDataSet;
+
+        ChartDataSetConfigUtils.commonConfig(pieDataSet, config: config);
+
+        // PieDataSet only config
+        if config["sliceSpace"].float != nil {
+            pieDataSet.sliceSpace = CGFloat(config["sliceSpace"].floatValue)
+        }
+
+        if config["selectionShift"].float != nil {
+            pieDataSet.selectionShift = CGFloat(config["selectionShift"].floatValue)
+        }
+
+        if config["xValuePosition"].string != nil {
+            pieDataSet.xValuePosition = BridgeUtils.parsePieChartDataSetValuePosition(config["xValuePosition"].stringValue)
+        }
+
+        if config["yValuePosition"].string != nil {
+            pieDataSet.yValuePosition = BridgeUtils.parsePieChartDataSetValuePosition(config["yValuePosition"].stringValue)
+        }
+
+        if config["valueLinePart1Length"].float != nil {
+            pieDataSet.valueLinePart1Length = CGFloat(config["valueLinePart1Length"].floatValue)
+        }
+
+        if config["valueLinePart2Length"].float != nil {
+            pieDataSet.valueLinePart2Length = CGFloat(config["valueLinePart2Length"].floatValue)
+        }
+
+        if config["valueLineColor"].int != nil {
+            pieDataSet.valueLineColor = RCTConvert.uiColor(config["valueLineColor"].intValue);
+        }
+
+        if config["valueLineWidth"].float != nil {
+            pieDataSet.valueLineWidth = CGFloat(config["valueLineWidth"].floatValue)
+        }
+
+        if config["valueLinePart1OffsetPercentage"].float != nil {
+            pieDataSet.valueLinePart1OffsetPercentage = CGFloat(config["valueLinePart1OffsetPercentage"].floatValue)
+        }
+
+        if config["valueLineVariableLength"].bool != nil {
+            pieDataSet.valueLineVariableLength = config["valueLineVariableLength"].boolValue
+        }
+
+    }
+
+    override func createEntry(_ values: [JSON], index: Int) -> ChartDataEntry {
+        var entry: PieChartDataEntry;
+
+        let item = values[index];
+
+        if item.dictionary != nil {
+            let dict = item;
+
+            var value : Double;
+            if dict["value"].double != nil {
+                value = Double((dict["value"].doubleValue));
+            } else {
+                fatalError("invalid data " + values.description);
+            }
+
+            if dict["label"].string != nil {
+                entry = PieChartDataEntry(value: value, label: dict["label"].stringValue)
+            } else {
+                entry = PieChartDataEntry(value: value)
+            }
+
+            entry.data = dict as AnyObject?
+        } else if item.double != nil {
+            entry = PieChartDataEntry(value : item.doubleValue);
+        } else {
+            fatalError("invalid data " + values.description);
+        }
+
+        return entry;
+    }
+}

package/ios/ReactNativeCharts/pie/RNPieChartManager.swift

@@ -0,0 +1,19 @@
+//  Created by xudong wu on 23/02/2017.
+//  Copyright wuxudong
+//
+
+import UIKit
+
+@objc(RNPieChartManager)
+@objcMembers
+open class RNPieChartManager: RCTViewManager {
+  override open func view() -> UIView! {
+    let ins = RNPieChartView()
+    return ins;
+  }
+
+  override public static func requiresMainQueueSetup() -> Bool {
+    return true;
+  }
+
+}

package/ios/ReactNativeCharts/pie/RNPieChartManagerBridge.m

@@ -0,0 +1,30 @@
+//  Created by xudong wu on 24/02/2017.
+//  Copyright © 2017 wuxudong. All rights reserved.
+//
+
+#import "React/RCTViewManager.h"
+#import "RNChartManagerBridge.h"
+
+@interface RCT_EXTERN_MODULE(RNPieChartManager, RCTViewManager)
+
+EXPORT_CHART_BASE_PROPERTIES
+RCT_EXPORT_VIEW_PROPERTY(drawEntryLabels, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(usePercentValues, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(centerText, NSString)
+RCT_EXPORT_VIEW_PROPERTY(styledCenterText, NSDictionary)
+RCT_EXPORT_VIEW_PROPERTY(centerTextRadiusPercent, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(holeRadius, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(holeColor, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(transparentCircleRadius, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(transparentCircleColor, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(entryLabelColor, NSInteger)
+RCT_EXPORT_VIEW_PROPERTY(entryLabelFontFamily, NSString)
+RCT_EXPORT_VIEW_PROPERTY(entryLabelTextSize, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(extraOffsets, NSDictionary)
+
+RCT_EXPORT_VIEW_PROPERTY(maxAngle, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(minOffset, NSNumber)
+RCT_EXPORT_VIEW_PROPERTY(rotationEnabled, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(rotationAngle, NSNumber)
+
+@end