Delta

//------------------------------------------------------------------------------
//
// Индикатор Delta. Copyright (c) 2019 Ilya Smirnov. All rights reserved.
//
//------------------------------------------------------------------------------
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.Serialization;
using System.Windows;
using System.Windows.Media;
using TigerTrade.Chart.Alerts;
using TigerTrade.Chart.Base;
using TigerTrade.Chart.Indicators.Common;
using TigerTrade.Chart.Indicators.Enums;
using TigerTrade.Core.UI.Converters;
using TigerTrade.Dx;
 
namespace TigerTrade.Chart.Indicators.Custom
{
    [TypeConverter(typeof(EnumDescriptionTypeConverter))]
    [DataContract(Name = "DeltaViewType", Namespace = "http://schemas.datacontract.org/2004/07/TigerTrade.Chart.Indicators.Custom")]
    public enum DeltaViewType
    {
        [EnumMember(Value = "Columns"), Description("Колонки")]
        Columns,
        [EnumMember(Value = "Candles"), Description("Свечи")]
        Candles
    }
 
    [DataContract(Name = "DeltaIndicator", Namespace = "http://schemas.datacontract.org/2004/07/TigerTrade.Chart.Indicators.Custom")]
    [Indicator("X_Delta", "*Delta", false, Type = typeof(DeltaIndicator))]
    internal sealed class DeltaIndicator : IndicatorBase
    {
        private XBrush _deltaPlusBrush;
 
        private XPen _deltaPlusPen;
 
        private XColor _deltaPlusColor;
 
        [DataMember(Name = "DeltaPlusColor")]
        [Category("Стиль"), DisplayName("Delta+")]
        public XColor DeltaPlusColor
        {
            get => _deltaPlusColor;
            set
            {
                if (value == _deltaPlusColor)
                {
                    return;
                }
 
                _deltaPlusColor = value;
 
                _deltaPlusBrush = new XBrush(_deltaPlusColor);
 
                _deltaPlusPen = new XPen(_deltaPlusBrush, 1);
 
                OnPropertyChanged();
            }
        }
 
        private XBrush _deltaMinusBrush;
 
        private XPen _deltaMinusPen;
 
        private XColor _deltaMinusColor;
 
        [DataMember(Name = "DeltaMinusColor")]
        [Category("Стиль"), DisplayName("Delta-")]
        public XColor DeltaMinusColor
        {
            get => _deltaMinusColor;
            set
            {
                if (value == _deltaMinusColor)
                {
                    return;
                }
 
                _deltaMinusColor = value;
 
                _deltaMinusBrush = new XBrush(_deltaMinusColor);
 
                _deltaMinusPen = new XPen(_deltaMinusBrush, 1);
 
                OnPropertyChanged();
            }
        }
 
        private DeltaViewType _type;
 
        [DataMember(Name = "DeltaType"), DefaultValue(DeltaViewType.Columns)]
        [Category("Параметры"), DisplayName("Тип")]
        public DeltaViewType Type
        {
            get => _type;
            set
            {
                if (value == _type)
                {
                    return;
                }
 
                _type = value;
 
                OnPropertyChanged();
            }
        }
 
        private bool _minimize;
 
        [DataMember(Name = "Minimize"), DefaultValue(false)]
        [Category("Параметры"), DisplayName("Минимизировать")]
        public bool Minimize
        {
            get => _minimize;
            set
            {
                if (value == _minimize)
                {
                    return;
                }
 
                _minimize = value;
 
                OnPropertyChanged();
            }
        }
 
        private IndicatorNullIntParam _maxDeltaParam;
 
        [DataMember(Name = "MaxDeltaParam")]
        public IndicatorNullIntParam MaxDeltaParam
        {
            get => _maxDeltaParam ?? (_maxDeltaParam = new IndicatorNullIntParam(null));
            set => _maxDeltaParam = value;
        }
 
