Delta

Тема в разделе "Примеры индикаторов", создана пользователем Support, 6 июл 2019.

  1. Support

    Support Администратор
    Команда форума

    Регистрация:
    5 сен 2015
    Сообщения:
    984
    Симпатии:
    185
    Код индикатора Delta
    1. //------------------------------------------------------------------------------
    2. //
    3. // Индикатор Delta. Copyright (c) 2019 Ilya Smirnov. All rights reserved.
    4. //
    5. //------------------------------------------------------------------------------
    6.  
    7. using System;
    8. using System.Collections.Generic;
    9. using System.ComponentModel;
    10. using System.Runtime.Serialization;
    11. using System.Windows;
    12. using System.Windows.Media;
    13. using TigerTrade.Chart.Alerts;
    14. using TigerTrade.Chart.Base;
    15. using TigerTrade.Chart.Indicators.Common;
    16. using TigerTrade.Chart.Indicators.Enums;
    17. using TigerTrade.Chart.Properties;
    18. using TigerTrade.Core.UI.Converters;
    19. using TigerTrade.Dx;
    20.  
    21. namespace TigerTrade.Chart.Indicators.Custom
    22. {
    23.     [TypeConverter(typeof(EnumDescriptionTypeConverter))]
    24.     [DataContract(Name = "DeltaViewType", Namespace = "http://schemas.datacontract.org/2004/07/TigerTrade.Chart.Indicators.Custom")]
    25.     public enum DeltaViewType
    26.     {
    27.         [EnumMember(Value = "Columns"), Description("Колонки")]
    28.         Columns,
    29.         [EnumMember(Value = "Candles"), Description("Свечи")]
    30.         Candles
    31.     }
    32.  
    33.     [DataContract(Name = "DeltaIndicator", Namespace = "http://schemas.datacontract.org/2004/07/TigerTrade.Chart.Indicators.Custom")]
    34.     [Indicator("X_Delta", "*Delta", false, Type = typeof(DeltaIndicator))]
    35.     internal sealed class DeltaIndicator : IndicatorBase
    36.     {
    37.         private XBrush _deltaPlusBrush;
    38.  
    39.         private XPen _deltaPlusPen;
    40.  
    41.         private XColor _deltaPlusColor;
    42.  
    43.         [DataMember(Name = "DeltaPlusColor")]
    44.         [Category("Стиль"), DisplayName("Delta+")]
    45.         public XColor DeltaPlusColor
    46.         {
    47.             get => _deltaPlusColor;
    48.             set
    49.             {
    50.                 if (value == _deltaPlusColor)
    51.                 {
    52.                     return;
    53.                 }
    54.  
    55.                 _deltaPlusColor = value;
    56.  
    57.                 _deltaPlusBrush = new XBrush(_deltaPlusColor);
    58.  
    59.                 _deltaPlusPen = new XPen(_deltaPlusBrush, 1);
    60.  
    61.                 OnPropertyChanged();
    62.             }
    63.         }
    64.  
    65.         private XBrush _deltaMinusBrush;
    66.  
    67.         private XPen _deltaMinusPen;
    68.  
    69.         private XColor _deltaMinusColor;
    70.  
    71.         [DataMember(Name = "DeltaMinusColor")]
    72.         [Category("Стиль"), DisplayName("Delta-")]
    73.         public XColor DeltaMinusColor
    74.         {
    75.             get => _deltaMinusColor;
    76.             set
    77.             {
    78.                 if (value == _deltaMinusColor)
    79.                 {
    80.                     return;
    81.                 }
    82.  
    83.                 _deltaMinusColor = value;
    84.  
    85.                 _deltaMinusBrush = new XBrush(_deltaMinusColor);
    86.  
    87.                 _deltaMinusPen = new XPen(_deltaMinusBrush, 1);
    88.  
    89.                 OnPropertyChanged();
    90.             }
    91.         }
    92.  
    93.         private DeltaViewType _type;
    94.  
    95.         [DataMember(Name = "DeltaType"), DefaultValue(DeltaViewType.Columns)]
    96.         [Category("Параметры"), DisplayName("Тип")]
    97.         public DeltaViewType Type
    98.         {
    99.             get => _type;
    100.             set
    101.             {
    102.                 if (value == _type)
    103.                 {
    104.                     return;
    105.                 }
    106.  
    107.                 _type = value;
    108.  
    109.                 OnPropertyChanged();
    110.             }
    111.         }
    112.  
    113.         private bool _minimize;
    114.  
    115.         [DataMember(Name = "Minimize"), DefaultValue(false)]
    116.         [Category("Параметры"), DisplayName("Минимизировать")]
    117.         public bool Minimize
    118.         {
    119.             get => _minimize;
    120.             set
    121.             {
    122.                 if (value == _minimize)
    123.                 {
    124.                     return;
    125.                 }
    126.  
    127.                 _minimize = value;
    128.  
    129.                 OnPropertyChanged();
    130.             }
    131.         }
    132.  
    133.         private IndicatorNullIntParam _maxDeltaParam;
    134.  
    135.         [DataMember(Name = "MaxDeltaParam")]
    136.         public IndicatorNullIntParam MaxDeltaParam
    137.         {
    138.             get => _maxDeltaParam ?? (_maxDeltaParam = new IndicatorNullIntParam(null));
    139.             set => _maxDeltaParam = value;
    140.         }
    141.  
    142.         [DefaultValue(null)]
    143.         [Category("Параметры"), DisplayName("Макс. дельта")]
    144.         public int? MaxDelta
    145.         {
    146.             get => MaxDeltaParam.Get(SettingsLongKey);
    147.             set
    148.             {
    149.                 if (!MaxDeltaParam.Set(SettingsLongKey, value, 0))
    150.                 {
    151.                     return;
    152.                 }
    153.  
    154.                 OnPropertyChanged();
    155.             }
    156.         }
    157.  
    158.         private IndicatorNullIntParam _filter1MinParam;
    159.  
    160.         [DataMember(Name = "Filter1MinParam")]
    161.         public IndicatorNullIntParam Filter1MinParam
    162.         {
    163.             get => _filter1MinParam ?? (_filter1MinParam = new IndicatorNullIntParam(null));
    164.             set => _filter1MinParam = value;
    165.         }
    166.  
    167.         [DefaultValue(null)]
    168.         [Category("Фильтр 1"), DisplayName("Минимум")]
    169.         public int? Filter1Min
    170.         {
    171.             get => Filter1MinParam.Get(SettingsLongKey);
    172.             set
    173.             {
    174.                 if (!Filter1MinParam.Set(SettingsLongKey, value, 0))
    175.                 {
    176.                     return;
    177.                 }
    178.  
    179.                 OnPropertyChanged();
    180.             }
    181.         }
    182.  
    183.         private IndicatorNullIntParam _filter1MaxParam;
    184.  
    185.         [DataMember(Name = "Filter1MaxParam")]
    186.         public IndicatorNullIntParam Filter1MaxParam
    187.         {
    188.             get => _filter1MaxParam ?? (_filter1MaxParam = new IndicatorNullIntParam(null));
    189.             set => _filter1MaxParam = value;
    190.         }
    191.  
    192.         [DefaultValue(null)]
    193.         [Category("Фильтр 1"), DisplayName("Максимум")]
    194.         public int? Filter1Max
    195.         {
    196.             get => Filter1MaxParam.Get(SettingsLongKey);
    197.             set
    198.             {
    199.                 if (!Filter1MaxParam.Set(SettingsLongKey, value, 0))
    200.                 {
    201.                     return;
    202.                 }
    203.  
    204.                 OnPropertyChanged();
    205.             }
    206.         }
    207.  
    208.         private XBrush _filter1PlusBrush;
    209.  
    210.         private XPen _filter1PlusPen;
    211.  
    212.         private XColor _filter1PlusColor;
    213.  
    214.         [DataMember(Name = "Filter1PlusColor")]
    215.         [Category("Фильтр 1"), DisplayName("Цвет+")]
    216.         public XColor Filter1PlusColor
    217.         {
    218.             get => _filter1PlusColor;
    219.             set
    220.             {
    221.                 if (value == _filter1PlusColor)
    222.                 {
    223.                     return;
    224.                 }
    225.  
    226.                 _filter1PlusColor = value;
    227.  
    228.                 _filter1PlusBrush = new XBrush(_filter1PlusColor);
    229.                 _filter1PlusPen = new XPen(_filter1PlusBrush, 1);
    230.  
    231.                 OnPropertyChanged();
    232.             }
    233.         }
    234.  
    235.         private XBrush _filter1MinusBrush;
    236.  
    237.         private XPen _filter1MinusPen;
    238.  
    239.         private XColor _filter1MinusColor;
    240.  
    241.         [DataMember(Name = "Filter1MinusColor")]
    242.         [Category("Фильтр 1"), DisplayName("Цвет-")]
    243.         public XColor Filter1MinusColor
    244.         {
    245.             get => _filter1MinusColor;
    246.             set
    247.             {
    248.                 if (value == _filter1MinusColor)
    249.                 {
    250.                     return;
    251.                 }
    252.  
    253.                 _filter1MinusColor = value;
    254.  
    255.                 _filter1MinusBrush = new XBrush(_filter1MinusColor);
    256.                 _filter1MinusPen = new XPen(_filter1MinusBrush, 1);
    257.  
    258.                 OnPropertyChanged();
    259.             }
    260.         }
    261.  
    262.         private ChartAlertSettings _filter1Alert;
    263.  
    264.         [DataMember(Name = "Filter1Alert")]
    265.         [Category("Фильтр 1"), DisplayName("Оповещение")]
    266.         public ChartAlertSettings Filter1Alert
    267.         {
    268.             get => _filter1Alert ?? (_filter1Alert = new ChartAlertSettings());
    269.             set
    270.             {
    271.                 if (Equals(value, _filter1Alert))
    272.                 {
    273.                     return;
    274.                 }
    275.  
    276.                 _filter1Alert = value;
    277.  
    278.                 OnPropertyChanged();
    279.             }
    280.         }
    281.  
    282.         private IndicatorNullIntParam _filter2MinParam;
    283.  
    284.         [DataMember(Name = "Filter2MinParam")]
    285.         public IndicatorNullIntParam Filter2MinParam
    286.         {
    287.             get => _filter2MinParam ?? (_filter2MinParam = new IndicatorNullIntParam(null));
    288.             set => _filter2MinParam = value;
    289.         }
    290.  
    291.         [DefaultValue(null)]
    292.         [Category("Фильтр 2"), DisplayName("Минимум")]
    293.         public int? Filter2Min
    294.         {
    295.             get => Filter2MinParam.Get(SettingsLongKey);
    296.             set
    297.             {
    298.                 if (!Filter2MinParam.Set(SettingsLongKey, value, 0))
    299.                 {
    300.                     return;
    301.                 }
    302.  
    303.                 OnPropertyChanged();
    304.             }
    305.         }
    306.  
    307.         private IndicatorNullIntParam _filter2MaxParam;
    308.  
    309.         [DataMember(Name = "Filter2MaxParam")]
    310.         public IndicatorNullIntParam Filter2MaxParam
    311.         {
    312.             get => _filter2MaxParam ?? (_filter2MaxParam = new IndicatorNullIntParam(null));
    313.             set => _filter2MaxParam = value;
    314.         }
    315.  
    316.         [DefaultValue(null)]
    317.         [Category("Фильтр 2"), DisplayName("Максимум")]
    318.         public int? Filter2Max
    319.         {
    320.             get => Filter2MaxParam.Get(SettingsLongKey);
    321.             set
    322.             {
    323.                 if (!Filter2MaxParam.Set(SettingsLongKey, value, 0))
    324.                 {
    325.                     return;
    326.                 }
    327.  
    328.                 OnPropertyChanged();
    329.             }
    330.         }
    331.  
    332.         private XBrush _filter2PlusBrush;
    333.  
    334.         private XPen _filter2PlusPen;
    335.  
    336.         private XColor _filter2PlusColor;
    337.  
    338.         [DataMember(Name = "Filter2PlusColor")]
    339.         [Category("Фильтр 2"), DisplayName("Цвет+")]
    340.         public XColor Filter2PlusColor
    341.         {
    342.             get => _filter2PlusColor;
    343.             set
    344.             {
    345.                 if (value == _filter2PlusColor)
    346.                 {
    347.                     return;
    348.                 }
    349.  
    350.                 _filter2PlusColor = value;
    351.  
    352.                 _filter2PlusBrush = new XBrush(_filter2PlusColor);
    353.                 _filter2PlusPen = new XPen(_filter2PlusBrush, 1);
    354.  
    355.                 OnPropertyChanged();
    356.             }
    357.         }
    358.  
    359.         private XBrush _filter2MinusBrush;
    360.  
    361.         private XPen _filter2MinusPen;
    362.  
    363.         private XColor _filter2MinusColor;
    364.  
    365.         [DataMember(Name = "Filter2MinusColor")]
    366.         [Category("Фильтр 2"), DisplayName("Цвет-")]
    367.         public XColor Filter2MinusColor
    368.         {
    369.             get => _filter2MinusColor;
    370.             set
    371.             {
    372.                 if (value == _filter2MinusColor)
    373.                 {
    374.                     return;
    375.                 }
    376.  
    377.                 _filter2MinusColor = value;
    378.  
    379.                 _filter2MinusBrush = new XBrush(_filter2MinusColor);
    380.                 _filter2MinusPen = new XPen(_filter2MinusBrush, 1);
    381.  
    382.                 OnPropertyChanged();
    383.             }
    384.         }
    385.  
    386.         private ChartAlertSettings _filter2Alert;
    387.  
    388.         [DataMember(Name = "Filter2Alert")]
    389.         [Category("Фильтр 2"), DisplayName("Оповещение")]
    390.         public ChartAlertSettings Filter2Alert
    391.         {
    392.             get => _filter2Alert ?? (_filter2Alert = new ChartAlertSettings());
    393.             set
    394.             {
    395.                 if (Equals(value, _filter2Alert))
    396.                 {
    397.                     return;
    398.                 }
    399.  
    400.                 _filter2Alert = value;
    401.  
    402.                 OnPropertyChanged();
    403.             }
    404.         }
    405.  
    406.         private IndicatorNullIntParam _filter3MinParam;
    407.  
    408.         [DataMember(Name = "Filter3MinParam")]
    409.         public IndicatorNullIntParam Filter3MinParam
    410.         {
    411.             get => _filter3MinParam ?? (_filter3MinParam = new IndicatorNullIntParam(null));
    412.             set => _filter3MinParam = value;
    413.         }
    414.  
    415.         [DefaultValue(null)]
    416.         [Category("Фильтр 3"), DisplayName("Минимум")]
    417.         public int? Filter3Min
    418.         {
    419.             get => Filter3MinParam.Get(SettingsLongKey);
    420.             set
    421.             {
    422.                 if (!Filter3MinParam.Set(SettingsLongKey, value, 0))
    423.                 {
    424.                     return;
    425.                 }
    426.  
    427.                 OnPropertyChanged();
    428.             }
    429.         }
    430.  
    431.         private IndicatorNullIntParam _filter3MaxParam;
    432.  
    433.         [DataMember(Name = "Filter3MaxParam")]
    434.         public IndicatorNullIntParam Filter3MaxParam
    435.         {
    436.             get => _filter3MaxParam ?? (_filter3MaxParam = new IndicatorNullIntParam(null));
    437.             set => _filter3MaxParam = value;
    438.         }
    439.  
    440.         [DefaultValue(null)]
    441.         [Category("Фильтр 3"), DisplayName("Максимум")]
    442.         public int? Filter3Max
    443.         {
    444.             get => Filter3MaxParam.Get(SettingsLongKey);
    445.             set
    446.             {
    447.                 if (!Filter3MaxParam.Set(SettingsLongKey, value, 0))
    448.                 {
    449.                     return;
    450.                 }
    451.  
    452.                 OnPropertyChanged();
    453.             }
    454.         }
    455.  
    456.         private XBrush _filter3PlusBrush;
    457.  
    458.         private XPen _filter3PlusPen;
    459.  
    460.         private XColor _filter3PlusColor;
    461.  
    462.         [DataMember(Name = "Filter3PlusColor")]
    463.         [Category("Фильтр 3"), DisplayName("Цвет+")]
    464.         public XColor Filter3PlusColor
    465.         {
    466.             get => _filter3PlusColor;
    467.             set
    468.             {
    469.                 if (value == _filter3PlusColor)
    470.                 {
    471.                     return;
    472.                 }
    473.  
    474.                 _filter3PlusColor = value;
    475.  
    476.                 _filter3PlusBrush = new XBrush(_filter3PlusColor);
    477.                 _filter3PlusPen = new XPen(_filter3PlusBrush, 1);
    478.  
    479.                 OnPropertyChanged();
    480.             }
    481.         }
    482.  
    483.         private XBrush _filter3MinusBrush;
    484.  
    485.         private XPen _filter3MinusPen;
    486.  
    487.         private XColor _filter3MinusColor;
    488.  
    489.         [DataMember(Name = "Filter3MinusColor")]
    490.         [Category("Фильтр 3"), DisplayName("Цвет-")]
    491.         public XColor Filter3MinusColor
    492.         {
    493.             get => _filter3MinusColor;
    494.             set
    495.             {
    496.                 if (value == _filter3MinusColor)
    497.                 {
    498.                     return;
    499.                 }
    500.  
    501.                 _filter3MinusColor = value;
    502.  
    503.                 _filter3MinusBrush = new XBrush(_filter3MinusColor);
    504.                 _filter3MinusPen = new XPen(_filter3MinusBrush, 1);
    505.  
    506.                 OnPropertyChanged();
    507.             }
    508.         }
    509.  
    510.         private ChartAlertSettings _filter3Alert;
    511.  
    512.         [DataMember(Name = "Filter3Alert")]
    513.         [Category("Фильтр 3"), DisplayName("Оповещение")]
    514.         public ChartAlertSettings Filter3Alert
    515.         {
    516.             get => _filter3Alert ?? (_filter3Alert = new ChartAlertSettings());
    517.             set
    518.             {
    519.                 if (Equals(value, _filter3Alert))
    520.                 {
    521.                     return;
    522.                 }
    523.  
    524.                 _filter3Alert = value;
    525.  
    526.                 OnPropertyChanged();
    527.             }
    528.         }
    529.  
    530.         [Browsable(false)]
    531.         public override IndicatorCalculation Calculation => IndicatorCalculation.OnEachTick;
    532.  
    533.         public override bool IntegerValues => true;
    534.  
    535.         private int _filter1SignalIndex;
    536.         private int _filter2SignalIndex;
    537.         private int _filter3SignalIndex;
    538.  
    539.         public DeltaIndicator()
    540.         {
    541.             DeltaPlusColor = Color.FromArgb(255, 30, 144, 255);
    542.             DeltaMinusColor = Color.FromArgb(255, 178, 34, 34);
    543.  
    544.             Type = DeltaViewType.Columns;
    545.  
    546.             Minimize = false;
    547.  
    548.             Filter1PlusColor = Colors.Orange;
    549.             Filter1MinusColor = Colors.Orange;
    550.  
    551.             Filter2PlusColor = Colors.Orange;
    552.             Filter2MinusColor = Colors.Orange;
    553.  
    554.             Filter3PlusColor = Colors.Orange;
    555.             Filter3MinusColor = Colors.Orange;
    556.  
    557.             _filter1SignalIndex = -1;
    558.             _filter2SignalIndex = -1;
    559.             _filter3SignalIndex = -1;
    560.         }
    561.  
    562.         protected override void Execute()
    563.         {
    564.             if (ClearData)
    565.             {
    566.                 _filter1SignalIndex = -1;
    567.                 _filter2SignalIndex = -1;
    568.                 _filter3SignalIndex = -1;
    569.             }
    570.  
    571.             var index = DataProvider.Count;
    572.  
    573.             var cluster = DataProvider.GetCluster(index - 1);
    574.  
    575.             if (cluster == null)
    576.             {
    577.                 return;
    578.             }
    579.  
    580.             var realDelta = cluster.Delta;
    581.             var absDelta = Math.Abs(realDelta);
    582.  
    583.             if (Filter1Alert.IsActive && _filter1SignalIndex < index)
    584.             {
    585.                 var min = Filter1Min ?? -1;
    586.                 var max = Filter1Max ?? -1;
    587.  
    588.                 if (min >= 0 && absDelta >= min && (max < 0 || absDelta <= max))
    589.                 {
    590.                     _filter1SignalIndex = index;
    591.  
    592.                     AddAlert(Filter1Alert,
    593.                         string.Format(Resources.ChartIndicatorsDeltaFilterAlert, 1,
    594.                             DataProvider.Symbol.FormatSizeFull(realDelta)));
    595.                 }
    596.             }
    597.  
    598.             if (Filter2Alert.IsActive && _filter2SignalIndex < index)
    599.             {
    600.                 var min = Filter2Min ?? -1;
    601.                 var max = Filter2Max ?? -1;
    602.  
    603.                 if (min >= 0 && absDelta >= min && (max < 0 || absDelta <= max))
    604.                 {
    605.                     _filter2SignalIndex = index;
    606.  
    607.                     AddAlert(Filter2Alert,
    608.                         string.Format(Resources.ChartIndicatorsDeltaFilterAlert, 2,
    609.                             DataProvider.Symbol.FormatSizeFull(realDelta)));
    610.                 }
    611.             }
    612.  
    613.             if (Filter3Alert.IsActive && _filter3SignalIndex < index)
    614.             {
    615.                 var min = Filter3Min ?? -1;
    616.                 var max = Filter3Max ?? -1;
    617.  
    618.                 if (min >= 0 && absDelta >= min && (max < 0 || absDelta <= max))
    619.                 {
    620.                     _filter3SignalIndex = index;
    621.  
    622.                     AddAlert(Filter3Alert,
    623.                         string.Format(Resources.ChartIndicatorsDeltaFilterAlert, 3,
    624.                             DataProvider.Symbol.FormatSizeFull(realDelta)));
    625.                 }
    626.             }
    627.         }
    628.  
    629.         public override bool GetMinMax(out double min, out double max)
    630.         {
    631.             min = double.MaxValue;
    632.             max = double.MinValue;
    633.  
    634.             if (Type == DeltaViewType.Candles)
    635.             {
    636.                 for (var i = 0; i < Canvas.Count; i++)
    637.                 {
    638.                     var index = Canvas.GetIndex(i);
    639.  
    640.                     var cluster = DataProvider.GetCluster(index);
    641.  
    642.                     if (cluster == null || cluster.Delta == 0)
    643.                     {
    644.                         continue;
    645.                     }
    646.  
    647.                     var deltaHigh = (double)cluster.DeltaHigh;
    648.                     var deltaLow = (double)cluster.DeltaLow;
    649.  
    650.                     if (Minimize && cluster.Delta < 0)
    651.                     {
    652.                         max = Math.Max(max, -deltaLow);
    653.                         min = Math.Min(min, -deltaHigh);
    654.  
    655.                     }
    656.                     else
    657.                     {
    658.                         min = Math.Min(min, deltaLow);
    659.                         max = Math.Max(max, deltaHigh);
    660.                     }
    661.                 }
    662.             }
    663.             else
    664.             {
    665.                 for (var i = 0; i < Canvas.Count; i++)
    666.                 {
    667.                     var index = Canvas.GetIndex(i);
    668.  
    669.                     var cluster = DataProvider.GetCluster(index);
    670.  
    671.                     if (cluster == null || cluster.Delta == 0)
    672.                     {
    673.                         continue;
    674.                     }
    675.  
    676.                     var delta = (double)cluster.Delta;
    677.  
    678.                     if (Minimize)
    679.                     {
    680.                         max = Math.Max(max, Math.Abs(delta));
    681.                     }
    682.                     else
    683.                     {
    684.                         min = Math.Min(min, delta);
    685.                         max = Math.Max(max, delta);
    686.                     }
    687.                 }
    688.  
    689.                 if (Minimize)
    690.                 {
    691.                     min = 0.0;
    692.                 }
    693.             }
    694.  
    695.             var maxDelta = MaxDelta ?? -1;
    696.  
    697.             if (maxDelta >= 0 && max > maxDelta)
    698.             {
    699.                 max = maxDelta;
    700.             }
    701.  
    702.             if (maxDelta >= 0 && min < -maxDelta)
    703.             {
    704.                 min = -maxDelta;
    705.             }
    706.  
    707.             return true;
    708.         }
    709.  
    710.         public override void Render(DxVisualQueue visual)
    711.         {
    712.             var min1 = Filter1Min ?? -1;
    713.             var max1 = Filter1Max ?? -1;
    714.             var min2 = Filter2Min ?? -1;
    715.             var max2 = Filter2Max ?? -1;
    716.             var min3 = Filter3Min ?? -1;
    717.             var max3 = Filter3Max ?? -1;
    718.  
    719.             var maxDelta = MaxDelta ?? -1;
    720.             var maxPoint = (int)GetY((double)maxDelta);
    721.             var minPoint = (int)GetY((double)-maxDelta);
    722.  
    723.             var zeroPoint = (int)GetY(0.0);
    724.  
    725.             switch (Type)
    726.             {
    727.                 case DeltaViewType.Candles:
    728.                     {
    729.                         var width = (int)(Canvas.ColumnWidth * Canvas.ColumnPercent + 0.4);
    730.                         var halfWith = Math.Max((int)(width / 2.0), 1.0);
    731.  
    732.                         var openY = zeroPoint;
    733.  
    734.                         for (var i = 0; i < Canvas.Count; i++)
    735.                         {
    736.                             var index = Canvas.GetIndex(i);
    737.  
    738.                             var cluster = DataProvider.GetCluster(index);
    739.  
    740.                             if (cluster == null || cluster.Delta == 0)
    741.                             {
    742.                                 continue;
    743.                             }
    744.  
    745.                             var delta = cluster.Delta;
    746.  
    747.                             var isUp = delta > 0;
    748.  
    749.                             var centerX = (int)Canvas.GetX(index);
    750.                             var highY = (int)GetY(cluster.DeltaHigh);
    751.                             var lowY = (int)GetY(cluster.DeltaLow);
    752.                             var closeY = (int)GetY(delta);
    753.  
    754.                             if (Minimize && delta < 0)
    755.                             {
    756.                                 highY = (int) GetY(-cluster.DeltaLow);
    757.                                 lowY = (int) GetY(-cluster.DeltaHigh);
    758.                                 closeY = (int) GetY(-delta);
    759.                             }
    760.  
    761.                             if (maxDelta >= 0)
    762.                             {
    763.                                 if (delta > 0 || Minimize)
    764.                                 {
    765.                                     closeY = Math.Max(closeY, maxPoint);
    766.                                     highY = Math.Max(highY, maxPoint);
    767.                                     lowY = Math.Min(lowY, minPoint);
    768.                                 }
    769.                                 else
    770.                                 {
    771.                                     closeY = Math.Min(closeY, minPoint);
    772.                                     highY = Math.Max(highY, maxPoint);
    773.                                     lowY = Math.Min(lowY, minPoint);
    774.                                 }
    775.                             }
    776.  
    777.                             var topY = Math.Min(openY, closeY);
    778.                             var bottomY = Math.Max(openY, closeY);
    779.  
    780.                             var height = bottomY - topY;
    781.  
    782.                             var backBrush = isUp ? _deltaPlusBrush : _deltaMinusBrush;
    783.                             var backPen = isUp ? _deltaPlusPen : _deltaMinusPen;
    784.  
    785.                             var absDelta = Math.Abs(delta);
    786.  
    787.                             if (min1 >= 0 && absDelta >= min1 && (max1 < 0 || absDelta <= max1))
    788.                             {
    789.                                 if (delta > 0)
    790.                                 {
    791.                                     backBrush = _filter1PlusBrush;
    792.                                     backPen = _filter1PlusPen;
    793.                                 }
    794.                                 else
    795.                                 {
    796.                                     backBrush = _filter1MinusBrush;
    797.                                     backPen = _filter1MinusPen;
    798.                                 }
    799.                             }
    800.                             else if (min2 >= 0 && absDelta >= min2 && (max2 < 0 || absDelta <= max2))
    801.                             {
    802.                                 if (delta > 0)
    803.                                 {
    804.                                     backBrush = _filter2PlusBrush;
    805.                                     backPen = _filter2PlusPen;
    806.                                 }
    807.                                 else
    808.                                 {
    809.                                     backBrush = _filter2MinusBrush;
    810.                                     backPen = _filter2MinusPen;
    811.                                 }
    812.                             }
    813.                             else if (min3 >= 0 && absDelta >= min3 && (max3 < 0 || absDelta <= max3))
    814.                             {
    815.                                 if (delta > 0)
    816.                                 {
    817.                                     backBrush = _filter3PlusBrush;
    818.                                     backPen = _filter3PlusPen;
    819.                                 }
    820.                                 else
    821.                                 {
    822.                                     backBrush = _filter3MinusBrush;
    823.                                     backPen = _filter3MinusPen;
    824.                                 }
    825.                             }
    826.  
    827.                             if (height == 0 || width <= 1)
    828.                             {
    829.                                 if (highY == lowY)
    830.                                 {
    831.                                     lowY++;
    832.                                 }
    833.  
    834.                                 visual.DrawLine(backPen,
    835.                                         new Point(centerX, highY),
    836.                                         new Point(centerX, lowY));
    837.                             }
    838.                             else
    839.                             {
    840.                                 visual.DrawLine(backPen,
    841.                                     new Point(centerX, highY),
    842.                                     new Point(centerX, topY));
    843.  
    844.                                 visual.DrawLine(backPen,
    845.                                     new Point(centerX, bottomY),
    846.                                     new Point(centerX, lowY));
    847.                             }
    848.  
    849.                             if (width > 1)
    850.                             {
    851.                                 if (height == 0)
    852.                                 {
    853.                                     visual.DrawLine(backPen,
    854.                                         new Point(centerX - halfWith, topY),
    855.                                         new Point(centerX + halfWith + 1, topY));
    856.                                 }
    857.                                 else
    858.                                 {
    859.                                     visual.FillRectangle(backBrush,
    860.                                         new Rect(centerX - halfWith, topY, halfWith*2 + 1, height));
    861.                                 }
    862.                             }
    863.                         }
    864.                     }
    865.  
    866.                     break;
    867.  
    868.                 case DeltaViewType.Columns:
    869.                     {
    870.                         var width = Math.Max(Canvas.ColumnWidth - 1, 1);
    871.  
    872.                         for (var i = 0; i < Canvas.Count; i++)
    873.                         {
    874.                             var index = Canvas.GetIndex(i);
    875.  
    876.                             var cluster = DataProvider.GetCluster(index);
    877.  
    878.                             if (cluster == null || cluster.Delta == 0)
    879.                             {
    880.                                 continue;
    881.                             }
    882.  
    883.                             var delta = cluster.Delta;
    884.  
    885.                             var x = Canvas.GetX(index);
    886.                             var y = GetY(Minimize ? Math.Abs(delta) : delta);
    887.  
    888.                             if (maxDelta >= 0)
    889.                             {
    890.                                 if (Minimize)
    891.                                 {
    892.                                     y = Math.Max(y, maxPoint);
    893.                                 }
    894.                                 else
    895.                                 {
    896.                                     y = delta > 0 ? Math.Max(y, maxPoint) : Math.Min(y, minPoint);
    897.                                 }
    898.                             }
    899.  
    900.                             var h = zeroPoint - (int)y;
    901.  
    902.                             if (h < 0.0)
    903.                             {
    904.                                 y += h;
    905.                                 h = -h;
    906.                             }
    907.  
    908.                             if (Minimize || delta > 0)
    909.                             {
    910.                                 if (h < 1)
    911.                                 {
    912.                                     y = zeroPoint - 1;
    913.                                     h = 1;
    914.                                 }
    915.                             }
    916.                             else
    917.                             {
    918.                                 if (h < 1)
    919.                                 {
    920.                                     y = zeroPoint;
    921.                                     h = 1;
    922.                                 }
    923.                             }
    924.  
    925.                             var isUp = delta > 0;
    926.  
    927.                             XBrush filterBrush = null;
    928.                             XPen filterPen = null;
    929.  
    930.                             var absDelta = Math.Abs(delta);
    931.  
    932.                             if (min1 >= 0 && absDelta >= min1 && (max1 < 0 || absDelta <= max1))
    933.                             {
    934.                                 if (delta > 0)
    935.                                 {
    936.                                     filterBrush = _filter1PlusBrush;
    937.                                     filterPen = _filter1PlusPen;
    938.                                 }
    939.                                 else
    940.                                 {
    941.                                     filterBrush = _filter1MinusBrush;
    942.                                     filterPen = _filter1MinusPen;
    943.                                 }
    944.                             }
    945.                             else if (min2 >= 0 && absDelta >= min2 && (max2 < 0 || absDelta <= max2))
    946.                             {
    947.                                 if (delta > 0)
    948.                                 {
    949.                                     filterBrush = _filter2PlusBrush;
    950.                                     filterPen = _filter2PlusPen;
    951.                                 }
    952.                                 else
    953.                                 {
    954.                                     filterBrush = _filter2MinusBrush;
    955.                                     filterPen = _filter2MinusPen;
    956.                                 }
    957.                             }
    958.                             else if (min3 >= 0 && absDelta >= min3 && (max3 < 0 || absDelta <= max3))
    959.                             {
    960.                                 if (delta > 0)
    961.                                 {
    962.                                     filterBrush = _filter3PlusBrush;
    963.                                     filterPen = _filter3PlusPen;
    964.                                 }
    965.                                 else
    966.                                 {
    967.                                     filterBrush = _filter3MinusBrush;
    968.                                     filterPen = _filter3MinusPen;
    969.                                 }
    970.                             }
    971.  
    972.                             if (width > 1.0)
    973.                             {
    974.                                 var rect = new Rect(x - width / 2.0, y, width, h);
    975.  
    976.                                 if (filterBrush != null)
    977.                                 {
    978.                                     visual.FillRectangle(filterBrush, rect);
    979.                                 }
    980.                                 else
    981.                                 {
    982.                                     visual.FillRectangle(isUp ? _deltaPlusBrush : _deltaMinusBrush, rect);
    983.                                 }
    984.                             }
    985.                             else
    986.                             {
    987.                                 if (filterBrush != null)
    988.                                 {
    989.                                     visual.DrawLine(filterPen, x, y, x, y + h);
    990.                                 }
    991.                                 else
    992.                                 {
    993.                                     visual.DrawLine(isUp ? _deltaPlusPen : _deltaMinusPen, x, y, x, y + h);
    994.                                 }
    995.                             }
    996.                         }
    997.                     }
    998.                     break;
    999.             }
    1000.         }
    1001.  
    1002.         public override List<IndicatorValueInfo> GetValues(int cursorPos)
    1003.         {
    1004.             var info = new List<IndicatorValueInfo>();
    1005.  
    1006.             var cluster = DataProvider.GetCluster(cursorPos);
    1007.  
    1008.             if (cluster == null)
    1009.             {
    1010.                 return info;
    1011.             }
    1012.  
    1013.             var s = Canvas.FormatValue((double)cluster.Delta);
    1014.  
    1015.             info.Add(new IndicatorValueInfo(s, Canvas.Theme.ChartFontBrush));
    1016.  
    1017.             return info;
    1018.         }
    1019.  
    1020.         public override void GetLabels(ref List<IndicatorLabelInfo> labels)
    1021.         {
    1022.             if (DataProvider.Count <= Canvas.Start)
    1023.             {
    1024.                 return;
    1025.             }
    1026.  
    1027.             var cluster = DataProvider.GetCluster(DataProvider.Count - 1 - Canvas.Start);
    1028.  
    1029.             if (cluster == null)
    1030.             {
    1031.                 return;
    1032.             }
    1033.  
    1034.             var delta = Minimize ? Math.Abs(cluster.Delta) : cluster.Delta;
    1035.  
    1036.             labels.Add(new IndicatorLabelInfo((double)delta, cluster.Delta > 0 ? _deltaPlusColor : _deltaMinusColor));
    1037.         }
    1038.  
    1039.         public override bool CheckAlert(double value, int distance, ref int lastIndex, ref double lastValue)
    1040.         {
    1041.             if (DataProvider.Count == lastIndex && value == lastValue)
    1042.             {
    1043.                 return false;
    1044.             }
    1045.  
    1046.             var cluster = DataProvider.GetCluster(DataProvider.Count - 1);
    1047.  
    1048.             if (cluster == null)
    1049.             {
    1050.                 return false;
    1051.             }
    1052.  
    1053.             var result = false;
    1054.  
    1055.             var delta = (double)cluster.Delta;
    1056.  
    1057.             if (value > 0 && delta >= value - distance)
    1058.             {
    1059.                 result = true;
    1060.             }
    1061.             else if (value < 0 && delta <= value + distance)
    1062.             {
    1063.                 result = true;
    1064.             }
    1065.  
    1066.             if (result == false)
    1067.             {
    1068.                 return false;
    1069.             }
    1070.  
    1071.             lastIndex = DataProvider.Count;
    1072.             lastValue = value;
    1073.  
    1074.             return true;
    1075.         }
    1076.  
    1077.         public override void ApplyColors(IChartTheme theme)
    1078.         {
    1079.             DeltaPlusColor = theme.PaletteColor6;
    1080.             DeltaMinusColor = theme.PaletteColor7;
    1081.  
    1082.             base.ApplyColors(theme);
    1083.         }
    1084.  
    1085.         public override void CopyTemplate(IndicatorBase indicator, bool style)
    1086.         {
    1087.             var i = (DeltaIndicator)indicator;
    1088.  
    1089.             DeltaPlusColor = i.DeltaPlusColor;
    1090.             DeltaMinusColor = i.DeltaMinusColor;
    1091.  
    1092.             Type = i.Type;
    1093.             Minimize = i.Minimize;
    1094.  
    1095.             MaxDeltaParam.Copy(i.MaxDeltaParam);
    1096.  
    1097.             Filter1MinParam.Copy(i.Filter1MinParam);
    1098.             Filter1MaxParam.Copy(i.Filter1MaxParam);
    1099.  
    1100.             OnPropertyChanged(nameof(Filter1Min));
    1101.             OnPropertyChanged(nameof(Filter1Max));
    1102.  
    1103.             Filter1PlusColor = i.Filter1PlusColor;
    1104.             Filter1MinusColor = i.Filter1MinusColor;
    1105.  
    1106.             Filter1Alert.Copy(i.Filter1Alert, !style);
    1107.  
    1108.             OnPropertyChanged(nameof(Filter1Alert));
    1109.  
    1110.             Filter2MinParam.Copy(i.Filter2MinParam);
    1111.             Filter2MaxParam.Copy(i.Filter2MaxParam);
    1112.  
    1113.             OnPropertyChanged(nameof(Filter2Min));
    1114.             OnPropertyChanged(nameof(Filter2Max));
    1115.  
    1116.             Filter2PlusColor = i.Filter2PlusColor;
    1117.             Filter2MinusColor = i.Filter2MinusColor;
    1118.  
    1119.             Filter2Alert.Copy(i.Filter2Alert, !style);
    1120.  
    1121.             OnPropertyChanged(nameof(Filter2Alert));
    1122.  
    1123.             Filter3MinParam.Copy(i.Filter3MinParam);
    1124.             Filter3MaxParam.Copy(i.Filter3MaxParam);
    1125.  
    1126.             OnPropertyChanged(nameof(Filter3Min));
    1127.             OnPropertyChanged(nameof(Filter3Max));
    1128.  
    1129.             Filter3PlusColor = i.Filter3PlusColor;
    1130.             Filter3MinusColor = i.Filter3MinusColor;
    1131.  
    1132.             Filter3Alert.Copy(i.Filter3Alert, !style);
    1133.  
    1134.             OnPropertyChanged(nameof(Filter3Alert));
    1135.  
    1136.             base.CopyTemplate(indicator, style);
    1137.         }
    1138.     }
    1139. }
     
    #1 Support, 6 июл 2019
    Последнее редактирование: 6 июл 2019