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.

// PalettedChartView.m

//
//  PalettedChartView.m
//  SciChartDemo
//
//  Created by Admin on 21.08.16.
//  Copyright © 2016 SciChart Ltd. All rights reserved.
//

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

@implementation PalettedChartView

-(instancetype)initWithFrame:(CGRect)frame{
    self = [super initWithFrame:frame];
    
    if (self) {
        self.surface = [[SCIChartSurface alloc]init];
        
        [self.surface setTranslatesAutoresizingMaskIntoConstraints:NO];
        [self addSubview:self.surface];
        
        NSDictionary *layout = @{@"SciChart":self.surface};
        
        [self addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"|-(0)-[SciChart]-(0)-|" options:0 metrics:0 views:layout]];
        [self addConstraints:[NSLayoutConstraint constraintsWithVisualFormat:@"V:|-(0)-[SciChart]-(0)-|" options:0 metrics:0 views:layout]];
        [self initializeSurfaceData];
    }
    
    return self;
}

-(void) initializeSurfaceData {
    
    id<SCIAxis2DProtocol> axisY = [[SCINumericAxis alloc] init];
    axisY.axisId = @"yAxis";
    [_surface.yAxes add:axisY];
    
    id<SCIAxis2DProtocol> axisX = [[SCINumericAxis alloc] init];
    axisX.axisId = @"xAxis";
    [axisX setVisibleRange: [[SCIDoubleRange alloc]initWithMin:SCIGeneric(150.0) Max:SCIGeneric(165.0)]];
    [_surface.xAxes add:axisX];
    
    SCIXAxisDragModifier * xDragModifier = [SCIXAxisDragModifier new];
    xDragModifier.axisId = @"xAxis";
    xDragModifier.dragMode = SCIAxisDragMode_Scale;
    xDragModifier.clipModeX = SCIClipMode_None;
    
    SCIYAxisDragModifier * yDragModifier = [SCIYAxisDragModifier new];
    yDragModifier.axisId = @"yAxis";
    yDragModifier.dragMode = SCIAxisDragMode_Pan;
    
    SCIPinchZoomModifier * pzm = [[SCIPinchZoomModifier alloc] init];
    SCIZoomExtentsModifier * zem = [[SCIZoomExtentsModifier alloc] init];
    
    SCIZoomPanModifier * zpm = [[SCIZoomPanModifier alloc] init];
    
    [zpm setModifierName:@"ZoomPan Modifier"];
    [zem setModifierName:@"ZoomExtents Modifier"];
    [pzm setModifierName:@"PinchZoom Modifier"];
    [yDragModifier setModifierName:@"YAxis Drag Modifier"];
    [xDragModifier setModifierName:@"XAxis Drag Modifier"];
    
    SCIChartModifierCollection * gm = [[SCIChartModifierCollection alloc] initWithChildModifiers:@[xDragModifier, yDragModifier, pzm, zem, zpm]];
    _surface.chartModifiers = gm;
    
    [self initializeSurfaceRenderableSeries];
    [self addBoxAnnotation];
    
    [_surface invalidateElement];
}