        [DefaultValue(null)]
        [Category("Параметры"), DisplayName("Макс. дельта")]
        public int? MaxDelta
        {
            get => MaxDeltaParam.Get(SettingsLongKey);
            set
            {
                if (!MaxDeltaParam.Set(SettingsLongKey, value, 0))
                {
                    return;
                }
 
                OnPropertyChanged();
            }
        }
 
        private IndicatorNullIntParam _filter1MinParam;
 
        [DataMember(Name = "Filter1MinParam")]
        public IndicatorNullIntParam Filter1MinParam
        {
            get => _filter1MinParam ?? (_filter1MinParam = new IndicatorNullIntParam(null));
            set => _filter1MinParam = value;
        }
 
        [DefaultValue(null)]
        [Category("Фильтр 1"), DisplayName("Минимум")]
        public int? Filter1Min
        {
            get => Filter1MinParam.Get(SettingsLongKey);
            set
            {
                if (!Filter1MinParam.Set(SettingsLongKey, value, 0))
                {
                    return;
                }
 
                OnPropertyChanged();
            }
        }
 
        private IndicatorNullIntParam _filter1MaxParam;
 
        [DataMember(Name = "Filter1MaxParam")]
        public IndicatorNullIntParam Filter1MaxParam
        {
            get => _filter1MaxParam ?? (_filter1MaxParam = new IndicatorNullIntParam(null));
            set => _filter1MaxParam = value;
        }
 
        [DefaultValue(null)]
        [Category("Фильтр 1"), DisplayName("Максимум")]
        public int? Filter1Max
        {
            get => Filter1MaxParam.Get(SettingsLongKey);
            set
            {
                if (!Filter1MaxParam.Set(SettingsLongKey, value, 0))
                {
                    return;
                }
 
                OnPropertyChanged();
            }
        }
 
        private XBrush _filter1PlusBrush;
 
        private XPen _filter1PlusPen;
 
        private XColor _filter1PlusColor;
 
        [DataMember(Name = "Filter1PlusColor")]
        [Category("Фильтр 1"), DisplayName("Цвет+")]
        public XColor Filter1PlusColor
        {
            get => _filter1PlusColor;
            set
            {
                if (value == _filter1PlusColor)
                {
                    return;
                }
 
                _filter1PlusColor = value;
 
                _filter1PlusBrush = new XBrush(_filter1PlusColor);
                _filter1PlusPen = new XPen(_filter1PlusBrush, 1);
 
                OnPropertyChanged();
            }
        }
 
        private XBrush _filter1MinusBrush;
 
        private XPen _filter1MinusPen;
 
        private XColor _filter1MinusColor;
 
        [DataMember(Name = "Filter1MinusColor")]
        [Category("Фильтр 1"), DisplayName("Цвет-")]
        public XColor Filter1MinusColor
        {
            get => _filter1MinusColor;
            set
            {
                if (value == _filter1MinusColor)
                {
                    return;
                }
 
                _filter1MinusColor = value;
 
                _filter1MinusBrush = new XBrush(_filter1MinusColor);
                _filter1MinusPen = new XPen(_filter1MinusBrush, 1);
 
                OnPropertyChanged();
            }
        }
 
        private ChartAlertSettings _filter1Alert;
 
        [DataMember(Name = "Filter1Alert")]
        [Category("Фильтр 1"), DisplayName("Оповещение")]
        public ChartAlertSettings Filter1Alert
        {
            get => _filter1Alert ?? (_filter1Alert = new ChartAlertSettings());
            set
            {
                if (Equals(value, _filter1Alert))
                {
                    return;
                }
 
                _filter1Alert = value;
 
                OnPropertyChanged();
            }
        }
 
        private IndicatorNullIntParam _filter2MinParam;
 
        [DataMember(Name = "Filter2MinParam")]
        public IndicatorNullIntParam Filter2MinParam
        {
            get => _filter2MinParam ?? (_filter2MinParam = new IndicatorNullIntParam(null));
            set => _filter2MinParam = value;
        }
 
