Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/GraphCore/Sources/Charts/Controllers/Stacked Bars/BarsComponentController.swift

@@ -0,0 +1,322 @@
+//
+//  BarsComponentController.swift
+//  GraphTest
+//
+//  Created by Andrei Salavei on 4/14/19.
+//  Copyright © 2019 Andrei Salavei. All rights reserved.
+//
+
+import Foundation
+#if os(macOS)
+import Cocoa
+#else
+import UIKit
+#endif
+
+class BarsComponentController: GeneralChartComponentController {
+    let mainBarsRenderer: BarChartRenderer
+    let horizontalScalesRenderer: HorizontalScalesRenderer
+    let verticalScalesRenderer: VerticalScalesRenderer
+    let secondaryScalesRenderer: VerticalScalesRenderer?
+    
+    let lineBulletsRenderer = LineBulletsRenderer()
+    let verticalLineRenderer = VerticalLinesRenderer()
+    
+    let previewBarsChartRenderer: BarChartRenderer
+    private(set) var barsWidth: CGFloat = 1
+    
+    private(set) var chartBars: BarChartRenderer.BarsData = .blank
+    
+    private var step: Bool
+    
+    init(isZoomed: Bool,
+         mainBarsRenderer: BarChartRenderer,
+         horizontalScalesRenderer: HorizontalScalesRenderer,
+         verticalScalesRenderer: VerticalScalesRenderer,
+         secondaryScalesRenderer: VerticalScalesRenderer? = nil,
+         previewBarsChartRenderer: BarChartRenderer,
+         step: Bool = false) {
+        self.mainBarsRenderer = mainBarsRenderer
+        self.horizontalScalesRenderer = horizontalScalesRenderer
+        self.verticalScalesRenderer = verticalScalesRenderer
+        self.secondaryScalesRenderer = secondaryScalesRenderer
+        self.previewBarsChartRenderer = previewBarsChartRenderer
+        self.step = step
+        
+        self.lineBulletsRenderer.isEnabled = false
+        
+        self.mainBarsRenderer.optimizationLevel = BaseConstants.barsChartOptimizationLevel
+        self.previewBarsChartRenderer.optimizationLevel = BaseConstants.barsChartOptimizationLevel
+
+        super.init(isZoomed: isZoomed)
+    }
+    
+    override func initialize(chartsCollection: ChartsCollection, initialDate: Date, totalHorizontalRange _: ClosedRange<CGFloat>, totalVerticalRange _: ClosedRange<CGFloat>) {
+        let (width, chartBars, totalHorizontalRange, totalVerticalRange) = BarChartRenderer.BarsData.initialComponents(chartsCollection: chartsCollection, separate: self.step)
+        self.chartBars = chartBars
+        self.barsWidth = width
+        
+        super.initialize(chartsCollection: chartsCollection,
+                         initialDate: initialDate,
+                         totalHorizontalRange: totalHorizontalRange,
+                         totalVerticalRange: totalVerticalRange)
+    }
+    
+    override func setupInitialChartRange(initialDate: Date) {
+        guard let first = chartsCollection.axisValues.first?.timeIntervalSince1970,
+            let last = chartsCollection.axisValues.last?.timeIntervalSince1970 else { return }
+        
+        let rangeStart = CGFloat(first)
+        let rangeEnd = CGFloat(last)
+        
+        if isZoomed {
+            let initalDate = CGFloat(initialDate.timeIntervalSince1970)
+            
+            initialHorizontalRange = max(initalDate - barsWidth, rangeStart)...min(initalDate + GeneralChartComponentConstants.defaultZoomedRangeLength - barsWidth, rangeEnd)
+            initialVerticalRange = totalVerticalRange
+        } else {
+            super.setupInitialChartRange(initialDate: initialDate)
+        }
+    }
+
+    
+    override func willAppear(animated: Bool) {
+        mainBarsRenderer.bars = self.chartBars
+        previewBarsChartRenderer.bars = self.chartBars
+        
+        previewBarsChartRenderer.setup(verticalRange: totalVerticalRange, animated: animated)
+        previewBarsChartRenderer.setup(horizontalRange: totalHorizontalRange, animated: animated)
+        
+        setupMainChart(verticalRange: initialVerticalRange, animated: animated)
+        setupMainChart(horizontalRange: initialHorizontalRange, animated: animated)        
+        updateChartVerticalRanges(horizontalRange: initialHorizontalRange, animated: animated)
+
+        super.willAppear(animated: animated)
+        
+        updatePreviewRangeClosure?(currentChartHorizontalRangeFraction, animated)
+        setComponentsVisible(visible: true, animated: animated)
+        updateHorizontalLimitLabels(animated: animated, forceUpdate: true)
+    }
+    
+    override func chartRangeDidUpdated(_ updatedRange: ClosedRange<CGFloat>) {
+        super.chartRangeDidUpdated(updatedRange)
+        if !isZoomed {
+            initialHorizontalRange = updatedRange
+        }
+        setupMainChart(horizontalRange: updatedRange, animated: false)
+        updateHorizontalLimitLabels(animated: true, forceUpdate: false)
+        updateChartVerticalRanges(horizontalRange: updatedRange, animated: true)
+    }
+    
+    func updateHorizontalLimitLabels(animated: Bool, forceUpdate: Bool) {
+        updateHorizontalLimitLabels(horizontalScalesRenderer: horizontalScalesRenderer,
+                                    horizontalRange: currentHorizontalMainChartRange,
+                                    scaleType: isZoomed ? .hour : .day,
+                                    forceUpdate: forceUpdate,
+                                    animated: animated)
+    }
+    
+    func prepareAppearanceAnimation(horizontalRnage: ClosedRange<CGFloat>) {
+        setupMainChart(horizontalRange: horizontalRnage, animated: false)
+        setComponentsVisible(visible: false, animated: false)
+    }
+    
+    func setComponentsVisible(visible: Bool, animated: Bool) {
+        mainBarsRenderer.setVisible(visible, animated: animated)
+        horizontalScalesRenderer.setVisible(visible, animated: animated)
+        verticalScalesRenderer.setVisible(visible, animated: animated)
+        secondaryScalesRenderer?.setVisible(visible, animated: animated)
+        previewBarsChartRenderer.setVisible(visible, animated: animated)
+    }
+    
+    func setupMainChart(horizontalRange: ClosedRange<CGFloat>, animated: Bool) {
+        mainBarsRenderer.setup(horizontalRange: horizontalRange, animated: animated)
+        horizontalScalesRenderer.setup(horizontalRange: horizontalRange, animated: animated)
+        verticalScalesRenderer.setup(horizontalRange: horizontalRange, animated: animated)
+        secondaryScalesRenderer?.setup(horizontalRange: horizontalRange, animated: animated)
+        
+        verticalLineRenderer.setup(horizontalRange: horizontalRange, animated: animated)
+        lineBulletsRenderer.setup(horizontalRange: horizontalRange, animated: animated)
+
+    }
+    
+    var visibleBars: BarChartRenderer.BarsData {
+        let visibleComponents: [BarChartRenderer.BarsData.Component] = chartVisibility.enumerated().compactMap { args in
+            args.element ? chartBars.components[args.offset] : nil
+        }
+        return BarChartRenderer.BarsData(barWidth: chartBars.barWidth,
+                                         locations: chartBars.locations,
+                                         components: visibleComponents)
+    }
+    
+    func verticalLimitsLabels(verticalRange: ClosedRange<CGFloat>, secondary: Bool) -> (ClosedRange<CGFloat>, [LinesChartLabel]) {
+        var (range, labels) = super.verticalLimitsLabels(verticalRange: verticalRange)
+        if secondary {
+            var updatedLabels: [LinesChartLabel] = []
+            for label in labels {
+                let convertedValue = (self.verticalLimitsNumberFormatter.number(from: label.text) as? Double ?? 0.0) * self.conversionRate
+                let text: String
+                if convertedValue > 1.0 {
+                    text = String(format: "%0.1f", convertedValue)
+                } else {
+                    text = String(format: "%0.3f", convertedValue)
+                }
+                updatedLabels.append(LinesChartLabel(value: label.value, text: "~$\(text)"))
+            }
+            labels = updatedLabels
+        }
+        return (range, labels)
+    }
+    
+    func updateChartVerticalRanges(horizontalRange: ClosedRange<CGFloat>, animated: Bool) {
+        if let range = BarChartRenderer.BarsData.verticalRange(bars: visibleBars,
+                                                               separate: self.step,
+                                                               calculatingRange: horizontalRange,
+                                                               addBounds: true) {
+            let (range, labels) = verticalLimitsLabels(verticalRange: range, secondary: false)
+           // if verticalScalesRenderer.verticalRange.end != range {
+                verticalScalesRenderer.setup(verticalLimitsLabels: labels, animated: animated)
+           // }
+            verticalScalesRenderer.setVisible(true, animated: animated)
+            
+            if let secondaryScalesRenderer = self.secondaryScalesRenderer {
+                let (_, labels) = verticalLimitsLabels(verticalRange: range, secondary: true)
+               // if secondaryScalesRenderer.verticalRange.end != range {
+                    secondaryScalesRenderer.setup(verticalLimitsLabels: labels, animated: animated)
+               // }
+                secondaryScalesRenderer.setVisible(true, animated: animated)
+            }
+            
+            setupMainChart(verticalRange: range, animated: animated)
+        } else {
+            verticalScalesRenderer.setVisible(false, animated: animated)
+            secondaryScalesRenderer?.setVisible(false, animated: animated)
+        }
+        
+        if let range = BarChartRenderer.BarsData.verticalRange(bars: visibleBars, separate: self.step) {
+            previewBarsChartRenderer.setup(verticalRange: range, animated: animated)
+        }
+    }
+    
+    func setupMainChart(verticalRange: ClosedRange<CGFloat>, animated: Bool) {
+        mainBarsRenderer.setup(verticalRange: verticalRange, animated: animated)
+        horizontalScalesRenderer.setup(verticalRange: verticalRange, animated: animated)
+        verticalScalesRenderer.setup(verticalRange: verticalRange, animated: animated)
+        secondaryScalesRenderer?.setup(verticalRange: verticalRange, animated: animated)
+        lineBulletsRenderer.setup(verticalRange: verticalRange, animated: animated)
+    }
+    
+    public override func updateChartsVisibility(visibility: [Bool], animated: Bool) {
+        super.updateChartsVisibility(visibility: visibility, animated: animated)
+        for (index, isVisible) in visibility.enumerated() {
+            mainBarsRenderer.setComponentVisible(isVisible, at: index, animated: animated)
+            previewBarsChartRenderer.setComponentVisible(isVisible, at: index, animated: animated)
+        }
+        updateChartVerticalRanges(horizontalRange: currentHorizontalMainChartRange, animated: true)
+    }
+    
+    var visibleChartValues: [ChartsCollection.Chart] {
+        let visibleCharts: [ChartsCollection.Chart] = chartVisibility.enumerated().compactMap { args in
+            args.element ? chartsCollection.chartValues[args.offset] : nil
+        }
+        return visibleCharts
+    }
+    
+    override func chartDetailsViewModel(closestDate: Date, pointIndex: Int, currency: GraphCurrency? = nil, rate: Double = 1.0) -> ChartDetailsViewModel {
+        var viewModel = super.chartDetailsViewModel(closestDate: closestDate, pointIndex: pointIndex, currency: currency, rate: rate)
+        let visibleChartValues = self.visibleChartValues
+        let totalSumm: CGFloat = visibleChartValues.map { CGFloat($0.values[pointIndex]) }.reduce(0, +)
+        viewModel.hideAction = { [weak self] in
+            self?.hideDetailsView(animated: true)
+        }
+        if !self.step {
+            viewModel.totalValue = ChartDetailsViewModel.Value(prefix: nil,
+                                                               title: self.strings.total,
+                                                               value: BaseConstants.detailsNumberFormatter.string(from: totalSumm),
+                                                               color: .white,
+                                                               visible: visibleChartValues.count > 1)
+        } else {
+            viewModel.title = "\(Int(closestDate.timeIntervalSince1970)):00"
+        }
+        return viewModel
+    }
+    
+    override var currentMainRangeRenderer: BaseChartRenderer {
+        return mainBarsRenderer
+    }
+    
+    override var currentPreviewRangeRenderer: BaseChartRenderer {
+        return previewBarsChartRenderer
+    }
+    
+    override func showDetailsView(at chartPosition: CGFloat, detailsViewPosition: CGFloat, dataIndex: Int, date: Date, animated: Bool, feedback: Bool) {
+        super.showDetailsView(at: chartPosition, detailsViewPosition: detailsViewPosition, dataIndex: dataIndex, date: date, animated: animated, feedback: feedback)
+        mainBarsRenderer.setSelectedIndex(dataIndex, animated: true)
+    }
+    
+    override func hideDetailsView(animated: Bool) {
+        super.hideDetailsView(animated: animated)
+        
+        mainBarsRenderer.setSelectedIndex(nil, animated: animated)
+    }
+    override func apply(theme: ChartTheme, strings: ChartStrings, animated: Bool) {
+        super.apply(theme: theme, strings: strings, animated: animated)
+        
+        horizontalScalesRenderer.labelsColor = theme.chartLabelsColor
+        verticalScalesRenderer.labelsColor = theme.chartLabelsColor
+        verticalScalesRenderer.axisXColor = theme.barChartStrongLinesColor
+        verticalScalesRenderer.horizontalLinesColor = theme.barChartStrongLinesColor
+        secondaryScalesRenderer?.labelsColor = theme.chartLabelsColor
+        secondaryScalesRenderer?.axisXColor = .clear
+        secondaryScalesRenderer?.horizontalLinesColor = .clear
+        mainBarsRenderer.update(backgroundColor: theme.chartBackgroundColor, animated: false)
+        previewBarsChartRenderer.update(backgroundColor: theme.chartBackgroundColor, animated: false)
+        verticalLineRenderer.linesColor = theme.chartStrongLinesColor
+    }
+    
+    override func updateChartRangeTitle(animated: Bool) {
+        let fromDate = Date(timeIntervalSince1970: TimeInterval(currentHorizontalMainChartRange.lowerBound + barsWidth))
+        let toDate = Date(timeIntervalSince1970: TimeInterval(currentHorizontalMainChartRange.upperBound))
+        if Calendar.utc.startOfDay(for: fromDate) == Calendar.utc.startOfDay(for: toDate) {
+            let stirng = BaseConstants.headerFullZoomedFormatter.string(from: fromDate)
+            self.setChartTitleClosure?(stirng, animated)
+        } else {
+            let stirng = "\(BaseConstants.headerMediumRangeFormatter.string(from: fromDate)) - \(BaseConstants.headerMediumRangeFormatter.string(from: toDate))"
+            self.setChartTitleClosure?(stirng, animated)
+        }
+    }
+    
+    override func chartInteractionDidBegin(point: CGPoint, manual: Bool = true) {
+        if manual && !isChartInteracting && detailsVisible {
+                  self.hideDetailsView(animated: true)
+                  ignoreInteraction = true
+                  return
+              }
+        let chartFrame = self.chartFrame()
+        guard chartFrame.width > 0 else { return }
+        let horizontalRange = currentHorizontalMainChartRange
+        let dateToFind = Date(timeIntervalSince1970: TimeInterval(horizontalRange.distance * point.x + horizontalRange.lowerBound))
+        guard let (closestDate, minIndex) = findClosestDateTo(dateToFind: dateToFind) else { return }
+        
+        let chartWasInteracting = isChartInteractionBegun
+        lastChartInteractionPoint = point
+        isChartInteractionBegun = true
+        isChartInteracting = true
+        
+        let chartValue: CGFloat = CGFloat(closestDate.timeIntervalSince1970)
+        var chartValueUpdated = true
+        if chartValue == currentChartValue {
+            chartValueUpdated = false
+        }
+        currentChartValue = chartValue
+        let detailsViewPosition = (chartValue - horizontalRange.lowerBound) / horizontalRange.distance * chartFrame.width + chartFrame.minX
+        
+        
+        showDetailsView(at: chartValue, detailsViewPosition: detailsViewPosition, dataIndex: minIndex, date: closestDate, animated: chartWasInteracting, feedback: chartWasInteracting && chartValueUpdated)
+        
+        super.chartInteractionDidBegin(point: point)
+        
+        self.verticalLineRenderer.values = [chartValue]
+//        self.verticalLineRenderer.offset = barOffset
+    }
+}

