The PaletteProvider API allows you to individually style points, line segments, columns and candles based on data-values.

For example, if you wished to have a candlestick a different colour based on high volume condition, you can do this using the PaletteProvider API. Or, if you wanted to have scatter points or line segments turn red if they exceed a threshold, you can also do this with this powerful and flexible API.

Palette Providers can be enabled by creating a class which implements SCIPaletteProviderProtocol and attaching to the SCIRenderableSeries.PaletteProvider property.

Implement the SCIPaletteProviderProtocol.styleForXy function and return a valid style for points you want to override. Returning nil uses the default (built in) series style.

// UsePaletteProviderView.m

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2018. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// UsePaletteProviderView.m is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

#import "UsePaletteProviderView.h"
#import "DataManager.h"
#import <SciChart/SciChart.h>
#import "CustomPalette.h"

@implementation UsePaletteProviderView

- (void)initExample {
    id<SCIAxis2DProtocol> xAxis = [SCINumericAxis new];
    xAxis.visibleRange = [[SCIDoubleRange alloc] initWithMin:SCIGeneric(150.0) Max:SCIGeneric(165.0)];
    id<SCIAxis2DProtocol> yAxis = [SCINumericAxis new];
    
    PriceSeries * priceData = [DataManager getPriceDataIndu];
    double offset = -1000;
    double offsetOpenData[priceData.size];
    double offsetHighData[priceData.size];
    double offsetLowData[priceData.size];
    double offsetCloseData[priceData.size];

    SCIXyDataSeries * mountainDataSeries = [[SCIXyDataSeries alloc] initWithXType:SCIDataType_Double YType:SCIDataType_Double];
    SCIXyDataSeries * lineDataSeries = [[SCIXyDataSeries alloc] initWithXType:SCIDataType_Double YType:SCIDataType_Double];
    SCIXyDataSeries * columnDataSeries = [[SCIXyDataSeries alloc] initWithXType:SCIDataType_Double YType:SCIDataType_Double];
    SCIOhlcDataSeries * ohlcDataSeries = [[SCIOhlcDataSeries alloc] initWithXType:SCIDataType_Double YType:SCIDataType_Double];
    SCIOhlcDataSeries * candlestickDataSeries = [[SCIOhlcDataSeries alloc] initWithXType:SCIDataType_Double YType:SCIDataType_Double];
    SCIXyDataSeries * scatterDataSeries = [[SCIXyDataSeries alloc] initWithXType:SCIDataType_Double YType:SCIDataType_Double];
    
    [mountainDataSeries appendRangeX:SCIGeneric(priceData.indexesAsDouble) Y:SCIGeneric(priceData.lowData) Count:priceData.size];
    [lineDataSeries appendRangeX:SCIGeneric(priceData.indexesAsDouble) Y:SCIGeneric([DataManager offsetArray:priceData.closeData destArray:offsetCloseData count:priceData.size offset:-offset]) Count:priceData.size];
    [columnDataSeries appendRangeX:SCIGeneric(priceData.indexesAsDouble) Y:SCIGeneric([DataManager offsetArray:priceData.closeData destArray:offsetCloseData count:priceData.size offset:offset * 3]) Count:priceData.size];
    [ohlcDataSeries appendRangeX:SCIGeneric(priceData.indexesAsDouble)
                            Open:SCIGeneric(priceData.openData)
                            High:SCIGeneric(priceData.highData)
                             Low:SCIGeneric(priceData.lowData)
                           Close:SCIGeneric(priceData.closeData)
                           Count:priceData.size];
    [candlestickDataSeries appendRangeX:SCIGeneric(priceData.indexesAsDouble)
                                   Open:SCIGeneric([DataManager offsetArray:priceData.openData destArray:offsetOpenData count:priceData.size offset:offset])
                                   High:SCIGeneric([DataManager offsetArray:priceData.highData destArray:offsetHighData count:priceData.size offset:offset])
                                    Low:SCIGeneric([DataManager offsetArray:priceData.lowData destArray:offsetLowData count:priceData.size offset:offset])
                                  Close:SCIGeneric([DataManager offsetArray:priceData.closeData destArray:offsetCloseData count:priceData.size offset:offset])
                                  Count:priceData.size];
    [scatterDataSeries appendRangeX:SCIGeneric(priceData.indexesAsDouble) Y:SCIGeneric([DataManager offsetArray:priceData.closeData destArray:offsetCloseData count:priceData.size offset:offset * 2.5]) Count:priceData.size];

    SCIFastMountainRenderableSeries * mountainSeries = [SCIFastMountainRenderableSeries new];
    mountainSeries.dataSeries = mountainDataSeries;
    mountainSeries.areaStyle = [[SCISolidBrushStyle alloc] initWithColorCode:0x9787CEEB];
    mountainSeries.strokeStyle  = [[SCISolidPenStyle alloc] initWithColorCode:0xFFFF00FF withThickness:1.0];
    mountainSeries.zeroLineY = 6000;
    mountainSeries.paletteProvider = [CustomPalette new];

    SCIEllipsePointMarker * ellipsePointMarker = [SCIEllipsePointMarker new];
    ellipsePointMarker.fillStyle = [[SCISolidBrushStyle alloc] initWithColor:UIColor.redColor];
    ellipsePointMarker.strokeStyle = [[SCISolidPenStyle alloc] initWithColor:UIColor.orangeColor withThickness:2.0];
    ellipsePointMarker.height = 10;
    ellipsePointMarker.width = 10;

    SCIFastLineRenderableSeries * lineSeries = [SCIFastLineRenderableSeries new];
    lineSeries.dataSeries = lineDataSeries;
    lineSeries.strokeStyle = [[SCISolidPenStyle alloc] initWithColorCode:0xFF0000FF withThickness:1.0];
    lineSeries.pointMarker = ellipsePointMarker;
    lineSeries.paletteProvider = [CustomPalette new];

    SCIFastOhlcRenderableSeries * ohlcSeries = [SCIFastOhlcRenderableSeries new];
    ohlcSeries.dataSeries = ohlcDataSeries;
    ohlcSeries.paletteProvider = [CustomPalette new];

    SCIFastCandlestickRenderableSeries * candlestickSeries = [SCIFastCandlestickRenderableSeries new];
    candlestickSeries.dataSeries = candlestickDataSeries;
    candlestickSeries.paletteProvider = [CustomPalette new];

    SCIFastColumnRenderableSeries * columnSeries = [SCIFastColumnRenderableSeries new];
    columnSeries.dataSeries = columnDataSeries;
    columnSeries.strokeStyle = nil;
    columnSeries.zeroLineY = 6000;
    columnSeries.dataPointWidth = 0.8;
    columnSeries.fillBrushStyle = [[SCISolidBrushStyle alloc] initWithColor:UIColor.blueColor];
    columnSeries.paletteProvider = [CustomPalette new];

    SCISquarePointMarker * squarePointMarker = [SCISquarePointMarker new];
    squarePointMarker.fillStyle = [[SCISolidBrushStyle alloc] initWithColor:UIColor.redColor];
    squarePointMarker.strokeStyle = [[SCISolidPenStyle alloc] initWithColor:UIColor.orangeColor withThickness:2.0];
    squarePointMarker.height = 7;
    squarePointMarker.width = 7;

    SCIXyScatterRenderableSeries * scatterSeries = [SCIXyScatterRenderableSeries new];
    scatterSeries.dataSeries = scatterDataSeries;
    scatterSeries.pointMarker = squarePointMarker;
    scatterSeries.paletteProvider = [CustomPalette new];

    [self addAnimationToSeries:mountainSeries];
    [self addAnimationToSeries:lineSeries];
    [self addAnimationToSeries:ohlcSeries];
    [self addAnimationToSeries:candlestickSeries];
    [self addAnimationToSeries:columnSeries];
    [self addAnimationToSeries:scatterSeries];

    SCIXAxisDragModifier * xDragModifier = [SCIXAxisDragModifier new];
    xDragModifier.clipModeX = SCIClipMode_None;
    
    SCIYAxisDragModifier * yDragModifier = [SCIYAxisDragModifier new];
    yDragModifier.dragMode = SCIAxisDragMode_Pan;
    
    SCIBoxAnnotation * boxAnnotation = [SCIBoxAnnotation new];
    boxAnnotation.coordinateMode = SCIAnnotationCoordinate_RelativeY;
    boxAnnotation.x1 = SCIGeneric(152);
    boxAnnotation.y1 = SCIGeneric(1.0);
    boxAnnotation.x2 = SCIGeneric(158);
    boxAnnotation.y2 = SCIGeneric(0.0);
    boxAnnotation.style.fillBrush = [[SCILinearGradientBrushStyle alloc] initWithColorCodeStart:0x550000FF finish:0x55FFFF00 direction:(SCILinearGradientDirection_Vertical)];
    boxAnnotation.style.borderPen = [[SCISolidPenStyle alloc] initWithColorCode:0xFF279B27 withThickness:1.0];
    
    [SCIUpdateSuspender usingWithSuspendable:self.surface withBlock:^{
        [self.surface.xAxes add:xAxis];
        [self.surface.yAxes add:yAxis];
        [self.surface.renderableSeries add:mountainSeries];
        [self.surface.renderableSeries add:lineSeries];
        [self.surface.renderableSeries add:ohlcSeries];
        [self.surface.renderableSeries add:candlestickSeries];
        [self.surface.renderableSeries add:columnSeries];
        [self.surface.renderableSeries add:scatterSeries];
        self.surface.chartModifiers = [[SCIChartModifierCollection alloc] initWithChildModifiers:@[xDragModifier, yDragModifier, [SCIPinchZoomModifier new], [SCIZoomExtentsModifier new], [SCITooltipModifier new]]];
        [self.surface.annotations add:boxAnnotation];
    }];
}