        [DefaultValue(null)]
        [Category("Фильтр 2"), DisplayName("Минимум")]
        public int? Filter2Min
        {
            get => Filter2MinParam.Get(SettingsLongKey);
            set
            {
                if (!Filter2MinParam.Set(SettingsLongKey, value, 0))
                {
                    return;
                }
 
                OnPropertyChanged();
            }
        }
 
        private IndicatorNullIntParam _filter2MaxParam;
 
        [DataMember(Name = "Filter2MaxParam")]
        public IndicatorNullIntParam Filter2MaxParam
        {
            get => _filter2MaxParam ?? (_filter2MaxParam = new IndicatorNullIntParam(null));
            set => _filter2MaxParam = value;
        }
 
        [DefaultValue(null)]
        [Category("Фильтр 2"), DisplayName("Максимум")]
        public int? Filter2Max
        {
            get => Filter2MaxParam.Get(SettingsLongKey);
            set
            {
                if (!Filter2MaxParam.Set(SettingsLongKey, value, 0))
                {
                    return;
                }
 
                OnPropertyChanged();
            }
        }
 
        private XBrush _filter2PlusBrush;
 
        private XPen _filter2PlusPen;
 
        private XColor _filter2PlusColor;
 
        [DataMember(Name = "Filter2PlusColor")]
        [Category("Фильтр 2"), DisplayName("Цвет+")]
        public XColor Filter2PlusColor
        {
            get => _filter2PlusColor;
            set
            {
                if (value == _filter2PlusColor)
                {
                    return;
                }
 
                _filter2PlusColor = value;
 
                _filter2PlusBrush = new XBrush(_filter2PlusColor);
                _filter2PlusPen = new XPen(_filter2PlusBrush, 1);
 
                OnPropertyChanged();
            }
        }
 
        private XBrush _filter2MinusBrush;
 
        private XPen _filter2MinusPen;
 
        private XColor _filter2MinusColor;
 
        [DataMember(Name = "Filter2MinusColor")]
        [Category("Фильтр 2"), DisplayName("Цвет-")]
        public XColor Filter2MinusColor
        {
            get => _filter2MinusColor;
            set
            {
                if (value == _filter2MinusColor)
                {
                    return;
                }
 
                _filter2MinusColor = value;
 
                _filter2MinusBrush = new XBrush(_filter2MinusColor);
                _filter2MinusPen = new XPen(_filter2MinusBrush, 1);
 
                OnPropertyChanged();
            }
        }
 
        private ChartAlertSettings _filter2Alert;
 
        [DataMember(Name = "Filter2Alert")]
        [Category("Фильтр 2"), DisplayName("Оповещение")]
        public ChartAlertSettings Filter2Alert
        {
            get => _filter2Alert ?? (_filter2Alert = new ChartAlertSettings());
            set
            {
                if (Equals(value, _filter2Alert))
                {
                    return;
                }
 
                _filter2Alert = value;
 
                OnPropertyChanged();
            }
        }
 
        private IndicatorNullIntParam _filter3MinParam;
 
        [DataMember(Name = "Filter3MinParam")]
        public IndicatorNullIntParam Filter3MinParam
        {
            get => _filter3MinParam ?? (_filter3MinParam = new IndicatorNullIntParam(null));
            set => _filter3MinParam = value;
        }
 
        [DefaultValue(null)]
        [Category("Фильтр 3"), DisplayName("Минимум")]
        public int? Filter3Min
        {
            get => Filter3MinParam.Get(SettingsLongKey);
            set
            {
                if (!Filter3MinParam.Set(SettingsLongKey, value, 0))
                {
                    return;
                }
 
                OnPropertyChanged();
            }
        }
 
        private IndicatorNullIntParam _filter3MaxParam;
 
