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

package/android/src/main/java/com/github/wuxudong/rncharts/utils/TypefaceUtils.java

@@ -0,0 +1,47 @@
+package com.github.wuxudong.rncharts.utils;
+
+import android.graphics.Typeface;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.views.text.ReactFontManager;
+import com.github.mikephil.charting.charts.Chart;
+
+/**
+ * Created by wuxudong on 2018/7/25.
+ */
+
+public class TypefaceUtils {
+    public static Typeface getTypeface(Chart chart, ReadableMap propMap) {
+        String fontFamily = propMap.getString("fontFamily");
+        boolean italic = false;
+        boolean bold = false;
+        int style = Typeface.NORMAL;
+        if (BridgeUtils.validate(propMap, ReadableType.String, "fontStyle")) {
+            italic = "italic".equals(propMap.getString("fontStyle"));
+        }
+        if (BridgeUtils.validate(propMap, ReadableType.String, "fontWeight")) {
+            bold = "bold".equals(propMap.getString("fontWeight"));
+        }
+
+        if (italic && bold) {
+            style = Typeface.BOLD_ITALIC;
+        } else if (italic) {
+            style = Typeface.ITALIC;
+        } else if (bold) {
+            style = Typeface.BOLD;
+        }
+
+        return getTypeface(chart, fontFamily, style);
+    }
+
+    public static Typeface getTypeface(Chart chart, String fontFamily) {
+        return getTypeface(chart, fontFamily, Typeface.NORMAL);
+    }
+
+    private static Typeface getTypeface(Chart chart, String fontFamily, int style) {
+        return ReactFontManager.getInstance().getTypeface(fontFamily,
+                style,
+                chart.getContext().getAssets());
+    }
+}

package/android/src/main/res/drawable-nodpi/circle_marker.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="oval">
+    <solid android:color="#454545"/>
+    <stroke
+        android:width="2dp"
+        android:color="#fff"/>
+</shape>

package/android/src/main/res/layout/circle_marker.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content">
+
+    <ImageView
+        android:background="@drawable/circle_marker"
+        android:layout_width="15dp"
+        android:layout_height="15dp" />
+
+</LinearLayout>

package/android/src/main/res/layout/oval_marker.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/oval_markerContent"
+    android:layout_width="wrap_content"
+    android:layout_height="40dp"
+    android:background="@drawable/oval_marker" >
+
+    <TextView
+        android:id="@+id/oval_tvContent"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_centerHorizontal="true"
+        android:layout_marginTop="8dp"
+        android:layout_marginLeft="5dp"
+        android:layout_marginRight="5dp"
+        android:text=""
+        android:textSize="12sp"
+        android:textColor="@android:color/white"
+        android:ellipsize="end"
+        android:maxLines="1"
+        android:textAppearance="?android:attr/textAppearanceSmall"
+    />
+
+</RelativeLayout>

package/android/src/main/res/layout/rectangle_marker.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/rectangle_markerContent"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    >
+
+    <TextView
+        android:id="@+id/rectangle_tvContent"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:background="@drawable/rectangle_marker"
+        android:layout_centerHorizontal="true"
+        android:text=""
+        android:gravity="center"
+        android:textSize="12sp"
+        android:textColor="@android:color/white"
+        android:textAppearance="?android:attr/textAppearanceSmall"
+    />
+
+</RelativeLayout>

package/index.js

@@ -0,0 +1,21 @@
+import BarChart from './lib/BarChart';
+import HorizontalBarChart from './lib/HorizontalBarChart';
+import BubbleChart from './lib/BubbleChart';
+import CandleStickChart from './lib/CandleStickChart';
+import LineChart from './lib/LineChart';
+import PieChart from './lib/PieChart';
+import RadarChart from './lib/RadarChart';
+import ScatterChart from './lib/ScatterChart';
+import CombinedChart from './lib/CombinedChart';
+
+module.exports = {
+  BarChart,
+  HorizontalBarChart,
+  BubbleChart,
+  CandleStickChart,
+  LineChart,
+  PieChart,
+  RadarChart,
+  ScatterChart,
+  CombinedChart
+};

package/ios/ReactNativeCharts/BalloonMarker.swift