- (void)addAnimationToSeries:(id<SCIRenderableSeriesProtocol>)series {
    SCIScaleRenderableSeriesAnimation * animation = [[SCIScaleRenderableSeriesAnimation alloc] initWithDuration:3 curveAnimation:SCIAnimationCurve_EaseOutElastic];
    [animation startAfterDelay:0.3];
    [series addAnimation:animation];
}

@end

// CustomPalette.m

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2018. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// CustomPalette.m is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

#import "CustomPalette.h"

@implementation CustomPalette {
    SCILineSeriesStyle * _lineSeriesStyle;
    SCIColumnSeriesStyle * _columnSeriesStyle;
    SCIOhlcSeriesStyle * _ohlcSeriesStyle;
    SCICandlestickSeriesStyle * _candleStickSeriesStyle;
    SCIMountainSeriesStyle * _mountainSeriesStyle;
    SCIScatterSeriesStyle * _scatterSeriesStyle;
    
    int _startIndex;
    int _endIndex;
    
    RenderableSeriesType _seriesType;
}

- (instancetype)init {
    self = [super init];
    if (self) {
        _startIndex = 152;
        _endIndex = 158;
        
        SCIEllipsePointMarker * ellipsePointMarker = [SCIEllipsePointMarker new];
        ellipsePointMarker.width = 7;
        ellipsePointMarker.height = 7;
        ellipsePointMarker.fillStyle = [[SCISolidBrushStyle alloc] initWithColor:UIColor.redColor];
        ellipsePointMarker.strokeStyle = [[SCISolidPenStyle alloc] initWithColor:UIColor.redColor withThickness:1.0];
        
        _lineSeriesStyle = [SCILineSeriesStyle new];
        _lineSeriesStyle.pointMarker = ellipsePointMarker;
        _lineSeriesStyle.strokeStyle = [[SCISolidPenStyle alloc] initWithColor:[UIColor redColor] withThickness:1.0];
        
        _mountainSeriesStyle = [SCIMountainSeriesStyle new];
        _mountainSeriesStyle.areaStyle = [[SCISolidBrushStyle alloc]initWithColor:UIColor.redColor];
        _mountainSeriesStyle.strokeStyle = [[SCISolidPenStyle alloc] initWithColor:UIColor.redColor withThickness:1.0];
        
        SCISquarePointMarker * squarePointMarker = [SCISquarePointMarker new];
        squarePointMarker.width = 7;
        squarePointMarker.height = 7;
        squarePointMarker.fillStyle = [[SCISolidBrushStyle alloc]initWithColor:UIColor.greenColor];
        
        _scatterSeriesStyle = [SCIScatterSeriesStyle new];
        _scatterSeriesStyle.pointMarker = squarePointMarker;
        
        _ohlcSeriesStyle = [SCIOhlcSeriesStyle new];
        _ohlcSeriesStyle.strokeUpStyle = [[SCISolidPenStyle alloc] initWithColorCode:0xFF6495ED withThickness:1.0];
        _ohlcSeriesStyle.strokeDownStyle = [[SCISolidPenStyle alloc] initWithColorCode:0xFF6495ED withThickness:1.0];
        
        _candleStickSeriesStyle = [SCICandlestickSeriesStyle new];
        _candleStickSeriesStyle.fillUpBrushStyle = [[SCISolidBrushStyle alloc] initWithColor:UIColor.greenColor];
        _candleStickSeriesStyle.fillDownBrushStyle = [[SCISolidBrushStyle alloc] initWithColor:UIColor.greenColor];
        
        _columnSeriesStyle = [SCIColumnSeriesStyle new];
        _columnSeriesStyle.strokeStyle = nil;
        _columnSeriesStyle.fillBrushStyle = [[SCISolidBrushStyle alloc] initWithColor:UIColor.purpleColor];
    }
    return self;
}