submodules/GraphCore/Sources/Charts/Controllers/Stacked Bars/DailyBarsChartController.swift

@@ -0,0 +1,259 @@
+//
+//  DailyBarsChartController.swift
+//  GraphTest
+//
+//  Created by Andrei Salavei on 4/7/19.
+//  Copyright © 2019 Andrei Salavei. All rights reserved.
+//
+
+import Foundation
+#if os(macOS)
+import Cocoa
+#else
+import UIKit
+#endif
+
+public class DailyBarsChartController: BaseChartController {
+    let barsController: BarsComponentController
+    let linesController: LinesComponentController
+    
+    override public init(chartsCollection: ChartsCollection)  {
+        let horizontalScalesRenderer = HorizontalScalesRenderer()
+        let verticalScalesRenderer = VerticalScalesRenderer()
+        barsController = BarsComponentController(isZoomed: false,
+                                                 mainBarsRenderer: BarChartRenderer(),
+                                                 horizontalScalesRenderer: horizontalScalesRenderer,
+                                                 verticalScalesRenderer: verticalScalesRenderer,
+                                                 previewBarsChartRenderer: BarChartRenderer())
+        linesController = LinesComponentController(isZoomed: true,
+                                                   userLinesTransitionAnimation: false,
+                                                   mainLinesRenderer: LinesChartRenderer(),
+                                                   horizontalScalesRenderer: horizontalScalesRenderer,
+                                                   verticalScalesRenderer: verticalScalesRenderer,
+                                                   verticalLineRenderer: VerticalLinesRenderer(),
+                                                   lineBulletsRenderer: LineBulletsRenderer(),
+                                                   previewLinesChartRenderer: LinesChartRenderer())
+        
+        super.init(chartsCollection: chartsCollection)
+        
+        [barsController, linesController].forEach { controller in
+            controller.chartFrame = { [unowned self] in self.chartFrame() }
+            controller.cartViewBounds = { [unowned self] in self.cartViewBounds() }
+            controller.zoomInOnDateClosure = { [unowned self] date in
+                self.didTapZoomIn(date: date, pointIndex: 0)
+            }
+            controller.setChartTitleClosure = { [unowned self] (title, animated) in
+                self.setChartTitleClosure?(title, animated)
+            }
+            controller.setDetailsViewPositionClosure = { [unowned self] (position) in
+                self.setDetailsViewPositionClosure?(position)
+            }
+            controller.setDetailsChartVisibleClosure = { [unowned self] (visible, animated) in
+                self.setDetailsChartVisibleClosure?(visible, animated)
+            }
+            controller.setDetailsViewModel = { [unowned self] (viewModel, animated, feedback) in
+                self.setDetailsViewModel?(viewModel, animated, feedback)
+            }
+            controller.updatePreviewRangeClosure = { [unowned self] (fraction, animated) in
+                self.chartRangeUpdatedClosure?(fraction, animated)
+            }
+            controller.chartRangePagingClosure = { [unowned self] (isEnabled, pageSize) in
+                self.setChartRangePagingEnabled(isEnabled: isEnabled, minimumSelectionSize: pageSize)
+            }
+        }
+    }
+    
+    public override var mainChartRenderers: [ChartViewRenderer] {
+        return [barsController.mainBarsRenderer,
+                linesController.mainLinesRenderer,
+                barsController.horizontalScalesRenderer,
+                barsController.verticalScalesRenderer,
+                linesController.verticalLineRenderer,
+                linesController.lineBulletsRenderer,
+//                performanceRenderer
+        ]
+    }
+    
+    public override var navigationRenderers: [ChartViewRenderer] {
+        return [barsController.previewBarsChartRenderer,
+                linesController.previewLinesChartRenderer]
+    }
+    
+    public override func initializeChart() {
+        barsController.initialize(chartsCollection: initialChartsCollection,
+                                  initialDate: Date(),
+                                  totalHorizontalRange: BaseConstants.defaultRange,
+                                  totalVerticalRange: BaseConstants.defaultRange)
+        switchToChart(chartsCollection: barsController.chartsCollection, isZoomed: false, animated: false)
+    }
+    
+    func switchToChart(chartsCollection: ChartsCollection, isZoomed: Bool, animated: Bool) {
+        if animated {
+            TimeInterval.setDefaultDuration(.expandAnimationDuration)
+            DispatchQueue.main.asyncAfter(deadline: .now() + .expandAnimationDuration) {
+                TimeInterval.setDefaultDuration(.osXDuration)
+            }
+        }
+        
+        super.isZoomed = isZoomed
+        if isZoomed {
+            let toHorizontalRange = linesController.initialHorizontalRange
+            let destinationHorizontalRange = (toHorizontalRange.lowerBound - barsController.barsWidth)...(toHorizontalRange.upperBound - barsController.barsWidth)
+            let initialChartVerticalRange = lineProportionAnimationRange()
+            
+            linesController.mainLinesRenderer.setup(horizontalRange: barsController.currentHorizontalMainChartRange, animated: false)
+            linesController.previewLinesChartRenderer.setup(horizontalRange: barsController.currentPreviewHorizontalRange, animated: false)
+            linesController.mainLinesRenderer.setup(verticalRange: initialChartVerticalRange, animated: false)
+            linesController.previewLinesChartRenderer.setup(verticalRange: initialChartVerticalRange, animated: false)
+            linesController.mainLinesRenderer.setVisible(false, animated: false)
+            linesController.previewLinesChartRenderer.setVisible(false, animated: false)
+            
+            barsController.setupMainChart(horizontalRange: destinationHorizontalRange, animated: animated)
+            barsController.previewBarsChartRenderer.setup(horizontalRange: linesController.totalHorizontalRange, animated: animated)
+            barsController.mainBarsRenderer.setVisible(false, animated: animated)
+            barsController.previewBarsChartRenderer.setVisible(false, animated: animated)
+            
+            linesController.willAppear(animated: animated)
+            barsController.willDisappear(animated: animated)
+            
+            linesController.updateChartsVisibility(visibility: linesController.chartLines.map { _ in true }, animated: false)
+        } else {
+            if !linesController.chartsCollection.isBlank {
+                barsController.hideDetailsView(animated: false)
+                let visibleVerticalRange = BarChartRenderer.BarsData.verticalRange(bars: barsController.visibleBars,
+                                                                                   calculatingRange: barsController.initialHorizontalRange) ?? BaseConstants.defaultRange
+                barsController.mainBarsRenderer.setup(verticalRange: visibleVerticalRange, animated: false)
+                
+                let toHorizontalRange = barsController.initialHorizontalRange
+                let destinationChartVerticalRange = lineProportionAnimationRange()
+                
+                linesController.setupMainChart(horizontalRange: toHorizontalRange, animated: animated)
+                linesController.mainLinesRenderer.setup(verticalRange: destinationChartVerticalRange, animated: animated)
+                linesController.previewLinesChartRenderer.setup(verticalRange: destinationChartVerticalRange, animated: animated)
+                linesController.previewLinesChartRenderer.setup(horizontalRange: barsController.totalHorizontalRange, animated: animated)
+                linesController.mainLinesRenderer.setVisible(false, animated: animated)
+                linesController.previewLinesChartRenderer.setVisible(false, animated: animated)
+            }
+            
+            barsController.willAppear(animated: animated)
+            linesController.willDisappear(animated: animated)
+        }
+        
+        self.setBackButtonVisibilityClosure?(isZoomed, animated)
+        self.refreshChartToolsClosure?(animated)
+    }
+    
+    public override func updateChartsVisibility(visibility: [Bool], animated: Bool) {
+        if isZoomed {
+            linesController.updateChartsVisibility(visibility: visibility, animated: animated)
+        } else {
+            barsController.updateChartsVisibility(visibility: visibility, animated: animated)
+        }
+    }
+    
+    var visibleChartValues: [ChartsCollection.Chart] {
+        let visibility = isZoomed ? linesController.chartVisibility : barsController.chartVisibility
+        let collection = isZoomed ? linesController.chartsCollection : barsController.chartsCollection
+        let visibleCharts: [ChartsCollection.Chart] = visibility.enumerated().compactMap { args in
+            args.element ? collection.chartValues[args.offset] : nil
+        }
+        return visibleCharts
+    }
+    
+    public override var actualChartVisibility: [Bool] {
+        return isZoomed ? linesController.chartVisibility : barsController.chartVisibility
+    }
+    
+    public override var actualChartsCollection: ChartsCollection {
+        let collection = isZoomed ? linesController.chartsCollection : barsController.chartsCollection
+        
+        if collection.isBlank {
+            return self.initialChartsCollection
+        }
+        return collection
+    }
+    
+    public override func chartInteractionDidBegin(point: CGPoint, manual: Bool = true) {
+        if isZoomed {
+            linesController.chartInteractionDidBegin(point: point, manual: manual)
+        } else {
+            barsController.chartInteractionDidBegin(point: point, manual: manual)
+        }
+    }
+    
+    public override func chartInteractionDidEnd() {
+        if isZoomed {
+            linesController.chartInteractionDidEnd()
+        } else {
+            barsController.chartInteractionDidEnd()
+        }
+    }
+    
+    public override var currentChartHorizontalRangeFraction: ClosedRange<CGFloat> {
+        if isZoomed {
+            return linesController.currentChartHorizontalRangeFraction
+        } else {
+            return barsController.currentChartHorizontalRangeFraction
+        }
+    }
+    
+    public override func cancelChartInteraction() {
+        if isZoomed {
+            return linesController.hideDetailsView(animated: true)
+        } else {
+            return barsController.hideDetailsView(animated: true)
+        }
+    }
+    
+    public override func didTapZoomIn(date: Date, pointIndex: Int) {
+        guard !isZoomed, isZoomable else { return }
+        if isZoomed {
+            return linesController.hideDetailsView(animated: true)
+        }
+        self.getDetailsData?(date, { updatedCollection in
+            if let updatedCollection = updatedCollection {
+                self.linesController.initialize(chartsCollection: updatedCollection,
+                                                initialDate: date,
+                                                totalHorizontalRange: 0...1,
+                                                totalVerticalRange: 0...1)
+                self.switchToChart(chartsCollection: updatedCollection, isZoomed: true, animated: true)
+            }
+        })
+    }
+    
+    func lineProportionAnimationRange() -> ClosedRange<CGFloat> {
+        let visibleLines = self.barsController.chartVisibility.enumerated().compactMap { $0.element ? self.linesController.chartLines[$0.offset] : nil }
+        let linesRange = LinesChartRenderer.LineData.verticalRange(lines: visibleLines) ?? BaseConstants.defaultRange
+        let barsRange = BarChartRenderer.BarsData.verticalRange(bars: self.barsController.visibleBars,
+                                                                calculatingRange: self.linesController.totalHorizontalRange) ?? BaseConstants.defaultRange
+        let range = 0...(linesRange.upperBound / barsRange.distance * self.barsController.currentVerticalMainChartRange.distance)
+        return range
+    }
+    
+   public override func didTapZoomOut() {
+        cancelChartInteraction()
+        switchToChart(chartsCollection: barsController.chartsCollection, isZoomed: false, animated: true)
+    }
+    
+    public override func updateChartRange(_ rangeFraction: ClosedRange<CGFloat>, animated: Bool = true) {
+        if isZoomed {
+            return linesController.chartRangeFractionDidUpdated(rangeFraction)
+        } else {
+            return barsController.chartRangeFractionDidUpdated(rangeFraction)
+        }
+    }
+    
+    override public func apply(theme: ChartTheme, strings: ChartStrings, animated: Bool) {
+        super.apply(theme: theme, strings: strings, animated: animated)
+        
+        linesController.apply(theme: theme, strings: strings, animated: animated)
+        barsController.apply(theme: theme, strings: strings, animated: animated)
+    }
+
+    public override var drawChartVisibity: Bool {
+        return true
+    }
+}
+
+//TODO: Убрать Performance полоски сверзу чартов (Не забыть)
+//TODO: Добавить ховеры на кнопки