        [DataMember(Name = "Filter3MaxParam")]
        public IndicatorNullIntParam Filter3MaxParam
        {
            get => _filter3MaxParam ?? (_filter3MaxParam = new IndicatorNullIntParam(null));
            set => _filter3MaxParam = value;
        }
 
        [DefaultValue(null)]
        [Category("Фильтр 3"), DisplayName("Максимум")]
        public int? Filter3Max
        {
            get => Filter3MaxParam.Get(SettingsLongKey);
            set
            {
                if (!Filter3MaxParam.Set(SettingsLongKey, value, 0))
                {
                    return;
                }
 
                OnPropertyChanged();
            }
        }
 
        private XBrush _filter3PlusBrush;
 
        private XPen _filter3PlusPen;
 
        private XColor _filter3PlusColor;
 
        [DataMember(Name = "Filter3PlusColor")]
        [Category("Фильтр 3"), DisplayName("Цвет+")]
        public XColor Filter3PlusColor
        {
            get => _filter3PlusColor;
            set
            {
                if (value == _filter3PlusColor)
                {
                    return;
                }
 
                _filter3PlusColor = value;
 
                _filter3PlusBrush = new XBrush(_filter3PlusColor);
                _filter3PlusPen = new XPen(_filter3PlusBrush, 1);
 
                OnPropertyChanged();
            }
        }
 
        private XBrush _filter3MinusBrush;
 
        private XPen _filter3MinusPen;
 
        private XColor _filter3MinusColor;
 
        [DataMember(Name = "Filter3MinusColor")]
        [Category("Фильтр 3"), DisplayName("Цвет-")]
        public XColor Filter3MinusColor
        {
            get => _filter3MinusColor;
            set
            {
                if (value == _filter3MinusColor)
                {
                    return;
                }
 
                _filter3MinusColor = value;
 
                _filter3MinusBrush = new XBrush(_filter3MinusColor);
                _filter3MinusPen = new XPen(_filter3MinusBrush, 1);
 
                OnPropertyChanged();
            }
        }
 
        private ChartAlertSettings _filter3Alert;
 
        [DataMember(Name = "Filter3Alert")]
        [Category("Фильтр 3"), DisplayName("Оповещение")]
        public ChartAlertSettings Filter3Alert
        {
            get => _filter3Alert ?? (_filter3Alert = new ChartAlertSettings());
            set
            {
                if (Equals(value, _filter3Alert))
                {
                    return;
                }
 
                _filter3Alert = value;
 
                OnPropertyChanged();
            }
        }
 
        [Browsable(false)]
        public override IndicatorCalculation Calculation => IndicatorCalculation.OnEachTick;
 
        public override bool IntegerValues => true;
 
        private int _filter1SignalIndex;
        private int _filter2SignalIndex;
        private int _filter3SignalIndex;
 
        public DeltaIndicator()
        {
            DeltaPlusColor = Color.FromArgb(255, 30, 144, 255);
            DeltaMinusColor = Color.FromArgb(255, 178, 34, 34);
 
            Type = DeltaViewType.Columns;
 
            Minimize = false;
 
            Filter1PlusColor = Colors.Orange;
            Filter1MinusColor = Colors.Orange;
 
            Filter2PlusColor = Colors.Orange;
            Filter2MinusColor = Colors.Orange;
 
            Filter3PlusColor = Colors.Orange;
            Filter3MinusColor = Colors.Orange;
 
            _filter1SignalIndex = -1;
            _filter2SignalIndex = -1;
            _filter3SignalIndex = -1;
        }
 