- (void)updateData:(id<SCIRenderPassDataProtocol>)data {
    if ([data.renderableSeries isKindOfClass:[SCIFastLineRenderableSeries class]]) _seriesType = line;
    if ([data.renderableSeries isKindOfClass:[SCIFastOhlcRenderableSeries class]]) _seriesType = ohlc;
    if ([data.renderableSeries isKindOfClass:[SCIXyScatterRenderableSeries class]]) _seriesType = scatter;
    if ([data.renderableSeries isKindOfClass:[SCIFastMountainRenderableSeries class]]) _seriesType = mountain;
    if ([data.renderableSeries isKindOfClass:[SCIFastColumnRenderableSeries class]]) _seriesType = column;
    if ([data.renderableSeries isKindOfClass:[SCIFastCandlestickRenderableSeries class]]) _seriesType = candles;
}

- (id<SCIStyleProtocol>)styleForX:(double)x Y:(double)y Index:(int)index {
    BOOL isInRange = index >= _startIndex && index <=_endIndex;
    
    if (isInRange){
        switch (_seriesType) {
            case line:
                return _lineSeriesStyle;
                break;
            case column:
                return _columnSeriesStyle;
                break;
            case ohlc:
                return _ohlcSeriesStyle;
                break;
            case candles:
                return _candleStickSeriesStyle;
                break;
            case mountain:
                return _mountainSeriesStyle;
                break;
            case scatter:
                return _scatterSeriesStyle;
                break;
        }
    }
    return nil;
}