submodules/GraphCore/Sources/Charts/Controllers/Stacked Bars/LinesComponentController.swift

@@ -0,0 +1,215 @@
+//
+//  LinesComponentController.swift
+//  GraphTest
+//
+//  Created by Andrei Salavei on 4/14/19.
+//  Copyright © 2019 Andrei Salavei. All rights reserved.
+//
+
+import Foundation
+#if os(macOS)
+import Cocoa
+#else
+import UIKit
+#endif
+
+class LinesComponentController: GeneralChartComponentController {
+    let mainLinesRenderer: LinesChartRenderer
+    let horizontalScalesRenderer: HorizontalScalesRenderer
+    let verticalScalesRenderer: VerticalScalesRenderer
+    let verticalLineRenderer: VerticalLinesRenderer
+    let lineBulletsRenderer: LineBulletsRenderer
+    
+    let previewLinesChartRenderer: LinesChartRenderer
+    
+    private let zoomedLinesRenderer = LinesChartRenderer()
+    private let zoomedPreviewLinesRenderer = LinesChartRenderer()
+
+    private let userLinesTransitionAnimation: Bool
+
+    private(set) var chartLines: [LinesChartRenderer.LineData] = []
+    
+    init(isZoomed: Bool,
+         userLinesTransitionAnimation: Bool,
+         mainLinesRenderer: LinesChartRenderer,
+         horizontalScalesRenderer: HorizontalScalesRenderer,
+         verticalScalesRenderer: VerticalScalesRenderer,
+         verticalLineRenderer: VerticalLinesRenderer,
+         lineBulletsRenderer: LineBulletsRenderer,
+         previewLinesChartRenderer: LinesChartRenderer) {
+        self.mainLinesRenderer = mainLinesRenderer
+        self.horizontalScalesRenderer = horizontalScalesRenderer
+        self.verticalScalesRenderer = verticalScalesRenderer
+        self.verticalLineRenderer = verticalLineRenderer
+        self.lineBulletsRenderer = lineBulletsRenderer
+        self.previewLinesChartRenderer = previewLinesChartRenderer
+        self.userLinesTransitionAnimation = userLinesTransitionAnimation
+        
+        super.init(isZoomed: isZoomed)
+        
+        self.mainLinesRenderer.lineWidth = BaseConstants.mainChartLineWidth
+        self.mainLinesRenderer.optimizationLevel = BaseConstants.linesChartOptimizationLevel
+        self.previewLinesChartRenderer.lineWidth = BaseConstants.previewChartLineWidth
+        self.previewLinesChartRenderer.optimizationLevel = BaseConstants.previewLinesChartOptimizationLevel
+        
+        self.lineBulletsRenderer.isEnabled = false
+    }
+    
+    override func initialize(chartsCollection: ChartsCollection,
+                             initialDate: Date,
+                             totalHorizontalRange _: ClosedRange<CGFloat>,
+                             totalVerticalRange _: ClosedRange<CGFloat>) {
+        let (chartLines, totalHorizontalRange, totalVerticalRange) = LinesChartRenderer.LineData.initialComponents(chartsCollection: chartsCollection)
+        self.chartLines = chartLines
+        
+        self.lineBulletsRenderer.bullets = self.chartLines.map { LineBulletsRenderer.Bullet(coordinate: $0.points.first ?? .zero, offset: .zero,
+                                                                                          color: $0.color)}
+        
+        super.initialize(chartsCollection: chartsCollection,
+                         initialDate: initialDate,
+                         totalHorizontalRange: totalHorizontalRange,
+                         totalVerticalRange: totalVerticalRange)
+        
+        self.mainLinesRenderer.setup(verticalRange: totalVerticalRange, animated: true)
+    }
+    
+    override func willAppear(animated: Bool) {
+        mainLinesRenderer.setLines(lines: self.chartLines, animated: animated && userLinesTransitionAnimation)
+        previewLinesChartRenderer.setLines(lines: self.chartLines, animated: animated && userLinesTransitionAnimation)
+        
+        previewLinesChartRenderer.setup(verticalRange: totalVerticalRange, animated: animated)
+        previewLinesChartRenderer.setup(horizontalRange: totalHorizontalRange, animated: animated)
+        
+        setupMainChart(verticalRange: initialVerticalRange, animated: animated)
+        setupMainChart(horizontalRange: initialHorizontalRange, animated: animated)
+        
+        updateChartVerticalRanges(horizontalRange: initialHorizontalRange, animated: animated)
+        
+        super.willAppear(animated: animated)
+        
+        updatePreviewRangeClosure?(currentChartHorizontalRangeFraction, animated)
+        setConponentsVisible(visible: true, animated: animated)
+        updateHorizontalLimitLabels(animated: animated, forceUpdate: true)
+    }
+    
+    override func chartRangeDidUpdated(_ updatedRange: ClosedRange<CGFloat>) {
+        super.chartRangeDidUpdated(updatedRange)
+        if !isZoomed {
+            initialHorizontalRange = updatedRange
+        }
+        setupMainChart(horizontalRange: updatedRange, animated: false)
+        updateHorizontalLimitLabels(animated: true, forceUpdate: false)
+        updateChartVerticalRanges(horizontalRange: updatedRange, animated: true)
+    }
+    
+    func updateHorizontalLimitLabels(animated: Bool, forceUpdate: Bool) {
+        updateHorizontalLimitLabels(horizontalScalesRenderer: horizontalScalesRenderer,
+                                    horizontalRange: currentHorizontalMainChartRange,
+                                    scaleType: isZoomed ? .hour : .day,
+                                    forceUpdate: forceUpdate,
+                                    animated: animated)
+    }
+    
+    func prepareAppearanceAnimation(horizontalRnage: ClosedRange<CGFloat>) {
+        setupMainChart(horizontalRange: horizontalRnage, animated: false)
+        setConponentsVisible(visible: false, animated: false)
+    }
+    
+    func setConponentsVisible(visible: Bool, animated: Bool) {
+        mainLinesRenderer.setVisible(visible, animated: animated)
+        horizontalScalesRenderer.setVisible(visible, animated: animated)
+        verticalScalesRenderer.setVisible(visible, animated: animated)
+        verticalLineRenderer.setVisible(visible, animated: animated)
+        previewLinesChartRenderer.setVisible(visible, animated: animated)
+        lineBulletsRenderer.setVisible(visible, animated: animated)
+    }
+    
+    func setupMainChart(horizontalRange: ClosedRange<CGFloat>, animated: Bool) {
+        mainLinesRenderer.setup(horizontalRange: horizontalRange, animated: animated)
+        horizontalScalesRenderer.setup(horizontalRange: horizontalRange, animated: animated)
+        verticalScalesRenderer.setup(horizontalRange: horizontalRange, animated: animated)
+        verticalLineRenderer.setup(horizontalRange: horizontalRange, animated: animated)
+        lineBulletsRenderer.setup(horizontalRange: horizontalRange, animated: animated)
+    }
+    
+    var visibleLines: [LinesChartRenderer.LineData] {
+        return chartVisibility.enumerated().compactMap { $0.element ? chartLines[$0.offset] : nil }
+    }
+    
+    func updateChartVerticalRanges(horizontalRange: ClosedRange<CGFloat>, animated: Bool) {
+        if let range = LinesChartRenderer.LineData.verticalRange(lines: visibleLines,
+                                                                 calculatingRange: horizontalRange,
+                                                                 addBounds: true) {
+            let (range, labels) = verticalLimitsLabels(verticalRange: range)
+            if verticalScalesRenderer.verticalRange.end != range {
+                verticalScalesRenderer.setup(verticalLimitsLabels: labels, animated: animated)
+            }
+            
+            setupMainChart(verticalRange: range, animated: animated)
+            verticalScalesRenderer.setVisible(true, animated: animated)
+        } else {
+            verticalScalesRenderer.setVisible(false, animated: animated)
+        }
+        
+        if let range = LinesChartRenderer.LineData.verticalRange(lines: visibleLines) {
+            previewLinesChartRenderer.setup(verticalRange: range, animated: animated)
+        }
+    }
+    
+    func setupMainChart(verticalRange: ClosedRange<CGFloat>, animated: Bool) {
+        mainLinesRenderer.setup(verticalRange: verticalRange, animated: animated)
+        horizontalScalesRenderer.setup(verticalRange: verticalRange, animated: animated)
+        verticalScalesRenderer.setup(verticalRange: verticalRange, animated: animated)
+        verticalLineRenderer.setup(verticalRange: verticalRange, animated: animated)
+        lineBulletsRenderer.setup(verticalRange: verticalRange, animated: animated)
+    }
+    
+    public override func updateChartsVisibility(visibility: [Bool], animated: Bool) {
+        super.updateChartsVisibility(visibility: visibility, animated: animated)
+        for (index, isVisible) in visibility.enumerated() {
+            mainLinesRenderer.setLineVisible(isVisible, at: index, animated: animated)
+            previewLinesChartRenderer.setLineVisible(isVisible, at: index, animated: animated)
+            lineBulletsRenderer.setLineVisible(isVisible, at: index, animated: animated)
+        }
+        updateChartVerticalRanges(horizontalRange: currentHorizontalMainChartRange, animated: true)
+    }
+    
+    override var currentMainRangeRenderer: BaseChartRenderer {
+        return mainLinesRenderer
+    }
+    
+    override var currentPreviewRangeRenderer: BaseChartRenderer {
+        return previewLinesChartRenderer
+    }
+    
+    override func showDetailsView(at chartPosition: CGFloat, detailsViewPosition: CGFloat, dataIndex: Int, date: Date, animated: Bool, feedback: Bool) {
+        super.showDetailsView(at: chartPosition, detailsViewPosition: detailsViewPosition, dataIndex: dataIndex, date: date, animated: animated, feedback: feedback)
+        verticalLineRenderer.values = [chartPosition]
+        verticalLineRenderer.isEnabled = true
+        
+        lineBulletsRenderer.isEnabled = true
+        lineBulletsRenderer.setVisible(true, animated: animated)
+        lineBulletsRenderer.bullets = chartLines.compactMap { chart in
+            return LineBulletsRenderer.Bullet(coordinate: chart.points[dataIndex], offset: .zero, color: chart.color)
+        }
+    }
+    
+    override func hideDetailsView(animated: Bool) {
+        super.hideDetailsView(animated: animated)
+        
+        verticalLineRenderer.values = []
+        verticalLineRenderer.isEnabled = false
+        lineBulletsRenderer.isEnabled = false
+    }
+    
+    override func apply(theme: ChartTheme, strings: ChartStrings, animated: Bool) {
+        super.apply(theme: theme, strings: strings, animated: animated)
+        
+        horizontalScalesRenderer.labelsColor = theme.chartLabelsColor
+        verticalScalesRenderer.labelsColor = theme.chartLabelsColor
+        verticalScalesRenderer.axisXColor = theme.chartStrongLinesColor
+        verticalScalesRenderer.horizontalLinesColor = theme.chartHelperLinesColor
+        lineBulletsRenderer.setInnerColor(theme.chartBackgroundColor, animated: animated)
+        verticalLineRenderer.linesColor = theme.chartStrongLinesColor
+    }
+}