-(void) initializeSurfaceRenderableSeries {
    SCIOhlcDataSeries * priceDataSeries = [[SCIOhlcDataSeries alloc] initWithXType:SCIDataType_DateTime YType:SCIDataType_Float];
    [DataManager getPriceIndu:@"INDU_Daily" data:priceDataSeries];
    
    float offset = -1000;
    
    SCIArrayController * xdata = [[SCIArrayController alloc]initWithType:SCIDataType_Float];
    for (int i = 0; i<[priceDataSeries count]; i++) {
        [xdata append:SCIGeneric(i)];
    }
    
    SCIXyDataSeries * mountainDataSeries = [[SCIXyDataSeries alloc] initWithXType:SCIDataType_Float YType:SCIDataType_Float];
    SCIArrayController * ac = [self offset:[priceDataSeries lowColumn] offset:offset*2];
    [mountainDataSeries appendRangeX:SCIGeneric([xdata floatData])
                                   Y:SCIGeneric([ac floatData])
                               Count:[priceDataSeries count]];
    
    SCIXyDataSeries * lineDataSeries = [[SCIXyDataSeries alloc] initWithXType:SCIDataType_Float YType:SCIDataType_Float];
    ac = [self offset:[priceDataSeries closeColumn]  offset: -offset];
    [lineDataSeries appendRangeX:SCIGeneric([xdata floatData])
                                   Y:SCIGeneric([ac floatData])
                               Count:[priceDataSeries count]];
    
    SCIXyDataSeries * columnDataSeries = [[SCIXyDataSeries alloc] initWithXType:SCIDataType_Float YType:SCIDataType_Float];
    ac = [self offset:[priceDataSeries closeColumn] offset: offset*3];
    [columnDataSeries appendRangeX:SCIGeneric([xdata floatData])
                                   Y:SCIGeneric([ac floatData])
                               Count:[priceDataSeries count]];
    
    SCIXyDataSeries * scatterDataSeries = [[SCIXyDataSeries alloc] initWithXType:SCIDataType_Float YType:SCIDataType_Float];
    ac = [self offset:[priceDataSeries openColumn] offset: offset*2.5];
    [scatterDataSeries appendRangeX:SCIGeneric([xdata floatData])
                                   Y:SCIGeneric([ac floatData])
                               Count:[priceDataSeries count]];
    
    SCIOhlcDataSeries * candleDataSeries = [[SCIOhlcDataSeries alloc] initWithXType:SCIDataType_Float YType:SCIDataType_Float];
    SCIArrayController * ac1 = [self offset:[priceDataSeries openColumn] offset: offset];
    SCIArrayController * ac2 = [self offset:[priceDataSeries highColumn] offset: offset];
    SCIArrayController * ac3 = [self offset:[priceDataSeries lowColumn] offset: offset];
    SCIArrayController * ac4 = [self offset:[priceDataSeries closeColumn] offset: offset];
    [candleDataSeries appendRangeX:SCIGeneric([xdata floatData])
                              Open:SCIGeneric([ac1 floatData])
                              High:SCIGeneric([ac2 floatData])
                               Low:SCIGeneric([ac3 floatData])
                             Close:SCIGeneric([ac4 floatData])
                             Count:[priceDataSeries count]];
    
    SCIOhlcDataSeries * ohlcDataSeries = [[SCIOhlcDataSeries alloc] initWithXType:SCIDataType_Float YType:SCIDataType_Float];
    [ohlcDataSeries appendRangeX:SCIGeneric([xdata floatData])
                              Open:SCIGeneric([[priceDataSeries openColumn] floatData])
                              High:SCIGeneric([[priceDataSeries highColumn] floatData])
                               Low:SCIGeneric([[priceDataSeries lowColumn] floatData])
                             Close:SCIGeneric([[priceDataSeries closeColumn] floatData])
                             Count:[priceDataSeries count]];
    
    SCIFastMountainRenderableSeries * mountainRS = [SCIFastMountainRenderableSeries new];
    [mountainRS setXAxisId: @"xAxis"];
    [mountainRS setYAxisId: @"yAxis"];
    [mountainRS setDataSeries:mountainDataSeries];
    [mountainRS.style setAreaStyle:[[SCISolidBrushStyle alloc]initWithColorCode:0x9787CEEB]];
    [mountainRS.style setStrokeStyle:[[SCISolidPenStyle alloc]initWithColorCode:0xFFFF00FF withThickness:1.0]];
    [mountainRS setZeroLineY:6000];
    [mountainRS setPaletteProvider: [CustomPalette new]];
    [_surface.renderableSeries add:mountainRS];
    
    SCIEllipsePointMarker * ellipsePointMarker = [[SCIEllipsePointMarker alloc]init];
    [ellipsePointMarker setFillStyle:[[SCISolidBrushStyle alloc] initWithColor: [UIColor redColor]]];
    [ellipsePointMarker setStrokeStyle:[[SCISolidPenStyle alloc]initWithColor: [UIColor orangeColor] withThickness:2.0]];
    [ellipsePointMarker setHeight:10];
    [ellipsePointMarker setWidth:10];
    
    SCIFastLineRenderableSeries * lineRS = [SCIFastLineRenderableSeries new];
    [lineRS setXAxisId: @"xAxis"];
    [lineRS setYAxisId: @"yAxis"];
    [lineRS setDataSeries:lineDataSeries];
    [lineRS setStrokeStyle:[[SCISolidPenStyle alloc]initWithColorCode:0xFF0000FF withThickness:1.0]];
    [lineRS.style setPointMarker:ellipsePointMarker];
    [lineRS setPaletteProvider: [CustomPalette new]];
    [_surface.renderableSeries add:lineRS];
    
    SCIFastOhlcRenderableSeries * ohlcRS = [SCIFastOhlcRenderableSeries new];
    [ohlcRS setXAxisId: @"xAxis"];
    [ohlcRS setYAxisId: @"yAxis"];
    [ohlcRS setDataSeries:ohlcDataSeries];
    [ohlcRS setPaletteProvider: [CustomPalette new]];
    [_surface.renderableSeries add:ohlcRS];
    
    SCIFastCandlestickRenderableSeries * candlesRS = [SCIFastCandlestickRenderableSeries new];
    [candlesRS setXAxisId: @"xAxis"];
    [candlesRS setYAxisId: @"yAxis"];
    [candlesRS setDataSeries:candleDataSeries];
    [candlesRS setPaletteProvider: [CustomPalette new]];
    [_surface.renderableSeries add:candlesRS];
    
    SCIFastColumnRenderableSeries * columnRS = [SCIFastColumnRenderableSeries new];
    [columnRS setXAxisId: @"xAxis"];
    [columnRS setYAxisId: @"yAxis"];
    [columnRS setDataSeries:columnDataSeries];
    [columnRS setStrokeStyle:nil];
    [columnRS setZeroLineY:6000];
    [columnRS.style setDataPointWidth:0.8];
    [columnRS.style setFillBrushStyle:[[SCISolidBrushStyle alloc]initWithColor:[UIColor blueColor]]];
    [columnRS setPaletteProvider: [CustomPalette new]];
    [_surface.renderableSeries add:columnRS];
    
    SCISquarePointMarker * squarePointMarker = [[SCISquarePointMarker alloc]init];
    [squarePointMarker setFillStyle:[[SCISolidBrushStyle alloc] initWithColor: [UIColor redColor]]];
    [squarePointMarker setStrokeStyle:[[SCISolidPenStyle alloc]initWithColor: [UIColor orangeColor] withThickness:2.0]];
    [squarePointMarker setHeight:7];
    [squarePointMarker setWidth:7];
    
    SCIXyScatterRenderableSeries * scatterRS = [SCIXyScatterRenderableSeries new];
    [scatterRS setXAxisId: @"xAxis"];
    [scatterRS setYAxisId: @"yAxis"];
    [scatterRS setDataSeries:scatterDataSeries];
    [scatterRS.style setPointMarker:squarePointMarker];
    [scatterRS setPaletteProvider: [CustomPalette new]];
    [_surface.renderableSeries add:scatterRS];
}