        protected override void Execute()
        {
            if (ClearData)
            {
                _filter1SignalIndex = -1;
                _filter2SignalIndex = -1;
                _filter3SignalIndex = -1;
            }
 
            var index = DataProvider.Count;
 
            var cluster = DataProvider.GetCluster(index - 1);
 
            if (cluster == null)
            {
                return;
            }
 
            var realDelta = cluster.Delta;
            var absDelta = Math.Abs(realDelta);
 
            if (Filter1Alert.IsActive && _filter1SignalIndex < index)
            {
                var min = Filter1Min ?? -1;
                var max = Filter1Max ?? -1;
 
                if (min >= 0 && absDelta >= min && (max < 0 || absDelta <= max))
                {
                    _filter1SignalIndex = index;
 
                    AddAlert(Filter1Alert,
                        $"Delta: фильтр 1, значение {DataProvider.Symbol.FormatSizeFull(realDelta)}.");
                }
            }
 
            if (Filter2Alert.IsActive && _filter2SignalIndex < index)
            {
                var min = Filter2Min ?? -1;
                var max = Filter2Max ?? -1;
 
                if (min >= 0 && absDelta >= min && (max < 0 || absDelta <= max))
                {
                    _filter2SignalIndex = index;
 
                    AddAlert(Filter2Alert,
                        $"Delta: фильтр 2, значение {DataProvider.Symbol.FormatSizeFull(realDelta)}.");
                }
            }
 
            if (Filter3Alert.IsActive && _filter3SignalIndex < index)
            {
                var min = Filter3Min ?? -1;
                var max = Filter3Max ?? -1;
 
                if (min >= 0 && absDelta >= min && (max < 0 || absDelta <= max))
                {
                    _filter3SignalIndex = index;
 
                    AddAlert(Filter3Alert,
                        $"Delta: фильтр 3, значение {DataProvider.Symbol.FormatSizeFull(realDelta)}.");
                }
            }
        }
 
        public override bool GetMinMax(out double min, out double max)
        {
            min = double.MaxValue;
            max = double.MinValue;
 
            if (Type == DeltaViewType.Candles)
            {
                for (var i = 0; i < Canvas.Count; i++)
                {
                    var index = Canvas.GetIndex(i);
 
                    var cluster = DataProvider.GetCluster(index);
 
                    if (cluster == null || cluster.Delta == 0)
                    {
                        continue;
                    }
 
                    var deltaHigh = (double)cluster.DeltaHigh;
                    var deltaLow = (double)cluster.DeltaLow;
 
                    if (Minimize && cluster.Delta < 0)
                    {
                        max = Math.Max(max, -deltaLow);
                        min = Math.Min(min, -deltaHigh);
 
                    }
                    else
                    {
                        min = Math.Min(min, deltaLow);
                        max = Math.Max(max, deltaHigh);
                    }
                }
            }
            else
            {
                for (var i = 0; i < Canvas.Count; i++)
                {
                    var index = Canvas.GetIndex(i);
 
                    var cluster = DataProvider.GetCluster(index);
 
                    if (cluster == null || cluster.Delta == 0)
                    {
                        continue;
                    }
 
                    var delta = (double)cluster.Delta;
 
                    if (Minimize)
                    {
                        max = Math.Max(max, Math.Abs(delta));
                    }
                    else
                    {
                        min = Math.Min(min, delta);
                        max = Math.Max(max, delta);
                    }
                }
 
                if (Minimize)
                {
                    min = 0.0;
                }
            }
 
            var maxDelta = MaxDelta ?? -1;
 
            if (maxDelta >= 0 && max > maxDelta)
            {
                max = maxDelta;
            }
 
            if (maxDelta >= 0 && min < -maxDelta)
            {
                min = -maxDelta;
            }
 
            return true;
        }
 