submodules/GraphCore/Sources/Charts/Controllers/Stacked Bars/StackedBarsChartController.swift

@@ -0,0 +1,289 @@
+//
+//  StackedBarsChartController.swift
+//  GraphTest
+//
+//  Created by Andrei Salavei on 4/7/19.
+//  Copyright © 2019 Andrei Salavei. All rights reserved.
+//
+
+import Foundation
+#if os(macOS)
+import Cocoa
+#else
+import UIKit
+#endif
+
+public enum GraphCurrency : String {
+    case xtr = "XTR"
+    case ton = "TON"
+    
+    var formatter: NumberFormatter {
+        switch self {
+        case .xtr:
+            return BaseConstants.starNumberFormatter
+        case .ton:
+            return BaseConstants.tonNumberFormatter
+        }
+    }
+}
+
+public class StackedBarsChartController: BaseChartController {
+    let barsController: BarsComponentController
+    let zoomedBarsController: BarsComponentController
+    
+    override public var isZoomable: Bool {
+        didSet {
+            barsController.isZoomable = self.isZoomable
+        }
+    }
+    
+    public init(chartsCollection: ChartsCollection, currency: GraphCurrency? = nil, drawCurrency:((CGContext, UIColor, CGPoint)->Void)? = nil, rate: Double = 1.0)  {
+        let horizontalScalesRenderer = HorizontalScalesRenderer()
+        let verticalScalesRenderer = VerticalScalesRenderer()
+        var secondaryScalesRenderer: VerticalScalesRenderer?
+        if let _ = currency {
+            verticalScalesRenderer.drawCurrency = drawCurrency
+            secondaryScalesRenderer = VerticalScalesRenderer()
+            secondaryScalesRenderer?.isRightAligned = true
+        }
+        barsController = BarsComponentController(isZoomed: false,
+                                                 mainBarsRenderer: BarChartRenderer(),
+                                                 horizontalScalesRenderer: horizontalScalesRenderer,
+                                                 verticalScalesRenderer: verticalScalesRenderer,
+                                                 secondaryScalesRenderer: secondaryScalesRenderer,
+                                                 previewBarsChartRenderer: BarChartRenderer())
+        if let currency {
+            barsController.currency = currency
+            barsController.conversionRate = rate
+            barsController.verticalLimitsNumberFormatter = currency.formatter
+            barsController.detailsNumberFormatter = currency.formatter
+        }
+        zoomedBarsController = BarsComponentController(isZoomed: true,
+                                                       mainBarsRenderer: BarChartRenderer(),
+                                                       horizontalScalesRenderer: horizontalScalesRenderer,
+                                                       verticalScalesRenderer: verticalScalesRenderer,
+                                                       previewBarsChartRenderer: BarChartRenderer())
+
+        super.init(chartsCollection: chartsCollection)
+        
+        [barsController, zoomedBarsController].forEach { controller in
+            controller.chartFrame = { [unowned self] in self.chartFrame() }
+            controller.cartViewBounds = { [unowned self] in self.cartViewBounds() }
+            controller.zoomInOnDateClosure = { [unowned self] date in
+                self.didTapZoomIn(date: date, pointIndex: 0)
+            }
+            controller.setChartTitleClosure = { [unowned self] (title, animated) in
+                self.setChartTitleClosure?(title, animated)
+            }
+            controller.setDetailsViewPositionClosure = { [unowned self] (position) in
+                self.setDetailsViewPositionClosure?(position)
+            }
+            controller.setDetailsChartVisibleClosure = { [unowned self] (visible, animated) in
+                self.setDetailsChartVisibleClosure?(visible, animated)
+            }
+            controller.setDetailsViewModel = { [unowned self] (viewModel, animated, feedback) in
+                self.setDetailsViewModel?(viewModel, animated, feedback)
+            }
+            controller.updatePreviewRangeClosure = { [unowned self] (fraction, animated) in
+                self.chartRangeUpdatedClosure?(fraction, animated)
+            }
+            controller.chartRangePagingClosure = { [unowned self] (isEnabled, pageSize) in
+                self.setChartRangePagingEnabled(isEnabled: isEnabled, minimumSelectionSize: pageSize)
+            }
+        }
+    }
+    
+    public override var mainChartRenderers: [ChartViewRenderer] {
+        var renderers = [barsController.mainBarsRenderer,
+                zoomedBarsController.mainBarsRenderer,
+                barsController.horizontalScalesRenderer,
+                barsController.verticalScalesRenderer,
+//                performanceRenderer
+        ]
+        if let secondary = barsController.secondaryScalesRenderer {
+            renderers.append(secondary)
+        }
+        return renderers
+    }
+    
+    public override var navigationRenderers: [ChartViewRenderer] {
+        return [barsController.previewBarsChartRenderer,
+                zoomedBarsController.previewBarsChartRenderer]
+    }
+    
+    public override func initializeChart() {
+        barsController.initialize(chartsCollection: initialChartsCollection,
+                                  initialDate: Date(),
+                                  totalHorizontalRange: BaseConstants.defaultRange,
+                                  totalVerticalRange: BaseConstants.defaultRange)
+        switchToChart(chartsCollection: barsController.chartsCollection, isZoomed: false, animated: false)
+    }
+    
+    func switchToChart(chartsCollection: ChartsCollection, isZoomed: Bool, animated: Bool) {
+        if animated {
+            TimeInterval.setDefaultDuration(.expandAnimationDuration)
+            DispatchQueue.main.asyncAfter(deadline: .now() + .expandAnimationDuration) {
+                TimeInterval.setDefaultDuration(.osXDuration)
+            }
+        }
+
+        super.isZoomed = isZoomed
+        if isZoomed {
+            let toHorizontalRange = zoomedBarsController.initialHorizontalRange
+            let destinationHorizontalRange = (toHorizontalRange.lowerBound - barsController.barsWidth)...(toHorizontalRange.upperBound - barsController.barsWidth)
+            let verticalVisibleRange = barsController.currentVerticalMainChartRange
+            let initialVerticalRange = verticalVisibleRange.lowerBound...(verticalVisibleRange.upperBound + verticalVisibleRange.distance * 10)
+ 
+            zoomedBarsController.mainBarsRenderer.setup(horizontalRange: barsController.currentHorizontalMainChartRange, animated: false)
+            zoomedBarsController.previewBarsChartRenderer.setup(horizontalRange: barsController.currentPreviewHorizontalRange, animated: false)
+            zoomedBarsController.mainBarsRenderer.setup(verticalRange: initialVerticalRange, animated: false)
+            zoomedBarsController.previewBarsChartRenderer.setup(verticalRange: initialVerticalRange, animated: false)
+            zoomedBarsController.mainBarsRenderer.setVisible(true, animated: false)
+            zoomedBarsController.previewBarsChartRenderer.setVisible(true, animated: false)
+
+            barsController.setupMainChart(horizontalRange: destinationHorizontalRange, animated: animated)
+            barsController.previewBarsChartRenderer.setup(horizontalRange: zoomedBarsController.totalHorizontalRange, animated: animated)
+            barsController.mainBarsRenderer.setVisible(false, animated: animated)
+            barsController.previewBarsChartRenderer.setVisible(false, animated: animated)
+
+            zoomedBarsController.willAppear(animated: animated)
+            barsController.willDisappear(animated: animated)
+            
+            zoomedBarsController.updateChartsVisibility(visibility: barsController.chartVisibility, animated: false)
+            zoomedBarsController.mainBarsRenderer.setup(verticalRange: zoomedBarsController.currentVerticalMainChartRange, animated: animated, timeFunction: .easeInOut)
+            zoomedBarsController.previewBarsChartRenderer.setup(verticalRange: zoomedBarsController.currentPreviewVerticalRange, animated: animated, timeFunction: .easeInOut)
+        } else {
+            if !zoomedBarsController.chartsCollection.isBlank {
+                barsController.hideDetailsView(animated: false)
+                barsController.chartVisibility = zoomedBarsController.chartVisibility
+                let visibleVerticalRange = BarChartRenderer.BarsData.verticalRange(bars: barsController.visibleBars,
+                                                                                   calculatingRange: barsController.initialHorizontalRange) ?? BaseConstants.defaultRange
+                barsController.mainBarsRenderer.setup(verticalRange: visibleVerticalRange, animated: false)
+                
+                let toHorizontalRange = barsController.initialHorizontalRange
+
+                let verticalVisibleRange = barsController.initialVerticalRange
+                let targetVerticalRange = verticalVisibleRange.lowerBound...(verticalVisibleRange.upperBound + verticalVisibleRange.distance * 10)
+
+                zoomedBarsController.setupMainChart(horizontalRange: toHorizontalRange, animated: animated)
+                zoomedBarsController.mainBarsRenderer.setup(verticalRange: targetVerticalRange, animated: animated, timeFunction: .easeInOut)
+                zoomedBarsController.previewBarsChartRenderer.setup(verticalRange: targetVerticalRange, animated: animated, timeFunction: .easeInOut)
+                zoomedBarsController.previewBarsChartRenderer.setup(horizontalRange: barsController.totalHorizontalRange, animated: animated)
+                DispatchQueue.main.asyncAfter(deadline: .now() + .defaultDuration) { [weak self] in
+                    self?.zoomedBarsController.mainBarsRenderer.setVisible(false, animated: false)
+                    self?.zoomedBarsController.previewBarsChartRenderer.setVisible(false, animated: false)
+                }
+            }
+            
+            barsController.willAppear(animated: animated)
+            zoomedBarsController.willDisappear(animated: animated)
+            
+            if !zoomedBarsController.chartsCollection.isBlank {
+                barsController.updateChartsVisibility(visibility: zoomedBarsController.chartVisibility, animated: false)
+            }
+        }
+        
+        self.setBackButtonVisibilityClosure?(isZoomed, animated)
+    }
+    
+    public override func updateChartsVisibility(visibility: [Bool], animated: Bool) {
+        if isZoomed {
+            zoomedBarsController.updateChartsVisibility(visibility: visibility, animated: animated)
+        } else {
+            barsController.updateChartsVisibility(visibility: visibility, animated: animated)
+        }
+    }
+    
+    var visibleChartValues: [ChartsCollection.Chart] {
+        let visibility = isZoomed ? zoomedBarsController.chartVisibility : barsController.chartVisibility
+        let collection = isZoomed ? zoomedBarsController.chartsCollection : barsController.chartsCollection
+        let visibleCharts: [ChartsCollection.Chart] = visibility.enumerated().compactMap { args in
+            args.element ? collection.chartValues[args.offset] : nil
+        }
+        return visibleCharts
+    }
+    
+    public override var actualChartVisibility: [Bool] {
+        return isZoomed ? zoomedBarsController.chartVisibility : barsController.chartVisibility
+    }
+    
+    public override var actualChartsCollection: ChartsCollection {
+        let collection = isZoomed ? zoomedBarsController.chartsCollection : barsController.chartsCollection
+        if collection.isBlank {
+            return self.initialChartsCollection
+        }
+        return collection
+    }
+
+    public override func chartInteractionDidBegin(point: CGPoint, manual: Bool = true) {
+        if isZoomed {
+            zoomedBarsController.chartInteractionDidBegin(point: point, manual: manual)
+        } else {
+            barsController.chartInteractionDidBegin(point: point, manual: manual)
+        }
+    }
+    
+    public override func chartInteractionDidEnd() {
+        if isZoomed {
+            zoomedBarsController.chartInteractionDidEnd()
+        } else {
+            barsController.chartInteractionDidEnd()
+        }
+    }
+    
+    public override var drawChartVisibity: Bool {
+        return true
+    }
+    
+    public override var currentChartHorizontalRangeFraction: ClosedRange<CGFloat> {
+        if isZoomed {
+            return zoomedBarsController.currentChartHorizontalRangeFraction
+        } else {
+            return barsController.currentChartHorizontalRangeFraction
+        }
+    }
+    
+    public override func cancelChartInteraction() {
+        if isZoomed {
+            return zoomedBarsController.hideDetailsView(animated: true)
+        } else {
+            return barsController.hideDetailsView(animated: true)
+        }
+    }
+    
+    public override func didTapZoomIn(date: Date, pointIndex: Int) {
+        guard !isZoomed, isZoomable else { return }
+        if isZoomed {
+            return zoomedBarsController.hideDetailsView(animated: true)
+        }
+        self.getDetailsData?(date, { updatedCollection in
+            if let updatedCollection = updatedCollection {
+                self.zoomedBarsController.initialize(chartsCollection: updatedCollection,
+                                                initialDate: date,
+                                                totalHorizontalRange: 0...1,
+                                                totalVerticalRange: 0...1)
+                self.switchToChart(chartsCollection: updatedCollection, isZoomed: true, animated: true)
+            }
+        })
+    }
+    
+   public override func didTapZoomOut() {
+        cancelChartInteraction()
+        switchToChart(chartsCollection: barsController.chartsCollection, isZoomed: false, animated: true)
+    }
+    
+    public override func updateChartRange(_ rangeFraction: ClosedRange<CGFloat>, animated: Bool = true) {
+        if isZoomed {
+            return zoomedBarsController.chartRangeFractionDidUpdated(rangeFraction)
+        } else {
+            return barsController.chartRangeFractionDidUpdated(rangeFraction)
+        }
+    }
+    
+    public override func apply(theme: ChartTheme, strings: ChartStrings, animated: Bool) {
+        super.apply(theme: theme, strings: strings, animated: animated)
+        
+        zoomedBarsController.apply(theme: theme, strings: strings, animated: animated)
+        barsController.apply(theme: theme, strings: strings, animated: animated)
+    }
+}