@@ -0,0 +1,240 @@
+//
+//  BalloonMarker.swift
+//  ChartsDemo
+//
+//  Created by Daniel Cohen Gindi on 19/3/15.
+//
+//  Copyright 2015 Daniel Cohen Gindi & Philipp Jahoda
+//  A port of MPAndroidChart for iOS
+//  Licensed under Apache License 2.0
+//
+//  https://github.com/danielgindi/ios-charts
+//  https://github.com/danielgindi/Charts/blob/1788e53f22eb3de79eb4f08574d8ea4b54b5e417/ChartsDemo/Classes/Components/BalloonMarker.swift
+//  Edit: Added textColor
+
+import Foundation;
+
+import DGCharts;
+
+import SwiftyJSON;
+
+open class BalloonMarker: MarkerView {
+    open var color: UIColor?
+    open var arrowSize = CGSize(width: 15, height: 11)
+    open var font: UIFont?
+    open var textColor: UIColor?
+    open var minimumSize = CGSize()
+
+
+    fileprivate var insets = UIEdgeInsets(top: 8.0,left: 8.0,bottom: 20.0,right: 8.0)
+    fileprivate var topInsets = UIEdgeInsets(top: 20.0,left: 8.0,bottom: 8.0,right: 8.0)
+
+    fileprivate var labelns: NSString?
+    fileprivate var _labelSize: CGSize = CGSize()
+    fileprivate var _size: CGSize = CGSize()
+    fileprivate var _paragraphStyle: NSMutableParagraphStyle?
+    fileprivate var _drawAttributes = [NSAttributedString.Key: Any]()
+
+
+  public init(color: UIColor, font: UIFont, textColor: UIColor, textAlign: NSTextAlignment) {
+        super.init(frame: CGRect.zero);
+        self.color = color
+        self.font = font
+        self.textColor = textColor
+
+        _paragraphStyle = NSParagraphStyle.default.mutableCopy() as? NSMutableParagraphStyle
+        _paragraphStyle?.alignment = textAlign
+    }
+
+    public required init?(coder aDecoder: NSCoder) {
+        fatalError("init(coder:) has not been implemented");
+    }
+
+
+    func drawRect(context: CGContext, point: CGPoint) -> CGRect{
+
+        let chart = super.chartView
+
+        let width = _size.width
+
+
+        var rect = CGRect(origin: point, size: _size)
+
+        if point.y - _size.height < 0 {
+
+            if point.x - _size.width / 2.0 < 0 {
+                drawTopLeftRect(context: context, rect: rect)
+            } else if (chart != nil && point.x + width - _size.width / 2.0 > (chart?.bounds.width)!) {
+                rect.origin.x -= _size.width
+                drawTopRightRect(context: context, rect: rect)
+            } else {
+                rect.origin.x -= _size.width / 2.0
+                drawTopCenterRect(context: context, rect: rect)
+            }
+
+            rect.origin.y += self.topInsets.top
+            rect.size.height -= self.topInsets.top + self.topInsets.bottom
+
+        } else {
+
+            rect.origin.y -= _size.height
+
+            if point.x - _size.width / 2.0 < 0 {
+                drawLeftRect(context: context, rect: rect)
+            } else if (chart != nil && point.x + width - _size.width / 2.0 > (chart?.bounds.width)!) {
+                rect.origin.x -= _size.width
+                drawRightRect(context: context, rect: rect)
+            } else {
+                rect.origin.x -= _size.width / 2.0
+                drawCenterRect(context: context, rect: rect)
+            }
+
+            rect.origin.y += self.insets.top
+            rect.size.height -= self.insets.top + self.insets.bottom
+
+        }
+
+        return rect
+    }
+
+    func drawCenterRect(context: CGContext, rect: CGRect) {
+
+        context.setFillColor((color?.cgColor)!)
+        context.beginPath()
+        context.move(to: CGPoint(x: rect.origin.x, y: rect.origin.y))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y + rect.size.height - arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + (rect.size.width + arrowSize.width) / 2.0, y: rect.origin.y + rect.size.height - arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width / 2.0, y: rect.origin.y + rect.size.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + (rect.size.width - arrowSize.width) / 2.0, y: rect.origin.y + rect.size.height - arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y + rect.size.height - arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y))
+        context.fillPath()
+
+    }
+
+    func drawLeftRect(context: CGContext, rect: CGRect) {
+        context.setFillColor((color?.cgColor)!)
+        context.beginPath()
+        context.move(to: CGPoint(x: rect.origin.x, y: rect.origin.y))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y + rect.size.height - arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + arrowSize.width / 2.0, y: rect.origin.y + rect.size.height - arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y + rect.size.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y))
+        context.fillPath()
+
+    }
+
+    func drawRightRect(context: CGContext, rect: CGRect) {
+        context.setFillColor((color?.cgColor)!)
+        context.beginPath()
+        context.move(to: CGPoint(x: rect.origin.x, y: rect.origin.y))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y + rect.size.height))
+        context.addLine(to: CGPoint(x: rect.origin.x  + rect.size.width - arrowSize.width / 2.0, y: rect.origin.y + rect.size.height - arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y + rect.size.height - arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y))
+        context.fillPath()
+
+    }
+
+    func drawTopCenterRect(context: CGContext, rect: CGRect) {
+
+        context.setFillColor((color?.cgColor)!)
+        context.beginPath()
+        context.move(to: CGPoint(x: rect.origin.x + rect.size.width / 2.0, y: rect.origin.y))
+        context.addLine(to: CGPoint(x: rect.origin.x + (rect.size.width + arrowSize.width) / 2.0, y: rect.origin.y + arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y + arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y + rect.size.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y + rect.size.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y + arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + (rect.size.width - arrowSize.width) / 2.0, y: rect.origin.y + arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width / 2.0, y: rect.origin.y))
+        context.fillPath()
+
+    }
+
+    func drawTopLeftRect(context: CGContext, rect: CGRect) {
+        context.setFillColor((color?.cgColor)!)
+        context.beginPath()
+        context.move(to: CGPoint(x: rect.origin.x, y: rect.origin.y))
+        context.addLine(to: CGPoint(x: rect.origin.x + arrowSize.width / 2.0, y: rect.origin.y + arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y + arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y + rect.size.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y + rect.size.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y))
+        context.fillPath()
+
+    }
+
+    func drawTopRightRect(context: CGContext, rect: CGRect) {
+        context.setFillColor((color?.cgColor)!)
+        context.beginPath()
+        context.move(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y + rect.size.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y + rect.size.height))
+        context.addLine(to: CGPoint(x: rect.origin.x, y: rect.origin.y + arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width - arrowSize.height / 2.0, y: rect.origin.y + arrowSize.height))
+        context.addLine(to: CGPoint(x: rect.origin.x + rect.size.width, y: rect.origin.y))
+        context.fillPath()
+
+    }
+
+
+
+    open override func draw(context: CGContext, point: CGPoint) {
+        if (labelns == nil || labelns?.length == 0) {
+            return
+        }
+
+        context.saveGState()
+
+        let rect = drawRect(context: context, point: point)
+
+        UIGraphicsPushContext(context)
+
+        labelns?.draw(in: rect, withAttributes: _drawAttributes)
+
+        UIGraphicsPopContext()
+
+        context.restoreGState()
+    }
+
+    open override func refreshContent(entry: ChartDataEntry, highlight: Highlight) {
+
+        var label : String;
+
+        if let candleEntry = entry as? CandleChartDataEntry {
+
+            label = candleEntry.close.description
+        } else {
+            label = entry.y.description
+        }
+
+        if let object = entry.data as? JSON {
+            if object["marker"].exists() {
+                label = object["marker"].stringValue;
+
+                if highlight.stackIndex != -1 && object["marker"].array != nil {
+                    label = object["marker"].arrayValue[highlight.stackIndex].stringValue
+                }
+            }
+        }
+
+        labelns = label as NSString
+
+        _drawAttributes.removeAll()
+        _drawAttributes[NSAttributedString.Key.font] = self.font
+        _drawAttributes[NSAttributedString.Key.paragraphStyle] = _paragraphStyle
+        _drawAttributes[NSAttributedString.Key.foregroundColor] = self.textColor
+
+        _labelSize = labelns?.size(withAttributes: _drawAttributes) ?? CGSize.zero
+        _size.width = _labelSize.width + self.insets.left + self.insets.right
+        _size.height = _labelSize.height + self.insets.top + self.insets.bottom
+        _size.width = max(minimumSize.width, _size.width)
+        _size.height = max(minimumSize.height, _size.height)
+
+    }
+}
+