@end

// UsePaletteProviderView.swift

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2018. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// UsePaletteProviderView.swift is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

class UsePaletteProviderView: SingleChartLayout {
    
    override func initExample() {
        let xAxis = SCINumericAxis()
        xAxis.visibleRange = SCIDoubleRange(min: SCIGeneric(150.0), max: SCIGeneric(165.0))
        let yAxis = SCINumericAxis()
        
        let priceData = DataManager.getPriceDataIndu()
        let size = priceData!.size()
        let offset = -1000.0
        
        let mountainDataSeries = SCIXyDataSeries(xType: .double, yType: .double)
        let lineDataSeries = SCIXyDataSeries(xType: .double, yType: .double)
        let columnDataSeries = SCIXyDataSeries(xType: .double, yType: .double)
        let ohlcDataSeries = SCIOhlcDataSeries(xType: .double, yType: .double)
        let candlestickDataSeries = SCIOhlcDataSeries(xType: .double, yType: .double)
        let scatterDataSeries = SCIXyDataSeries(xType: .double, yType: .double)
        
        mountainDataSeries.appendRangeX(DataManager.getGenericDataArray(priceData!.indexesAsDouble()), y: DataManager.getGenericDataArray(priceData!.lowData()), count: size)
        lineDataSeries.appendRangeX(DataManager.getGenericDataArray(priceData!.indexesAsDouble()), y: DataManager.getGenericDataArrayWithOffset(priceData!.closeData(), size: size, offset: -offset), count: size)
        columnDataSeries.appendRangeX(DataManager.getGenericDataArray(priceData!.indexesAsDouble()), y: DataManager.getGenericDataArrayWithOffset(priceData!.closeData(), size: size, offset: offset * 3), count: size)
        ohlcDataSeries.appendRangeX(DataManager.getGenericDataArray(priceData!.indexesAsDouble()),
                                    open: DataManager.getGenericDataArray(priceData!.openData()),
                                    high: DataManager.getGenericDataArray(priceData!.highData()),
                                    low: DataManager.getGenericDataArray(priceData!.lowData()),
                                    close: DataManager.getGenericDataArray(priceData!.closeData()),
                                    count: size)
        candlestickDataSeries.appendRangeX(DataManager.getGenericDataArray(priceData!.indexesAsDouble()),
                                           open: DataManager.getGenericDataArrayWithOffset(priceData!.openData(), size: size, offset: offset),
                                           high: DataManager.getGenericDataArrayWithOffset(priceData!.highData(), size: size, offset: offset),
                                           low: DataManager.getGenericDataArrayWithOffset(priceData!.lowData(), size: size, offset: offset),
                                           close: DataManager.getGenericDataArrayWithOffset(priceData!.closeData(), size: size, offset: offset),
                                           count: size)
        scatterDataSeries.appendRangeX(DataManager.getGenericDataArray(priceData!.indexesAsDouble()), y: DataManager.getGenericDataArrayWithOffset(priceData!.closeData(), size: size, offset: offset * 2.5), count: size)

        let mountainSeries = SCIFastMountainRenderableSeries()
        mountainSeries.dataSeries = mountainDataSeries
        mountainSeries.areaStyle = SCISolidBrushStyle(colorCode: 0x9787CEEB)
        mountainSeries.strokeStyle = SCISolidPenStyle(colorCode: 0xFFFF00FF, withThickness: 1.0)
        mountainSeries.zeroLineY = 6000
        mountainSeries.paletteProvider = CustomPaletteProvider()
        
        let ellipsePointMarker = SCIEllipsePointMarker()
        ellipsePointMarker.fillStyle = SCISolidBrushStyle(color: UIColor.red)
        ellipsePointMarker.strokeStyle = SCISolidPenStyle(color: UIColor.orange, withThickness: 2.0)
        ellipsePointMarker.height = 10
        ellipsePointMarker.width = 10
        
        let lineSeries = SCIFastLineRenderableSeries()
        lineSeries.dataSeries = lineDataSeries
        lineSeries.strokeStyle = SCISolidPenStyle(colorCode: 0xFF0000FF, withThickness: 1.0)
        lineSeries.pointMarker = ellipsePointMarker
        lineSeries.paletteProvider = CustomPaletteProvider()
        
        let ohlcSeries = SCIFastOhlcRenderableSeries()
        ohlcSeries.dataSeries = ohlcDataSeries
        ohlcSeries.paletteProvider = CustomPaletteProvider()
        
        let candlestickSeries = SCIFastCandlestickRenderableSeries()
        candlestickSeries.dataSeries = candlestickDataSeries
        candlestickSeries.paletteProvider = CustomPaletteProvider()
        
        let columnSeries = SCIFastColumnRenderableSeries()
        columnSeries.dataSeries = columnDataSeries
        columnSeries.strokeStyle = nil
        columnSeries.zeroLineY = 6000
        columnSeries.style.dataPointWidth = 0.8
        columnSeries.fillBrushStyle = SCISolidBrushStyle(color: UIColor.blue)
        columnSeries.paletteProvider = CustomPaletteProvider()
        
        let squarePointMarker = SCISquarePointMarker()
        squarePointMarker.fillStyle = SCISolidBrushStyle(color: UIColor.red)
        squarePointMarker.strokeStyle = SCISolidPenStyle(color: UIColor.orange, withThickness: 2.0)
        squarePointMarker.height = 7
        squarePointMarker.width = 7
        
        let scatterSeries = SCIXyScatterRenderableSeries()
        scatterSeries.dataSeries = scatterDataSeries
        scatterSeries.pointMarker = squarePointMarker
        scatterSeries.paletteProvider = CustomPaletteProvider()
        
        let xDragModifier = SCIXAxisDragModifier()
        xDragModifier.clipModeX = .none
        
        let yDragModifier = SCIYAxisDragModifier()
        yDragModifier.dragMode = .pan
        
        let boxAnnotation = SCIBoxAnnotation()
        boxAnnotation.coordinateMode = .relativeY
        boxAnnotation.x1 = SCIGeneric(152)
        boxAnnotation.y1 = SCIGeneric(1.0)
        boxAnnotation.x2 = SCIGeneric(158)
        boxAnnotation.y2 = SCIGeneric(0.0)
        boxAnnotation.style.fillBrush = SCILinearGradientBrushStyle(colorCodeStart: 0x550000FF, finish: 0x55FFFF00, direction: .vertical)
        
        SCIUpdateSuspender.usingWithSuspendable(surface) {
            self.surface.xAxes.add(xAxis)
            self.surface.yAxes.add(yAxis)
            self.surface.renderableSeries.add(mountainSeries)
            self.surface.renderableSeries.add(lineSeries)
            self.surface.renderableSeries.add(ohlcSeries)
            self.surface.renderableSeries.add(candlestickSeries)
            self.surface.renderableSeries.add(columnSeries)
            self.surface.renderableSeries.add(scatterSeries)
            self.surface.chartModifiers = SCIChartModifierCollection(childModifiers: [xDragModifier, yDragModifier, SCIPinchZoomModifier(), SCIZoomExtentsModifier(), SCITooltipModifier()])
            self.surface.annotations.add(boxAnnotation)
            
            mountainSeries.addAnimation(SCIScaleRenderableSeriesAnimation(duration: 3, curveAnimation: .easeOutElastic))
            lineSeries.addAnimation(SCIScaleRenderableSeriesAnimation(duration: 3, curveAnimation: .easeOutElastic))
            ohlcSeries.addAnimation(SCIScaleRenderableSeriesAnimation(duration: 3, curveAnimation: .easeOutElastic))
            candlestickSeries.addAnimation(SCIScaleRenderableSeriesAnimation(duration: 3, curveAnimation: .easeOutElastic))
            columnSeries.addAnimation(SCIScaleRenderableSeriesAnimation(duration: 3, curveAnimation: .easeOutElastic))
            scatterSeries.addAnimation(SCIScaleRenderableSeriesAnimation(duration: 3, curveAnimation: .easeOutElastic))
        }
    }
}