-(SCIArrayController*) offset:(SCIArrayController*)dataSeries offset:(float)offset{
    SCIArrayController * result = [[SCIArrayController alloc] initWithType:SCIDataType_Float];
    for (int i =0; i<[dataSeries count]; i++) {
        float y = SCIGenericFloat([dataSeries valueAt:i]);
        y += offset;
        [result append:SCIGeneric(y)];
    }
    return result;
}

-(void)addBoxAnnotation{
    SCIBoxAnnotation * boxAnnotation = [[SCIBoxAnnotation alloc] init];
    boxAnnotation.coordinateMode = SCIAnnotationCoordinate_RelativeY;
    [boxAnnotation setXAxisId: @"xAxis"];
    [boxAnnotation setYAxisId: @"yAxis"];
    boxAnnotation.x1 = SCIGeneric(152);
    boxAnnotation.y1 = SCIGeneric(1.0);
    boxAnnotation.x2 = SCIGeneric(158);
    boxAnnotation.y2 = SCIGeneric(0.0);
    boxAnnotation.style.fillBrush = [[SCILinearGradientBrushStyle alloc]initWithColorStart:[UIColor fromARGBColorCode:0x550000FF] finish:[UIColor fromARGBColorCode:0x55FFFF00] direction:(SCILinearGradientDirection_Vertical)];
    boxAnnotation.style.borderPen = [[SCISolidPenStyle alloc]initWithColor: [UIColor fromARGBColorCode:0xFF279B27] withThickness:1.0];
    
    [_surface setAnnotations:[[SCIAnnotationCollection alloc] initWithChildAnnotations:@[boxAnnotation]]];
}

@end

// CustomPalette.m

//
//  CustomPalette.m
//  SciChartDemo
//
//  Created by Yaroslav Pelyukh on 27/04/2017.
//  Copyright © 2017 ABT. All rights reserved.
//