package/ios/ReactNativeCharts/ChartGroupHolder.swift

@@ -0,0 +1,70 @@
+//
+//  ChartGroupHolder.swift
+//  Charts
+//
+//  Created by wuxudong on 2018/10/1.
+//
+
+import Foundation
+
+import DGCharts
+
+class ChartHolder {
+    open weak var chart:BarLineChartViewBase?
+    open var syncX: Bool;
+    open  var syncY:Bool;
+
+    init( chart: BarLineChartViewBase,  syncX: Bool,  syncY: Bool) {
+        self.chart = chart
+        self.syncX = syncX
+        self.syncY = syncY
+    }
+}
+
+open class ChartGroupHolder {
+    static var chartGroup: Dictionary<String, Dictionary<String, ChartHolder>> = [:]
+
+    public static func addChart(group: String, identifier: String ,  chart: BarLineChartViewBase,  syncX: Bool, syncY: Bool) {
+        objc_sync_enter(chartGroup)
+        defer { objc_sync_exit(chartGroup) }
+
+        let keyExists = chartGroup[group] != nil
+
+        if !keyExists {
+            chartGroup[group] = [:]
+        }
+
+        chartGroup[group]![identifier] = ChartHolder(chart: chart, syncX: syncX, syncY: syncY)
+    }
+
+
+    // sync gesture to other chart in the same group
+    public static func sync( group: String,  identifier: String,  scaleX: CGFloat,  scaleY:CGFloat,  centerX: CGFloat,  centerY:CGFloat,  performImmediately: Bool) {
+
+        objc_sync_enter(chartGroup)
+        defer { objc_sync_exit(chartGroup) }
+
+        if let identifierMap = chartGroup[group] {
+            for (identifierKey, chartHolder) in identifierMap {
+                if identifierKey != identifier {
+                    if let chart = chartHolder.chart {
+
+                        let axis = chart.getAxis(YAxis.AxisDependency.left).enabled ? YAxis.AxisDependency.left : YAxis.AxisDependency.right
+
+                        let contentRect = chart.contentRect
+
+                        let originalCenterValue = chart.valueForTouchPoint(point: CGPoint(x: contentRect.midX, y: contentRect.midY), axis: axis)
+
+                        let finalScaleX = chartHolder.syncX ? scaleX : chart.scaleX
+                        let finalScaleY = chartHolder.syncY ? scaleY : chart.scaleY
+
+                        let finalCenterX = chartHolder.syncX ? centerX : originalCenterValue.x;
+                        let finalCenterY = chartHolder.syncY ? centerY : originalCenterValue.y;
+
+                        chart.zoom(scaleX: finalScaleX, scaleY: finalScaleY, xValue: Double(finalCenterX), yValue: Double(finalCenterY), axis: axis);
+                    }
+                }
+            }
+        }
+    }
+}