        public override void Render(DxVisualQueue visual)
        {
            var min1 = Filter1Min ?? -1;
            var max1 = Filter1Max ?? -1;
            var min2 = Filter2Min ?? -1;
            var max2 = Filter2Max ?? -1;
            var min3 = Filter3Min ?? -1;
            var max3 = Filter3Max ?? -1;
 
            var maxDelta = MaxDelta ?? -1;
            var maxPoint = (int)GetY((double)maxDelta);
            var minPoint = (int)GetY((double)-maxDelta);
 
            var zeroPoint = (int)GetY(0.0);
 
            switch (Type)
            {
                case DeltaViewType.Candles:
                    {
                        var width = (int)(Canvas.ColumnWidth * Canvas.ColumnPercent + 0.4);
                        var halfWith = Math.Max((int)(width / 2.0), 1.0);
 
                        var openY = zeroPoint;
 
                        for (var i = 0; i < Canvas.Count; i++)
                        {
                            var index = Canvas.GetIndex(i);
 
                            var cluster = DataProvider.GetCluster(index);
 
                            if (cluster == null || cluster.Delta == 0)
                            {
                                continue;
                            }
 
                            var delta = cluster.Delta;
 
                            var isUp = delta > 0;
 
                            var centerX = (int)Canvas.GetX(index);
                            var highY = (int)GetY(cluster.DeltaHigh);
                            var lowY = (int)GetY(cluster.DeltaLow);
                            var closeY = (int)GetY(delta);
 
                            if (Minimize && delta < 0)
                            {
                                highY = (int) GetY(-cluster.DeltaLow);
                                lowY = (int) GetY(-cluster.DeltaHigh);
                                closeY = (int) GetY(-delta);
                            }
 
                            if (maxDelta >= 0)
                            {
                                if (delta > 0 || Minimize)
                                {
                                    closeY = Math.Max(closeY, maxPoint);
                                    highY = Math.Max(highY, maxPoint);
                                    lowY = Math.Min(lowY, minPoint);
                                }
                                else
                                {
                                    closeY = Math.Min(closeY, minPoint);
                                    highY = Math.Max(highY, maxPoint);
                                    lowY = Math.Min(lowY, minPoint);
                                }
                            }
 
                            var topY = Math.Min(openY, closeY);
                            var bottomY = Math.Max(openY, closeY);
 
                            var height = bottomY - topY;
 
                            var backBrush = isUp ? _deltaPlusBrush : _deltaMinusBrush;
                            var backPen = isUp ? _deltaPlusPen : _deltaMinusPen;
 
                            var absDelta = Math.Abs(delta);
 
                            if (min1 >= 0 && absDelta >= min1 && (max1 < 0 || absDelta <= max1))
                            {
                                if (delta > 0)
                                {
                                    backBrush = _filter1PlusBrush;
                                    backPen = _filter1PlusPen;
                                }
                                else
                                {
                                    backBrush = _filter1MinusBrush;
                                    backPen = _filter1MinusPen;
                                }
                            }
                            else if (min2 >= 0 && absDelta >= min2 && (max2 < 0 || absDelta <= max2))
                            {
                                if (delta > 0)
                                {
                                    backBrush = _filter2PlusBrush;
                                    backPen = _filter2PlusPen;
                                }
                                else
                                {
                                    backBrush = _filter2MinusBrush;
                                    backPen = _filter2MinusPen;
                                }
                            }
                            else if (min3 >= 0 && absDelta >= min3 && (max3 < 0 || absDelta <= max3))
                            {
                                if (delta > 0)
                                {
                                    backBrush = _filter3PlusBrush;
                                    backPen = _filter3PlusPen;
                                }
                                else
                                {
                                    backBrush = _filter3MinusBrush;
                                    backPen = _filter3MinusPen;
                                }
                            }
 
                            if (height == 0 || width <= 1)
                            {
                                if (highY == lowY)
                                {
                                    lowY++;
                                }
 
                                visual.DrawLine(backPen,
                                        new Point(centerX, highY),
                                        new Point(centerX, lowY));
                            }
                            else
                            {
                                visual.DrawLine(backPen,
                                    new Point(centerX, highY),
                                    new Point(centerX, topY));
 
                                visual.DrawLine(backPen,
                                    new Point(centerX, bottomY),
                                    new Point(centerX, lowY));
                            }
 
                            if (width > 1)
                            {
                                if (height == 0)
                                {
                                    visual.DrawLine(backPen,
                                        new Point(centerX - halfWith, topY),
                                        new Point(centerX + halfWith + 1, topY));
                                }
                                else
                                {
                                    visual.FillRectangle(backBrush,
                                        new Rect(centerX - halfWith, topY, halfWith*2 + 1, height));
                                }
                            }
                        }
                    }
 
                    break;
 
                case DeltaViewType.Columns:
                    {
                        var width = Math.Max(Canvas.ColumnWidth - 1, 1);
 
                        for (var i = 0; i < Canvas.Count; i++)
                        {
                            var index = Canvas.GetIndex(i);
 
                            var cluster = DataProvider.GetCluster(index);
 
                            if (cluster == null || cluster.Delta == 0)
                            {
                                continue;
                            }
 
                            var delta = cluster.Delta;
 
                            var x = Canvas.GetX(index);
                            var y = GetY(Minimize ? Math.Abs(delta) : delta);
 
                            if (maxDelta >= 0)
                            {
                                if (Minimize)
                                {
                                    y = Math.Max(y, maxPoint);
                                }
                                else
                                {
                                    y = delta > 0 ? Math.Max(y, maxPoint) : Math.Min(y, minPoint);
                                }
                            }
 
                            var h = zeroPoint - (int)y;
 
                            if (h < 0.0)
                            {
                                y += h;
                                h = -h;
                            }
 
                            if (Minimize || delta > 0)
                            {
                                if (h < 1)
                                {
                                    y = zeroPoint - 1;
                                    h = 1;
                                }
                            }
                            else
                            {
                                if (h < 1)
                                {
                                    y = zeroPoint;
                                    h = 1;
                                }
                            }
 
                            var isUp = delta > 0;
 
                            XBrush filterBrush = null;
                            XPen filterPen = null;
 
                            var absDelta = Math.Abs(delta);
 
                            if (min1 >= 0 && absDelta >= min1 && (max1 < 0 || absDelta <= max1))
                            {
                                if (delta > 0)
                                {
                                    filterBrush = _filter1PlusBrush;
                                    filterPen = _filter1PlusPen;
                                }
                                else
                                {
                                    filterBrush = _filter1MinusBrush;
                                    filterPen = _filter1MinusPen;
                                }
                            }
                            else if (min2 >= 0 && absDelta >= min2 && (max2 < 0 || absDelta <= max2))
                            {
                                if (delta > 0)
                                {
                                    filterBrush = _filter2PlusBrush;
                                    filterPen = _filter2PlusPen;
                                }
                                else
                                {
                                    filterBrush = _filter2MinusBrush;
                                    filterPen = _filter2MinusPen;
                                }
                            }
                            else if (min3 >= 0 && absDelta >= min3 && (max3 < 0 || absDelta <= max3))
                            {
                                if (delta > 0)
                                {
                                    filterBrush = _filter3PlusBrush;
                                    filterPen = _filter3PlusPen;
                                }
                                else
                                {
                                    filterBrush = _filter3MinusBrush;
                                    filterPen = _filter3MinusPen;
                                }
                            }
 
                            if (width > 1.0)
                            {
                                var rect = new Rect(x - width / 2.0, y, width, h);
 
                                if (filterBrush != null)
                                {
                                    visual.FillRectangle(filterBrush, rect);
                                }
                                else
                                {
                                    visual.FillRectangle(isUp ? _deltaPlusBrush : _deltaMinusBrush, rect);
                                }
                            }
                            else
                            {
                                if (filterBrush != null)
                                {
                                    visual.DrawLine(filterPen, x, y, x, y + h);
                                }
                                else
                                {
                                    visual.DrawLine(isUp ? _deltaPlusPen : _deltaMinusPen, x, y, x, y + h);
                                }
                            }
                        }
                    }
                    break;
            }
        }
 