#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 setWidth:7];
        [ellipsePointMarker setHeight:7];
        [ellipsePointMarker setFillStyle:[[SCISolidBrushStyle alloc]initWithColor:[UIColor redColor]]];
        [ellipsePointMarker setStrokeStyle:[[SCISolidPenStyle alloc] initWithColor:[UIColor redColor] withThickness:1.0]];
        
        _lineSeriesStyle = [SCILineSeriesStyle new];
        [_lineSeriesStyle setPointMarker:ellipsePointMarker];
        [_lineSeriesStyle setStrokeStyle:[[SCISolidPenStyle alloc] initWithColor:[UIColor redColor] withThickness:1.0]];
        
        _mountainSeriesStyle = [SCIMountainSeriesStyle new];
        [_mountainSeriesStyle setAreaStyle:[[SCISolidBrushStyle alloc]initWithColor:[UIColor redColor]]];
        [_mountainSeriesStyle setStrokeStyle: [[SCISolidPenStyle alloc] initWithColor:[UIColor redColor] withThickness:1.0]];
        
        _scatterSeriesStyle = [SCIScatterSeriesStyle new];
        SCISquarePointMarker * squarePointMarker = [SCISquarePointMarker new];
        [squarePointMarker setWidth:7];
        [squarePointMarker setHeight:7];
        [squarePointMarker setFillStyle:[[SCISolidBrushStyle alloc]initWithColor:[UIColor greenColor]]];
        [_scatterSeriesStyle setPointMarker: squarePointMarker];
        
        _ohlcSeriesStyle = [SCIOhlcSeriesStyle new];
        [_ohlcSeriesStyle setStrokeUpStyle:[[SCISolidPenStyle alloc]initWithColorCode:0xFF6495ED withThickness:1.0]];
        [_ohlcSeriesStyle setStrokeDownStyle:[[SCISolidPenStyle alloc]initWithColorCode:0xFF6495ED withThickness:1.0]];
        
        _candleStickSeriesStyle = [SCICandlestickSeriesStyle new];
        [_candleStickSeriesStyle setFillUpBrushStyle: [[SCISolidBrushStyle alloc]initWithColor:[UIColor greenColor]]];
        [_candleStickSeriesStyle setFillDownBrushStyle: [[SCISolidBrushStyle alloc]initWithColor:[UIColor greenColor]]];
        
        _columnSeriesStyle = [SCIColumnSeriesStyle new];
        [_columnSeriesStyle setStrokeStyle:nil];
        [_columnSeriesStyle setFillBrushStyle:[[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

// SCSPalettedChartView.swift

//
//  SCSPalettedChartView.swift
//  SciChartSwiftDemo
//
//  Created by Admin on 08/22/16.
//  Copyright © 2016 SciChart Ltd. All rights reserved.
//

import UIKit
import SciChart

class SCSPalettedChartView: UIView {
    let surface = SCIChartSurface()
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        completeConfiguration()
    }
    
    required init?(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
        completeConfiguration()
    }
    
    func addDefaultModifiers() {
        
        let xAxisDragmodifier = SCIXAxisDragModifier()
        xAxisDragmodifier.dragMode = .scale
        xAxisDragmodifier.clipModeX = .none
        
        let yAxisDragmodifier = SCIYAxisDragModifier()
        yAxisDragmodifier.dragMode = .pan
        
        let extendZoomModifier = SCIZoomExtentsModifier()
        
        let pinchZoomModifier = SCIPinchZoomModifier()
        
        let rolloverModifier = SCIRolloverModifier()
        rolloverModifier.style.tooltipSize = CGSize(width: 200, height: CGFloat.nan)
        
        let groupModifier = SCIChartModifierCollection(childModifiers: [xAxisDragmodifier, yAxisDragmodifier, pinchZoomModifier, extendZoomModifier, rolloverModifier])
        
        surface.chartModifiers = groupModifier
    }
    
    // MARK: initialize surface
    fileprivate func addSurface() {
        surface.translatesAutoresizingMaskIntoConstraints = true
        surface.frame = bounds
        surface.autoresizingMask = [.flexibleHeight, .flexibleWidth]
        addSubview(surface)
    }
    // MARK: Overrided Functions
    
        func completeConfiguration() {
        addSurface()
        addAxes()
        addDefaultModifiers()
        addSeries()
        buildBoxAnnotation()   
    }
    
    // MARK: Private Functions
    
    fileprivate func addAxes() {
        let xAxis = SCINumericAxis()
        xAxis.visibleRange = SCIDoubleRange.init(min: SCIGeneric(150), max: SCIGeneric(164))
        surface.xAxes.add(xAxis)
        
        let yAxis = SCINumericAxis()
        yAxis.autoRange = .always
        surface.yAxes.add(yAxis)
    }
    
    fileprivate func addSeries() {
        let priceDataSeries:SCIOhlcDataSeries = SCIOhlcDataSeries.init(xType: .dateTime, yType: .float)
        SCSDataManager.getPriceIndu(dataSeries: priceDataSeries, fileName: "INDU_Daily")
        
        let offset:Float = -1000
        
        let xdata:SCIArrayController = SCIArrayController.init(type: .float)
        for i in 0..<priceDataSeries.count() {
            xdata.append(SCIGeneric(i))
        }
        
        let mountainDataSeries = SCIXyDataSeries.init(xType: .float, yType: .float)
        var ac = offsetData(dataSeries: priceDataSeries.lowColumn as! (SCIArrayController), offset: offset*2)
        mountainDataSeries.appendRangeX(SCIGeneric(xdata.floatData()), y:SCIGeneric(ac.floatData()), count:priceDataSeries.count());
        
        let lineDataSeries = SCIXyDataSeries.init(xType: .float, yType: .float)
        ac = offsetData(dataSeries: priceDataSeries.closeColumn as! (SCIArrayController), offset: -offset)
        lineDataSeries.appendRangeX(SCIGeneric(xdata.floatData()), y:SCIGeneric(ac.floatData()), count:priceDataSeries.count());
        
        let columnDataSeries = SCIXyDataSeries.init(xType: .float, yType: .float)
        ac = offsetData(dataSeries: priceDataSeries.closeColumn as! (SCIArrayController), offset: offset*3)
        columnDataSeries.appendRangeX(SCIGeneric(xdata.floatData()), y:SCIGeneric(ac.floatData()), count:priceDataSeries.count());
        
        let scatterDataSeries = SCIXyDataSeries.init(xType: .float, yType: .float)
        ac = offsetData(dataSeries: priceDataSeries.openColumn as! (SCIArrayController), offset: offset*2.5)
        scatterDataSeries.appendRangeX(SCIGeneric(xdata.floatData()), y:SCIGeneric(ac.floatData()), count:priceDataSeries.count());
        
        let candleDataSeries = SCIOhlcDataSeries.init(xType: .float, yType: .float)
        let ac1 = offsetData(dataSeries: priceDataSeries.lowColumn as! (SCIArrayController), offset: offset)
        let ac2 = offsetData(dataSeries: priceDataSeries.lowColumn as! (SCIArrayController), offset: offset)
        let ac3 = offsetData(dataSeries: priceDataSeries.lowColumn as! (SCIArrayController), offset: offset)
        let ac4 = offsetData(dataSeries: priceDataSeries.lowColumn as! (SCIArrayController), offset: offset)
        candleDataSeries.appendRangeX(SCIGeneric(xdata.floatData()), open: SCIGeneric(ac1.floatData()), high: SCIGeneric(ac2.floatData()), low: SCIGeneric(ac3.floatData()), close: SCIGeneric(ac4.floatData()), count: priceDataSeries.count())
        
        let ohlcDataSeries = SCIOhlcDataSeries.init(xType: .float, yType: .float)
        ohlcDataSeries.appendRangeX(SCIGeneric(xdata.floatData()), open: SCIGeneric(priceDataSeries.openColumn.floatData()), high: SCIGeneric(priceDataSeries.highColumn.floatData()), low: SCIGeneric(priceDataSeries.lowColumn.floatData()), close: SCIGeneric(priceDataSeries.closeColumn.floatData()), count: priceDataSeries.count())
        
        let mountainRS = SCIFastMountainRenderableSeries()
        mountainRS.dataSeries=mountainDataSeries
        mountainRS.areaStyle = SCISolidBrushStyle.init(colorCode: 0x9787CEEB)
        mountainRS.style.strokeStyle = SCISolidPenStyle.init(colorCode: 0xFFFF00FF, withThickness: 1.0)
        mountainRS.zeroLineY = 6000
        mountainRS.paletteProvider = SCSCustomPaletteProvider()
        surface.renderableSeries.add(mountainRS)
        
        let ellipsePointMarker = SCIEllipsePointMarker()
        ellipsePointMarker.fillStyle = SCISolidBrushStyle.init(color: UIColor.red)
        ellipsePointMarker.strokeStyle = SCISolidPenStyle.init(color: UIColor.orange, withThickness: 2.0)
        ellipsePointMarker.height = 10
        ellipsePointMarker.width = 10
        
        let lineRS = SCIFastLineRenderableSeries()
        lineRS.dataSeries = lineDataSeries
        lineRS.strokeStyle = SCISolidPenStyle.init(colorCode: 0xFF0000FF, withThickness: 1.0)
        lineRS.style.pointMarker = ellipsePointMarker
        lineRS.paletteProvider = SCSCustomPaletteProvider()
        surface.renderableSeries.add(lineRS)
        
        let ohlcRS = SCIFastOhlcRenderableSeries()
        ohlcRS.dataSeries = ohlcDataSeries
        ohlcRS.paletteProvider = SCSCustomPaletteProvider()
        surface.renderableSeries.add(ohlcRS)
        
        let candlesRS = SCIFastCandlestickRenderableSeries()
        candlesRS.dataSeries = candleDataSeries
        candlesRS.paletteProvider = SCSCustomPaletteProvider()
        surface.renderableSeries.add(candlesRS)
        
        let columnRS = SCIFastColumnRenderableSeries()
        columnRS.dataSeries = columnDataSeries
        columnRS.zeroLineY = 6000
        columnRS.style.dataPointWidth = 0.8
        columnRS.fillBrushStyle = SCISolidBrushStyle.init(color: UIColor.blue)
        columnRS.paletteProvider = SCSCustomPaletteProvider()
        surface.renderableSeries.add(columnRS)
        
        let squarePointMarker = SCISquarePointMarker()
        squarePointMarker.fillStyle = SCISolidBrushStyle.init(color: UIColor.red)
        squarePointMarker.strokeStyle = SCISolidPenStyle.init(color: UIColor.orange, withThickness: 2.0)
        squarePointMarker.height = 7
        squarePointMarker.width = 7
        
        let scatterRS = SCIXyScatterRenderableSeries()
        scatterRS.dataSeries = scatterDataSeries
        scatterRS.style.pointMarker = squarePointMarker
        scatterRS.paletteProvider = SCSCustomPaletteProvider()
        surface.renderableSeries.add(scatterRS)
    }
    
    private func offsetData(dataSeries:(SCIArrayController), offset:(Float)) -> SCIArrayController{
        let result = SCIArrayController.init(type:.float)
        for i in 0..<dataSeries.count() {
            var y:Float = SCIGenericFloat(dataSeries.value(at: i))
            y += offset;
            result?.append(SCIGeneric(y))
        }
        return result!;
    }
    
    private func buildBoxAnnotation(){
        
        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.init(colorStart: UIColor.fromARGBColorCode(0x550000FF), finish: UIColor.fromARGBColorCode(0x55FFFF00), direction: .vertical)
        boxAnnotation.style.borderPen = SCISolidPenStyle.init(color: UIColor.fromARGBColorCode(0xFF279B27), withThickness: 1.0)
        
        surface.annotations = SCIAnnotationCollection.init(childAnnotations: [boxAnnotation])
    }
}

// SCSCustomPaletteProvider.swift

//
//  SCSCustomPaletteProvider.swift
//  SciChartSwiftDemo
//
//  Created by Yaroslav Pelyukh on 28/04/2017.
//  Copyright © 2017 SciChart Ltd. All rights reserved.
//

import Foundation
import SciChart

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

class SCSCustomPaletteProvider: SCIPaletteProvider {
    
    private let lineSeriesStyle: SCILineSeriesStyle = SCILineSeriesStyle()
    private let columnSeriesStyle: SCIColumnSeriesStyle = SCIColumnSeriesStyle()
    private let ohlcSeriesStyle: SCIOhlcSeriesStyle = SCIOhlcSeriesStyle()
    private let candleStickSeriesStyle: SCICandlestickSeriesStyle = SCICandlestickSeriesStyle()
    private let mountainSeriesStyle: SCIMountainSeriesStyle = SCIMountainSeriesStyle()
    private let scatterSeriesStyle: SCIScatterSeriesStyle = 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