// CustomPaletteProvider.swift

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2018. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// CustomPaletteProvider.swift is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

import Foundation
import SciChart

enum RenderableSeriesType {
    case line
    case column
    case ohlc
    case mountain
    case candles
    case scatter
    case none
}

class CustomPaletteProvider: SCIPaletteProvider {
    
    private let lineSeriesStyle = SCILineSeriesStyle()
    private let columnSeriesStyle = SCIColumnSeriesStyle()
    private let ohlcSeriesStyle = SCIOhlcSeriesStyle()
    private let candleStickSeriesStyle = SCICandlestickSeriesStyle()
    private let mountainSeriesStyle = SCIMountainSeriesStyle()
    private let scatterSeriesStyle = SCIScatterSeriesStyle()
    
    private let startIndex: Int32 = 152
    private let endIndex: Int32 = 158
    
    private var seriesType: RenderableSeriesType = .none
    
    override init() {
        super.init()
        
        let ellipsePointMarker = SCIEllipsePointMarker()
        ellipsePointMarker.width = 7
        ellipsePointMarker.height = 7
        ellipsePointMarker.fillStyle = SCISolidBrushStyle.init(color: UIColor.red)
        ellipsePointMarker.strokeStyle = SCISolidPenStyle.init(color: UIColor.red, withThickness: 1.0)
        
        lineSeriesStyle.pointMarker = ellipsePointMarker
        lineSeriesStyle.strokeStyle = SCISolidPenStyle.init(color: UIColor.red, withThickness: 1.0)
        
        mountainSeriesStyle.areaStyle = SCISolidBrushStyle.init(color: UIColor.red)
        mountainSeriesStyle.strokeStyle = SCISolidPenStyle.init(color: UIColor.red, withThickness: 1.0)
        
        let squarePointMarker = SCISquarePointMarker()
        squarePointMarker.width = 7
        squarePointMarker.height = 7
        squarePointMarker.fillStyle = SCISolidBrushStyle.init(color:UIColor.green)
        scatterSeriesStyle.pointMarker = squarePointMarker
        
        ohlcSeriesStyle.strokeUpStyle = SCISolidPenStyle.init(colorCode:0xFF6495ED, withThickness:1.0)
        ohlcSeriesStyle.strokeDownStyle = SCISolidPenStyle.init(colorCode:0xFF6495ED, withThickness:1.0)
        
        candleStickSeriesStyle.fillUpBrushStyle = SCISolidBrushStyle.init(color:UIColor.green)
        candleStickSeriesStyle.fillDownBrushStyle = SCISolidBrushStyle.init(color:UIColor.green)
        
        columnSeriesStyle.fillBrushStyle = SCISolidBrushStyle.init(color:UIColor.purple)
    }
    