        public override List<IndicatorValueInfo> GetValues(int cursorPos)
        {
            var info = new List<IndicatorValueInfo>();
 
            var cluster = DataProvider.GetCluster(cursorPos);
 
            if (cluster == null)
            {
                return info;
            }
 
            var s = Canvas.FormatValue((double)cluster.Delta);
 
            info.Add(new IndicatorValueInfo(s, Canvas.Theme.ChartFontBrush));
 
            return info;
        }
 
        public override void GetLabels(ref List<IndicatorLabelInfo> labels)
        {
            if (DataProvider.Count <= Canvas.Start)
            {
                return;
            }
 
            var cluster = DataProvider.GetCluster(DataProvider.Count - 1 - Canvas.Start);
 
            if (cluster == null)
            {
                return;
            }
 
            var delta = Minimize ? Math.Abs(cluster.Delta) : cluster.Delta;
 
            labels.Add(new IndicatorLabelInfo((double)delta, cluster.Delta > 0 ? _deltaPlusColor : _deltaMinusColor));
        }
 
        public override bool CheckAlert(double value, int distance, ref int lastIndex, ref double lastValue)
        {
            if (DataProvider.Count == lastIndex && value == lastValue)
            {
                return false;
            }
 
            var cluster = DataProvider.GetCluster(DataProvider.Count - 1);
 
            if (cluster == null)
            {
                return false;
            }
 
            var result = false;
 
            var delta = (double)cluster.Delta;
 
            if (value > 0 && delta >= value - distance)
            {
                result = true;
            }
            else if (value < 0 && delta <= value + distance)
            {
                result = true;
            }
 
            if (result == false)
            {
                return false;
            }
 
            lastIndex = DataProvider.Count;
            lastValue = value;
 
            return true;
        }
 
