Delta

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

  1. Support

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

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