submodules/GraphCore/Sources/Charts/Controllers/Stacked Bars/StepBarsChartController.swift

@@ -0,0 +1,271 @@
+//
+//  StackedBarsChartController.swift
+//  GraphTest
+//
+//  Created by Andrei Salavei on 4/7/19.
+//  Copyright © 2019 Andrei Salavei. All rights reserved.
+//
+
+import Foundation
+#if os(macOS)
+import Cocoa
+#else
+import UIKit
+#endif
+
+public class StepBarsChartController: BaseChartController {
+    let barsController: BarsComponentController
+    let zoomedBarsController: BarsComponentController
+    
+    override public var isZoomable: Bool {
+        didSet {
+            barsController.isZoomable = self.isZoomable
+        }
+    }
+    
+    override public init(chartsCollection: ChartsCollection)  {
+        let horizontalScalesRenderer = HorizontalScalesRenderer()
+        let verticalScalesRenderer = VerticalScalesRenderer()
+        barsController = BarsComponentController(isZoomed: false,
+                                                 mainBarsRenderer: BarChartRenderer(step: true),
+                                                 horizontalScalesRenderer: horizontalScalesRenderer,
+                                                 verticalScalesRenderer: verticalScalesRenderer,
+                                                 previewBarsChartRenderer: BarChartRenderer(step: true), step: true)
+        zoomedBarsController = BarsComponentController(isZoomed: true,
+                                                       mainBarsRenderer: BarChartRenderer(),
+                                                       horizontalScalesRenderer: horizontalScalesRenderer,
+                                                       verticalScalesRenderer: verticalScalesRenderer,
+                                                       previewBarsChartRenderer: BarChartRenderer(), step: true)
+
+        super.init(chartsCollection: chartsCollection)
+        
+        [barsController, zoomedBarsController].forEach { controller in
+            controller.chartFrame = { [unowned self] in self.chartFrame() }
+            controller.cartViewBounds = { [unowned self] in self.cartViewBounds() }
+            controller.zoomInOnDateClosure = { [unowned self] date in
+                self.didTapZoomIn(date: date, pointIndex: 0)
+            }
+            controller.setChartTitleClosure = { [unowned self] (title, animated) in
+                self.setChartTitleClosure?("", animated)
+            }
+            controller.setDetailsViewPositionClosure = { [unowned self] (position) in
+                self.setDetailsViewPositionClosure?(position)
+            }
+            controller.setDetailsChartVisibleClosure = { [unowned self] (visible, animated) in
+                self.setDetailsChartVisibleClosure?(visible, animated)
+            }
+            controller.setDetailsViewModel = { [unowned self] (viewModel, animated, feedback) in
+                self.setDetailsViewModel?(viewModel, animated, feedback)
+            }
+            controller.updatePreviewRangeClosure = { [unowned self] (fraction, animated) in
+                self.chartRangeUpdatedClosure?(fraction, animated)
+            }
+            controller.chartRangePagingClosure = { [unowned self] (isEnabled, pageSize) in
+                self.setChartRangePagingEnabled(isEnabled: isEnabled, minimumSelectionSize: pageSize)
+            }
+        }
+    }
+    
+    public var hourly: Bool = false
+    
+    public convenience init(chartsCollection: ChartsCollection, hourly: Bool)  {
+        self.init(chartsCollection: chartsCollection)
+        self.hourly = hourly
+    }
+    
+    public override var mainChartRenderers: [ChartViewRenderer] {
+        return [barsController.mainBarsRenderer,
+                zoomedBarsController.mainBarsRenderer,
+                barsController.horizontalScalesRenderer,
+                barsController.verticalScalesRenderer,
+                barsController.lineBulletsRenderer,
+                barsController.verticalLineRenderer
+//                performanceRenderer
+        ]
+    }
+    
+    public override var navigationRenderers: [ChartViewRenderer] {
+        return [barsController.previewBarsChartRenderer,
+                zoomedBarsController.previewBarsChartRenderer]
+    }
+    
+    public override func initializeChart() {
+        barsController.initialize(chartsCollection: initialChartsCollection,
+                                  initialDate: Date(),
+                                  totalHorizontalRange: BaseConstants.defaultRange,
+                                  totalVerticalRange: BaseConstants.defaultRange)
+        switchToChart(chartsCollection: barsController.chartsCollection, isZoomed: false, animated: false)
+    }
+    
+    func switchToChart(chartsCollection: ChartsCollection, isZoomed: Bool, animated: Bool) {
+        if animated {
+            TimeInterval.setDefaultDuration(.expandAnimationDuration)
+            DispatchQueue.main.asyncAfter(deadline: .now() + .expandAnimationDuration) {
+                TimeInterval.setDefaultDuration(.osXDuration)
+            }
+        }
+
+        super.isZoomed = isZoomed
+        if isZoomed {
+            let toHorizontalRange = zoomedBarsController.initialHorizontalRange
+            let destinationHorizontalRange = (toHorizontalRange.lowerBound - barsController.barsWidth)...(toHorizontalRange.upperBound - barsController.barsWidth)
+            let verticalVisibleRange = barsController.currentVerticalMainChartRange
+            let initialVerticalRange = verticalVisibleRange.lowerBound...(verticalVisibleRange.upperBound + verticalVisibleRange.distance * 10)
+ 
+            zoomedBarsController.mainBarsRenderer.setup(horizontalRange: barsController.currentHorizontalMainChartRange, animated: false)
+            zoomedBarsController.previewBarsChartRenderer.setup(horizontalRange: barsController.currentPreviewHorizontalRange, animated: false)
+            zoomedBarsController.mainBarsRenderer.setup(verticalRange: initialVerticalRange, animated: false)
+            zoomedBarsController.previewBarsChartRenderer.setup(verticalRange: initialVerticalRange, animated: false)
+            zoomedBarsController.mainBarsRenderer.setVisible(true, animated: false)
+            zoomedBarsController.previewBarsChartRenderer.setVisible(true, animated: false)
+
+            barsController.setupMainChart(horizontalRange: destinationHorizontalRange, animated: animated)
+            barsController.previewBarsChartRenderer.setup(horizontalRange: zoomedBarsController.totalHorizontalRange, animated: animated)
+            barsController.mainBarsRenderer.setVisible(false, animated: animated)
+            barsController.previewBarsChartRenderer.setVisible(false, animated: animated)
+
+            zoomedBarsController.willAppear(animated: animated)
+            barsController.willDisappear(animated: animated)
+            
+            zoomedBarsController.updateChartsVisibility(visibility: barsController.chartVisibility, animated: false)
+            zoomedBarsController.mainBarsRenderer.setup(verticalRange: zoomedBarsController.currentVerticalMainChartRange, animated: animated, timeFunction: .easeInOut)
+            zoomedBarsController.previewBarsChartRenderer.setup(verticalRange: zoomedBarsController.currentPreviewVerticalRange, animated: animated, timeFunction: .easeInOut)
+        } else {
+            if !zoomedBarsController.chartsCollection.isBlank {
+                barsController.hideDetailsView(animated: false)
+                barsController.chartVisibility = zoomedBarsController.chartVisibility
+                let visibleVerticalRange = BarChartRenderer.BarsData.verticalRange(bars: barsController.visibleBars,
+                                                                                   separate: true,
+                                                                                   calculatingRange: barsController.initialHorizontalRange) ?? BaseConstants.defaultRange
+                barsController.mainBarsRenderer.setup(verticalRange: visibleVerticalRange, animated: false)
+                
+                let toHorizontalRange = barsController.initialHorizontalRange
+
+                let verticalVisibleRange = barsController.initialVerticalRange
+                let targetVerticalRange = verticalVisibleRange.lowerBound...(verticalVisibleRange.upperBound + verticalVisibleRange.distance * 10)
+
+                zoomedBarsController.setupMainChart(horizontalRange: toHorizontalRange, animated: animated)
+                zoomedBarsController.mainBarsRenderer.setup(verticalRange: targetVerticalRange, animated: animated, timeFunction: .easeInOut)
+                zoomedBarsController.previewBarsChartRenderer.setup(verticalRange: targetVerticalRange, animated: animated, timeFunction: .easeInOut)
+                zoomedBarsController.previewBarsChartRenderer.setup(horizontalRange: barsController.totalHorizontalRange, animated: animated)
+                DispatchQueue.main.asyncAfter(deadline: .now() + .defaultDuration) { [weak self] in
+                    self?.zoomedBarsController.mainBarsRenderer.setVisible(false, animated: false)
+                    self?.zoomedBarsController.previewBarsChartRenderer.setVisible(false, animated: false)
+                }
+            }
+            
+            barsController.willAppear(animated: animated)
+            zoomedBarsController.willDisappear(animated: animated)
+            
+            if !zoomedBarsController.chartsCollection.isBlank {
+                barsController.updateChartsVisibility(visibility: zoomedBarsController.chartVisibility, animated: false)
+            }
+        }
+        
+        self.setBackButtonVisibilityClosure?(isZoomed, animated)
+    }
+    
+    public override func updateChartsVisibility(visibility: [Bool], animated: Bool) {
+        if isZoomed {
+            zoomedBarsController.updateChartsVisibility(visibility: visibility, animated: animated)
+        } else {
+            barsController.updateChartsVisibility(visibility: visibility, animated: animated)
+        }
+    }
+    
+    var visibleChartValues: [ChartsCollection.Chart] {
+        let visibility = isZoomed ? zoomedBarsController.chartVisibility : barsController.chartVisibility
+        let collection = isZoomed ? zoomedBarsController.chartsCollection : barsController.chartsCollection
+        let visibleCharts: [ChartsCollection.Chart] = visibility.enumerated().compactMap { args in
+            args.element ? collection.chartValues[args.offset] : nil
+        }
+        return visibleCharts
+    }
+    
+    public override var actualChartVisibility: [Bool] {
+        return isZoomed ? zoomedBarsController.chartVisibility : barsController.chartVisibility
+    }
+    
+    public override var actualChartsCollection: ChartsCollection {
+        let collection = isZoomed ? zoomedBarsController.chartsCollection : barsController.chartsCollection
+        if collection.isBlank {
+            return self.initialChartsCollection
+        }
+        return collection
+    }
+
+    public override func chartInteractionDidBegin(point: CGPoint, manual: Bool = true) {
+        if isZoomed {
+            zoomedBarsController.chartInteractionDidBegin(point: point, manual: manual)
+        } else {
+            barsController.chartInteractionDidBegin(point: point, manual: manual)
+        }
+    }
+    
+    public override func chartInteractionDidEnd() {
+        if isZoomed {
+            zoomedBarsController.chartInteractionDidEnd()
+        } else {
+            barsController.chartInteractionDidEnd()
+        }
+    }
+    
+    public override var drawChartVisibity: Bool {
+        return true
+    }
+    
+    public override var currentChartHorizontalRangeFraction: ClosedRange<CGFloat> {
+        if isZoomed {
+            return zoomedBarsController.currentChartHorizontalRangeFraction
+        } else {
+            return barsController.currentChartHorizontalRangeFraction
+        }
+    }
+    
+    public override func cancelChartInteraction() {
+        self.barsController.lineBulletsRenderer.isEnabled = false
+        self.barsController.verticalLineRenderer.values = []
+        if isZoomed {
+            return zoomedBarsController.hideDetailsView(animated: true)
+        } else {
+            return barsController.hideDetailsView(animated: true)
+        }
+        
+    }
+    
+    public override func didTapZoomIn(date: Date, pointIndex: Int) {
+        guard !isZoomed, isZoomable else { return }
+        if isZoomed {
+            return zoomedBarsController.hideDetailsView(animated: true)
+        }
+        self.getDetailsData?(date, { updatedCollection in
+            if let updatedCollection = updatedCollection {
+                self.zoomedBarsController.initialize(chartsCollection: updatedCollection,
+                                                initialDate: date,
+                                                totalHorizontalRange: 0...1,
+                                                totalVerticalRange: 0...1)
+                self.switchToChart(chartsCollection: updatedCollection, isZoomed: true, animated: true)
+            }
+        })
+    }
+    
+   public override func didTapZoomOut() {
+        cancelChartInteraction()
+        switchToChart(chartsCollection: barsController.chartsCollection, isZoomed: false, animated: true)
+    }
+    
+    public override func updateChartRange(_ rangeFraction: ClosedRange<CGFloat>, animated: Bool = true) {
+        if isZoomed {
+            return zoomedBarsController.chartRangeFractionDidUpdated(rangeFraction)
+        } else {
+            return barsController.chartRangeFractionDidUpdated(rangeFraction)
+        }
+    }
+    
+    public override func apply(theme: ChartTheme, strings: ChartStrings, animated: Bool) {
+        super.apply(theme: theme, strings: strings, animated: animated)
+        
+        zoomedBarsController.apply(theme: theme, strings: strings, animated: animated)
+        barsController.apply(theme: theme, strings: strings, animated: animated)
+    }
+}