package/ios/ReactNativeCharts/CircleMarker.swift

@@ -0,0 +1,108 @@
+import Foundation
+import DGCharts
+
+open class CircleMarker: MarkerImage
+{
+  open var color: UIColor
+  open var strokeColor: UIColor
+  open var strokeSize: Int
+
+  public init(
+    color: UIColor,
+    strokeColor: UIColor,
+    size: CGSize,
+    strokeSize: Int
+  )
+  {
+    self.color = color
+    self.strokeColor = strokeColor
+    self.strokeSize = strokeSize
+
+    super.init()
+
+    self.size = size
+  }
+
+  open override func offsetForDrawing(atPoint point: CGPoint) -> CGPoint
+  {
+    var offset = self.offset
+    var size = self.size
+
+    if size.width == 0.0 && image != nil
+    {
+      size.width = image!.size.width
+    }
+    if size.height == 0.0 && image != nil
+    {
+      size.height = image!.size.height
+    }
+
+    let width = size.width
+    let height = size.height
+    let padding: CGFloat = 8.0
+
+    var origin = point
+    origin.x -= width / 2
+    origin.y -= height
+
+    if origin.x + offset.x < 0.0
+    {
+      offset.x = -origin.x + padding
+    }
+    else if let chart = chartView,
+      origin.x + width + offset.x > chart.bounds.size.width
+    {
+      offset.x = chart.bounds.size.width - origin.x - width - padding
+    }
+
+    if origin.y + offset.y < 0
+    {
+      offset.y = height + padding;
+    }
+    else if let chart = chartView,
+      origin.y + height + offset.y > chart.bounds.size.height
+    {
+      offset.y = chart.bounds.size.height - origin.y - height - padding
+    }
+
+    return offset
+  }
+
+  open override func draw(context: CGContext, point: CGPoint)
+  {
+    let offset = self.offsetForDrawing(atPoint: point)
+    let color = self.color;
+    let size = self.size
+    let strokeSize = self.strokeSize
+    let strokeColor = self.strokeColor;
+
+    var rect = CGRect(
+      origin: CGPoint(
+        x: point.x + offset.x,
+        y: point.y + offset.y
+      ),
+      size: size
+    )
+    rect.origin.x -= size.width / 2.0
+    rect.origin.y -= size.height / 2.0
+
+    context.saveGState()
+
+    context.setFillColor(color.cgColor)
+    context.setLineWidth(CGFloat(strokeSize))
+    context.setStrokeColor(strokeColor.cgColor)
+
+    context.addEllipse(in: rect)
+    context.drawPath(using: .fillStroke)
+
+    UIGraphicsPushContext(context)
+
+    UIGraphicsPopContext()
+
+    context.restoreGState()
+  }
+
+  open override func refreshContent(entry: ChartDataEntry, highlight: Highlight)
+  {
+  }
+}