    override func updateData(_ data: SCIRenderPassDataProtocol!) {
        if data.renderableSeries() is SCIFastLineRenderableSeries{
            seriesType = .line
        }
        if data.renderableSeries() is SCIFastColumnRenderableSeries{
            seriesType = .column
        }
        if data.renderableSeries() is SCIXyScatterRenderableSeries{
            seriesType = .scatter
        }
        if data.renderableSeries() is SCIFastCandlestickRenderableSeries{
            seriesType = .candles
        }
        if data.renderableSeries() is SCIFastMountainRenderableSeries{
            seriesType = .mountain
        }
        if data.renderableSeries() is SCIFastOhlcRenderableSeries{
            seriesType = .ohlc
        }
    }
    
    override func styleFor(x: Double, y: Double, index: Int32) -> SCIStyleProtocol! {
        let isInRange: Bool = (index >= startIndex) && (index <= endIndex)
        
        if (isInRange){
            switch seriesType {
            case .line:
                return lineSeriesStyle;
            case .column:
                return columnSeriesStyle;
            case .ohlc:
                return ohlcSeriesStyle;
            case .candles:
                return candleStickSeriesStyle;
            case .mountain:
                return mountainSeriesStyle;
            case .scatter:
                return scatterSeriesStyle;
            case .none:
                return nil
            }
        }
        return nil;
    }
}

< BACK TO ALL IOS CHART CHART EXAMPLES