        public override void ApplyColors(IChartTheme theme)
        {
            DeltaPlusColor = theme.PaletteColor6;
            DeltaMinusColor = theme.PaletteColor7;
 
            base.ApplyColors(theme);
        }
 
        public override void CopyTemplate(IndicatorBase indicator, bool style)
        {
            var i = (DeltaIndicator)indicator;
 
            DeltaPlusColor = i.DeltaPlusColor;
            DeltaMinusColor = i.DeltaMinusColor;
 
            Type = i.Type;
            Minimize = i.Minimize;
 
            MaxDeltaParam.Copy(i.MaxDeltaParam);
 
            Filter1MinParam.Copy(i.Filter1MinParam);
            Filter1MaxParam.Copy(i.Filter1MaxParam);
 
            OnPropertyChanged(nameof(Filter1Min));
            OnPropertyChanged(nameof(Filter1Max));
 
            Filter1PlusColor = i.Filter1PlusColor;
            Filter1MinusColor = i.Filter1MinusColor;
 
            Filter1Alert.Copy(i.Filter1Alert, !style);
 
            OnPropertyChanged(nameof(Filter1Alert));
 
            Filter2MinParam.Copy(i.Filter2MinParam);
            Filter2MaxParam.Copy(i.Filter2MaxParam);
 
            OnPropertyChanged(nameof(Filter2Min));
            OnPropertyChanged(nameof(Filter2Max));
 
            Filter2PlusColor = i.Filter2PlusColor;
            Filter2MinusColor = i.Filter2MinusColor;
 
            Filter2Alert.Copy(i.Filter2Alert, !style);
 
            OnPropertyChanged(nameof(Filter2Alert));
 
            Filter3MinParam.Copy(i.Filter3MinParam);
            Filter3MaxParam.Copy(i.Filter3MaxParam);
 
            OnPropertyChanged(nameof(Filter3Min));
            OnPropertyChanged(nameof(Filter3Max));
 
            Filter3PlusColor = i.Filter3PlusColor;
            Filter3MinusColor = i.Filter3MinusColor;
 
            Filter3Alert.Copy(i.Filter3Alert, !style);
 
            OnPropertyChanged(nameof(Filter3Alert));
 
            base.CopyTemplate(indicator, style);
        }
    }
}