package/ios/ReactNativeCharts/ConfigurableMinimumLinePositionFillFormatter.swift

@@ -0,0 +1,19 @@
+import Foundation
+import DGCharts
+
+open class ConfigurableMinimumLinePositionFillFormatter: NSObject, FillFormatter {
+
+    open var min = CGFloat(0)
+
+    public override init() {
+
+    }
+
+    public init(_ min: CGFloat) {
+        self.min = min;
+    }
+
+    open func getFillLinePosition(dataSet: LineChartDataSetProtocol, dataProvider: LineChartDataProvider) -> CGFloat {
+        return min
+    }
+}

package/ios/ReactNativeCharts/CustomChartDateFormatter.swift

@@ -0,0 +1,64 @@
+//
+//  CustomChartDateFormatter.swift
+//  Charts
+//
+//  Created by wuxudong on 2018/10/6.
+//
+
+import Foundation
+import DGCharts
+
+open class CustomChartDateFormatter: NSObject, ValueFormatter, AxisValueFormatter {
+
+    open var dateFormatter = DateFormatter();
+
+    open var since = 0.0
+
+    open var timeUnit : String?
+
+    public override init() {
+
+    }
+
+    public init(pattern: String?, since: Double, timeUnit: String?, locale: String?) {
+        self.dateFormatter.locale = Locale(identifier: locale ?? Locale.current.languageCode ?? "en_US");
+        self.dateFormatter.dateFormat = pattern;
+        self.since = since
+        self.timeUnit = timeUnit
+    }
+
+    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)
+    }
+
+    fileprivate func format(_ value: Double) -> String
+    {
+        var span = 0.0
+
+        // TODO: any better enum other than String equals to java.util.TimeUnit
+        switch timeUnit {
+        case "MILLISECONDS":
+            span = value / 1000.0
+        case "SECONDS":
+            span = value
+        case "MINUTES":
+            span = value * 60
+        case "HOURS":
+            span = value * 60 * 60
+        case "DAYS":
+            span = value * 60 * 60 * 24
+        default:
+            span = value / 1000.0
+        }
+
+        let timeIntervalSince1970 = self.since / 1000.0 +  span
+
+        let date = Date(timeIntervalSince1970: timeIntervalSince1970);
+        return self.dateFormatter.string(from: date);
+    }
+
+}