submodules/GraphCore/Sources/Charts/Controllers/Stacked Bars/TwoAxisStepBarsChartController.swift

@@ -0,0 +1,353 @@
+import Foundation
+#if os(macOS)
+import Cocoa
+#else
+import UIKit
+#endif
+
+private enum Constants {
+    static let verticalBaseAnchors: [CGFloat] = [8, 5, 4, 2.5, 2, 1]
+}
+
+public class TwoAxisStepBarsChartController: BaseLinesChartController {
+    class GraphController {
+        let mainBarsRenderer = BarChartRenderer(step: true)
+        let verticalScalesRenderer = VerticalScalesRenderer()
+        let lineBulletsRenderer = LineBulletsRenderer()
+        let previewBarsRenderer = BarChartRenderer(step: true, lineWidth: 1.0)
+        
+        var chartBars: BarChartRenderer.BarsData = .blank
+        var barsWidth: CGFloat = 1
+        
+        var totalVerticalRange: ClosedRange<CGFloat> = BaseConstants.defaultRange
+
+        init() {
+            self.lineBulletsRenderer.isEnabled = false
+            
+            self.mainBarsRenderer.optimizationLevel = BaseConstants.barsChartOptimizationLevel
+            self.previewBarsRenderer.optimizationLevel = BaseConstants.barsChartOptimizationLevel
+        }
+        
+        func updateMainChartVerticalRange(range: ClosedRange<CGFloat>, animated: Bool) {
+            mainBarsRenderer.setup(verticalRange: range, animated: animated)
+            verticalScalesRenderer.setup(verticalRange: range, animated: animated)
+            lineBulletsRenderer.setup(verticalRange: range, animated: animated)
+        }
+    }
+    
+    private var graphControllers: [GraphController] = []
+    private let verticalLineRenderer = VerticalLinesRenderer()
+    private let horizontalScalesRenderer = HorizontalScalesRenderer()
+
+    var totalHorizontalRange: ClosedRange<CGFloat> = BaseConstants.defaultRange
+
+    private let initialChartCollection: ChartsCollection
+    
+    private var prevoiusHorizontalStrideInterval: Int = 1
+    
+    public var hourly: Bool = false
+    public var min5: Bool = false
+    
+    override public init(chartsCollection: ChartsCollection)  {
+        self.initialChartCollection = chartsCollection
+        graphControllers = chartsCollection.chartValues.map { _ in GraphController() }
+
+        super.init(chartsCollection: chartsCollection)
+        self.zoomChartVisibility = chartVisibility
+    }
+    
+    override func setupChartCollection(chartsCollection: ChartsCollection, animated: Bool, isZoomed: Bool) {
+        super.setupChartCollection(chartsCollection: chartsCollection, animated: animated, isZoomed: isZoomed)
+        
+        for (index, controller) in self.graphControllers.enumerated() {
+            if index < chartsCollection.chartValues.count {
+                let chart = chartsCollection.chartValues[index]
+                let initialComponents = [BarChartRenderer.BarsData.Component(color: chart.color,
+                                                                            values: chart.values.map { CGFloat($0) })]
+                let (width, chartBars, totalHorizontalRange, totalVerticalRange) = BarChartRenderer.BarsData.initialComponents(chartsCollection: chartsCollection, separate: true, initialComponents: initialComponents)
+                controller.chartBars = chartBars
+                controller.verticalScalesRenderer.labelsColor = chart.color
+                controller.barsWidth = width
+                controller.totalVerticalRange = totalVerticalRange
+                self.totalHorizontalRange = totalHorizontalRange
+                
+                var bullets: [LineBulletsRenderer.Bullet] = []
+                if let component = chartBars.components.first {
+                    for i in 0 ..< chartBars.locations.count {
+                        let location = chartBars.locations[i]
+                        let value = component.values[i]
+                        bullets.append(LineBulletsRenderer.Bullet(coordinate: CGPoint(x: location, y: value), offset: .zero, color: component.color))
+                    }
+                }
+                
+                controller.lineBulletsRenderer.bullets = bullets
+                controller.previewBarsRenderer.setup(horizontalRange: self.totalHorizontalRange, animated: animated)
+                controller.previewBarsRenderer.setup(verticalRange: controller.totalVerticalRange, animated: animated)
+                controller.mainBarsRenderer.bars = chartBars
+                controller.previewBarsRenderer.bars = chartBars
+                
+                controller.verticalScalesRenderer.setHorizontalLinesVisible((index == 0), animated: animated)
+                controller.verticalScalesRenderer.isRightAligned = (index != 0)
+                controller.verticalScalesRenderer.isEnabled = true
+            } else {
+                let emptyBars = BarChartRenderer.BarsData(barWidth: 0.0, locations: [], components: [])
+                controller.chartBars = emptyBars
+                controller.barsWidth = emptyBars.barWidth
+                controller.mainBarsRenderer.bars = emptyBars
+                controller.previewBarsRenderer.bars = emptyBars
+            }
+        }
+        
+        self.prevoiusHorizontalStrideInterval = -1
+        
+        let chartRange: ClosedRange<CGFloat>
+        if isZoomed {
+            chartRange = zoomedChartRange
+        } else {
+            chartRange = initialChartRange
+        }
+        
+        updateHorizontalLimits(horizontalRange: chartRange, animated: animated)
+        updateMainChartHorizontalRange(range: chartRange, animated: animated)
+        updateVerticalLimitsAndRange(horizontalRange: chartRange, animated: animated)
+        
+        self.chartRangeUpdatedClosure?(currentChartHorizontalRangeFraction, animated)
+    }
+    
+   public override func initializeChart() {
+        if let first = initialChartCollection.axisValues.first?.timeIntervalSince1970,
+            let last = initialChartCollection.axisValues.last?.timeIntervalSince1970 {
+            initialChartRange = CGFloat(max(first, last - BaseConstants.defaultRangePresetLength))...CGFloat(last)
+        }
+        setupChartCollection(chartsCollection: initialChartCollection, animated: false, isZoomed: false)
+    }
+    
+    public override var mainChartRenderers: [ChartViewRenderer] {
+        return graphControllers.map { $0.mainBarsRenderer } +
+               graphControllers.flatMap { [$0.verticalScalesRenderer, $0.lineBulletsRenderer] } +
+            [horizontalScalesRenderer, verticalLineRenderer]
+    }
+    
+    public override var navigationRenderers: [ChartViewRenderer] {
+        return graphControllers.map { $0.previewBarsRenderer }
+    }
+    
+    public override func updateChartsVisibility(visibility: [Bool], animated: Bool) {
+        chartVisibility = visibility
+        zoomChartVisibility = visibility
+        let firstIndex = visibility.firstIndex(where: { $0 })
+        for (index, isVisible) in visibility.enumerated() {
+            let graph = graphControllers[index]
+            graph.mainBarsRenderer.setVisible(isVisible, animated: animated)
+            graph.previewBarsRenderer.setVisible(isVisible, animated: animated)
+            graph.lineBulletsRenderer.setLineVisible(isVisible, at: 0, animated: animated)
+            graph.verticalScalesRenderer.setVisible(isVisible, animated: animated)
+            if let firstIndex = firstIndex {
+                graph.verticalScalesRenderer.setHorizontalLinesVisible(index == firstIndex, animated: animated)
+            }
+        }
+        
+        updateVerticalLimitsAndRange(horizontalRange: currentHorizontalRange, animated: true)
+        
+        if isChartInteractionBegun {
+            chartInteractionDidBegin(point: lastChartInteractionPoint, manual: false)
+        }
+    }
+    
+    public override func chartInteractionDidBegin(point: CGPoint, manual: Bool = true) {
+        if manual && !isChartInteracting && !self.verticalLineRenderer.values.isEmpty {
+            self.cancelChartInteraction()
+            ignoreInteraction = true
+            return
+        }
+        
+        let horizontalRange = currentHorizontalRange
+        let chartFrame = self.chartFrame()
+        guard chartFrame.width > 0 else { return }
+        
+        let barsWidth = graphControllers.first?.barsWidth ?? 0.0
+        
+        let dateToFind = Date(timeIntervalSince1970: TimeInterval(horizontalRange.distance * point.x + horizontalRange.lowerBound + barsWidth / 2.0))
+        guard let (closestDate, minIndex) = findClosestDateTo(dateToFind: dateToFind) else { return }
+        
+        let chartInteractionWasBegin = isChartInteractionBegun
+        super.chartInteractionDidBegin(point: point)
+        
+        var barOffset: CGFloat = 0.0
+        for (index, graphController) in graphControllers.enumerated() {
+            var bullets: [LineBulletsRenderer.Bullet] = []
+            if let component = graphController.chartBars.components.first {
+                let location = graphController.chartBars.locations[minIndex]
+                let value = component.values[minIndex]
+                
+                let offset = -(graphController.mainBarsRenderer.transform(toChartCoordinateHorizontal: horizontalRange.lowerBound + graphController.barsWidth, chartFrame: chartFrame) - chartFrame.minX) / 2.0
+                barOffset = offset
+                
+                bullets.append(LineBulletsRenderer.Bullet(coordinate: CGPoint(x: location, y: value), offset: CGPoint(x: offset, y: 0.0), color: component.color))
+            }
+            let isVisible = chartVisibility[index]
+            graphController.lineBulletsRenderer.bullets = bullets
+            graphController.lineBulletsRenderer.isEnabled = true
+            graphController.lineBulletsRenderer.setLineVisible(isVisible, at: 0, animated: false)
+        }
+        
+        let chartValue: CGFloat = CGFloat(closestDate.timeIntervalSince1970)
+        var chartValueUpdated = true
+        if self.verticalLineRenderer.values == [chartValue] {
+            chartValueUpdated = false
+        }
+        let detailsViewPosition = (chartValue - horizontalRange.lowerBound) / horizontalRange.distance * chartFrame.width + chartFrame.minX + barOffset
+        self.setDetailsViewModel?(chartDetailsViewModel(closestDate: closestDate, pointIndex: minIndex, loading: false), chartInteractionWasBegin, chartInteractionWasBegin && chartValueUpdated)
+        self.setDetailsChartVisibleClosure?(true, true)
+        self.setDetailsViewPositionClosure?(detailsViewPosition)
+        self.verticalLineRenderer.values = [chartValue]
+        self.verticalLineRenderer.offset = barOffset
+    }
+    
+    public override var currentChartHorizontalRangeFraction: ClosedRange<CGFloat> {
+        let lowerPercent = (currentHorizontalRange.lowerBound - totalHorizontalRange.lowerBound) / totalHorizontalRange.distance
+        let upperPercent = (currentHorizontalRange.upperBound - totalHorizontalRange.lowerBound) / totalHorizontalRange.distance
+        return lowerPercent...upperPercent
+    }
+    
+    public override var currentHorizontalRange: ClosedRange<CGFloat> {
+        return graphControllers.first?.mainBarsRenderer.horizontalRange.end ?? BaseConstants.defaultRange
+    }
+
+    public override func cancelChartInteraction() {
+        super.cancelChartInteraction()
+        for graphController in graphControllers {
+            graphController.lineBulletsRenderer.isEnabled = false
+        }
+        
+        self.setDetailsChartVisibleClosure?(false, true)
+        self.verticalLineRenderer.values = []
+    }
+    
+    public override func didTapZoomOut() {
+        cancelChartInteraction()
+        self.setupChartCollection(chartsCollection: initialChartCollection, animated: true, isZoomed: false)
+    }
+    
+    public override func updateChartRange(_ rangeFraction: ClosedRange<CGFloat>, animated: Bool = true) {
+        cancelChartInteraction()
+        
+        let horizontalRange = ClosedRange(uncheckedBounds:
+            (lower: totalHorizontalRange.lowerBound + rangeFraction.lowerBound * totalHorizontalRange.distance,
+             upper: totalHorizontalRange.lowerBound + rangeFraction.upperBound * totalHorizontalRange.distance))
+        
+        zoomedChartRange = horizontalRange
+        updateChartRangeTitle(animated: true)
+        
+        updateMainChartHorizontalRange(range: horizontalRange, animated: false)
+        updateHorizontalLimits(horizontalRange: horizontalRange, animated: true)
+        updateVerticalLimitsAndRange(horizontalRange: horizontalRange, animated: true)
+    }
+    
+    func updateMainChartHorizontalRange(range: ClosedRange<CGFloat>, animated: Bool) {
+        for controller in graphControllers {
+            controller.mainBarsRenderer.setup(horizontalRange: range, animated: animated)
+            controller.verticalScalesRenderer.setup(horizontalRange: range, animated: animated)
+            controller.lineBulletsRenderer.setup(horizontalRange: range, animated: animated)
+        }
+        horizontalScalesRenderer.setup(horizontalRange: range, animated: animated)
+        verticalLineRenderer.setup(horizontalRange: range, animated: animated)
+    }
+    
+    func updateHorizontalLimits(horizontalRange: ClosedRange<CGFloat>, animated: Bool) {
+        var scaleType: ChartScaleType = .day
+        if isZoomed {
+            scaleType = .minutes5
+        } else {
+            if self.hourly {
+                scaleType = .hour
+            } else if self.min5 {
+                scaleType = .minutes5
+            }
+        }
+        
+        if let (stride, labels) = horizontalLimitsLabels(horizontalRange: horizontalRange,
+                                                         scaleType: scaleType,
+                                                         prevoiusHorizontalStrideInterval: prevoiusHorizontalStrideInterval) {
+            self.horizontalScalesRenderer.setup(labels: labels, animated: animated)
+            self.prevoiusHorizontalStrideInterval = stride
+        }
+    }
+    
+    func updateVerticalLimitsAndRange(horizontalRange: ClosedRange<CGFloat>, animated: Bool) {
+        let chartHeight = chartFrame().height
+        let approximateNumberOfChartValues = (chartHeight / BaseConstants.minimumAxisYLabelsDistance)
+
+        let dividorsAndMultiplers: [(startValue: CGFloat, base: CGFloat, count: Int, maximumNumberOfDecimals: Int)] = graphControllers.enumerated().map { arg in
+            let (index, controller) = arg
+            let verticalRange = BarChartRenderer.BarsData.verticalRange(bars: controller.chartBars, separate: true, calculatingRange: horizontalRange, addBounds: true) ?? controller.totalVerticalRange
+
+            var numberOfOffsetsPerItem = verticalRange.distance / approximateNumberOfChartValues
+            
+            var multiplier: CGFloat = 1.0
+            if numberOfOffsetsPerItem > 0 {
+                while numberOfOffsetsPerItem > 10 {
+                    numberOfOffsetsPerItem /= 10
+                    multiplier *= 10
+                }
+            }
+            var dividor: CGFloat = 1.0
+            var maximumNumberOfDecimals = 2
+            if numberOfOffsetsPerItem > 0 {
+                while numberOfOffsetsPerItem < 1 {
+                    numberOfOffsetsPerItem *= 10
+                    dividor *= 10
+                    maximumNumberOfDecimals += 1
+                }
+            }
+            
+            let generalBase = Constants.verticalBaseAnchors.first { numberOfOffsetsPerItem > $0 } ?? BaseConstants.defaultVerticalBaseAnchor
+            let base = generalBase * multiplier / dividor
+            
+            var verticalValue = (verticalRange.lowerBound / base).rounded(.down) * base
+            let startValue = verticalValue
+            var count = 0
+            if chartVisibility[index] {
+                while verticalValue < verticalRange.upperBound {
+                    count += 1
+                    verticalValue += base
+                }
+            }
+            return (startValue: startValue, base: base, count: count, maximumNumberOfDecimals: maximumNumberOfDecimals)
+        }
+        
+        let totalCount = dividorsAndMultiplers.map { $0.count }.max() ?? 0
+        guard totalCount > 0 else { return }
+        
+        let numberFormatter = BaseConstants.chartNumberFormatter
+        for (index, controller) in graphControllers.enumerated() {
+            let (startValue, base, _, maximumNumberOfDecimals) = dividorsAndMultiplers[index]
+            
+            let updatedRange = startValue...(startValue + base * CGFloat(totalCount))
+            if controller.verticalScalesRenderer.verticalRange.end != updatedRange {
+                numberFormatter.maximumFractionDigits = maximumNumberOfDecimals
+
+                var verticalLabels: [LinesChartLabel] = []
+                for multipler in 0...(totalCount - 1) {
+                    let verticalValue = startValue + base * CGFloat(multipler)
+                    let text: String = numberFormatter.string(from: NSNumber(value: Double(verticalValue))) ?? ""
+                    verticalLabels.append(LinesChartLabel(value: verticalValue, text: text))
+                }
+                
+                controller.verticalScalesRenderer.setup(verticalLimitsLabels: verticalLabels, animated: animated)
+                controller.updateMainChartVerticalRange(range: updatedRange, animated: animated)
+            }
+        }
+    }
+    
+    public override func apply(theme: ChartTheme, strings: ChartStrings, animated: Bool) {
+        horizontalScalesRenderer.labelsColor = theme.chartLabelsColor
+        verticalLineRenderer.linesColor = theme.chartStrongLinesColor
+
+        for controller in graphControllers {
+            controller.verticalScalesRenderer.horizontalLinesColor = theme.chartHelperLinesColor
+            controller.lineBulletsRenderer.setInnerColor(theme.chartBackgroundColor, animated: animated)
+            controller.verticalScalesRenderer.axisXColor = theme.chartStrongLinesColor
+        }
+    }
+}