Trades

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

  1. Support

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

    Регистрация:
    5 сен 2015
    Сообщения:
    1 023
    Симпатии:
    195
    Код индикатора Trades
    1. //------------------------------------------------------------------------------
    2. //
    3. // Индикатор Trades. 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.Dx;
    18.  
    19. namespace TigerTrade.Chart.Indicators.Custom
    20. {
    21.     [DataContract(Name = "TradesIndicator", Namespace = "http://schemas.datacontract.org/2004/07/TigerTrade.Chart.Indicators.Custom")]
    22.     [Indicator("X_Trades", "*Trades", false, Type = typeof(TradesIndicator))]
    23.     internal sealed class TradesIndicator : IndicatorBase
    24.     {
    25.         private XBrush _upBackBrush;
    26.  
    27.         private XPen _upBackPen;
    28.  
    29.         private XColor _upBackColor;
    30.  
    31.         [DataMember(Name = "UpColor")]
    32.         [Category("Стиль"), DisplayName("Цвет при росте")]
    33.         public XColor UpColor
    34.         {
    35.             get => _upBackColor;
    36.             set
    37.             {
    38.                 if (value == _upBackColor)
    39.                 {
    40.                     return;
    41.                 }
    42.  
    43.                 _upBackColor = value;
    44.  
    45.                 _upBackBrush = new XBrush(_upBackColor);
    46.                 _upBackPen = new XPen(_upBackBrush, 1);
    47.  
    48.                 OnPropertyChanged();
    49.             }
    50.         }
    51.  
    52.         private XBrush _downBackBrush;
    53.  
    54.         private XPen _downBackPen;
    55.  
    56.         private XColor _downBackColor;
    57.  
    58.         [DataMember(Name = "DownColor")]
    59.         [Category("Стиль"), DisplayName("Цвет при падении")]
    60.         public XColor DownColor
    61.         {
    62.             get => _downBackColor;
    63.             set
    64.             {
    65.                 if (value == _downBackColor)
    66.                 {
    67.                     return;
    68.                 }
    69.  
    70.                 _downBackColor = value;
    71.  
    72.                 _downBackBrush = new XBrush(_downBackColor);
    73.                 _downBackPen = new XPen(_downBackBrush, 1);
    74.  
    75.                 OnPropertyChanged();
    76.             }
    77.         }
    78.  
    79.         private bool _deltaColored;
    80.  
    81.         [DataMember(Name = "DeltaColored")]
    82.         [Category("Параметры"), DisplayName("Раскраска по дельте")]
    83.         public bool DeltaColored
    84.         {
    85.             get => _deltaColored;
    86.             set
    87.             {
    88.                 if (value == _deltaColored)
    89.                 {
    90.                     return;
    91.                 }
    92.  
    93.                 _deltaColored = value;
    94.  
    95.                 OnPropertyChanged();
    96.             }
    97.         }
    98.  
    99.         private IndicatorNullIntParam _maxTradesParam;
    100.  
    101.         [DataMember(Name = "MaxTradesParam")]
    102.         public IndicatorNullIntParam MaxTradesParam
    103.         {
    104.             get => _maxTradesParam ?? (_maxTradesParam = new IndicatorNullIntParam(null));
    105.             set => _maxTradesParam = value;
    106.         }
    107.  
    108.         [DefaultValue(null)]
    109.         [Category("Параметры"), DisplayName("Макс. значение")]
    110.         public int? MaxTrades
    111.         {
    112.             get => MaxTradesParam.Get(SettingsLongKey);
    113.             set
    114.             {
    115.                 if (!MaxTradesParam.Set(SettingsLongKey, value, 0))
    116.                 {
    117.                     return;
    118.                 }
    119.  
    120.                 OnPropertyChanged();
    121.             }
    122.         }
    123.  
    124.         private IndicatorNullIntParam _filter1MinParam;
    125.  
    126.         [DataMember(Name = "Filter1MinParam")]
    127.         public IndicatorNullIntParam Filter1MinParam
    128.         {
    129.             get => _filter1MinParam ?? (_filter1MinParam = new IndicatorNullIntParam(null));
    130.             set => _filter1MinParam = value;
    131.         }
    132.  
    133.         [DefaultValue(null)]
    134.         [Category("Фильтр 1"), DisplayName("Минимум")]
    135.         public int? Filter1Min
    136.         {
    137.             get => Filter1MinParam.Get(SettingsLongKey);
    138.             set
    139.             {
    140.                 if (!Filter1MinParam.Set(SettingsLongKey, value, 0))
    141.                 {
    142.                     return;
    143.                 }
    144.  
    145.                 OnPropertyChanged();
    146.             }
    147.         }
    148.  
    149.         private IndicatorNullIntParam _filter1MaxParam;
    150.  
    151.         [DataMember(Name = "Filter1MaxParam")]
    152.         public IndicatorNullIntParam Filter1MaxParam
    153.         {
    154.             get => _filter1MaxParam ?? (_filter1MaxParam = new IndicatorNullIntParam(null));
    155.             set => _filter1MaxParam = value;
    156.         }
    157.  
    158.         [DefaultValue(null)]
    159.         [Category("Фильтр 1"), DisplayName("Максимум")]
    160.         public int? Filter1Max
    161.         {
    162.             get => Filter1MaxParam.Get(SettingsLongKey);
    163.             set
    164.             {
    165.                 if (!Filter1MaxParam.Set(SettingsLongKey, value, 0))
    166.                 {
    167.                     return;
    168.                 }
    169.  
    170.                 OnPropertyChanged();
    171.             }
    172.         }
    173.  
    174.         private XBrush _filter1Brush;
    175.  
    176.         private XPen _filter1Pen;
    177.  
    178.         private XColor _filter1Color;
    179.  
    180.         [DataMember(Name = "Filter1Color")]
    181.         [Category("Фильтр 1"), DisplayName("Цвет")]
    182.         public XColor Filter1Color
    183.         {
    184.             get => _filter1Color;
    185.             set
    186.             {
    187.                 if (value == _filter1Color)
    188.                 {
    189.                     return;
    190.                 }
    191.  
    192.                 _filter1Color = value;
    193.  
    194.                 _filter1Brush = new XBrush(_filter1Color);
    195.                 _filter1Pen = new XPen(_filter1Brush, 1);
    196.  
    197.                 OnPropertyChanged();
    198.             }
    199.         }
    200.  
    201.         private ChartAlertSettings _filter1Alert;
    202.  
    203.         [DataMember(Name = "Filter1Alert")]
    204.         [Category("Фильтр 1"), DisplayName("Оповещение")]
    205.         public ChartAlertSettings Filter1Alert
    206.         {
    207.             get => _filter1Alert ?? (_filter1Alert = new ChartAlertSettings());
    208.             set
    209.             {
    210.                 if (Equals(value, _filter1Alert))
    211.                 {
    212.                     return;
    213.                 }
    214.  
    215.                 _filter1Alert = value;
    216.  
    217.                 OnPropertyChanged();
    218.             }
    219.         }
    220.  
    221.         private IndicatorNullIntParam _filter2MinParam;
    222.  
    223.         [DataMember(Name = "Filter2MinParam")]
    224.         public IndicatorNullIntParam Filter2MinParam
    225.         {
    226.             get => _filter2MinParam ?? (_filter2MinParam = new IndicatorNullIntParam(null));
    227.             set => _filter2MinParam = value;
    228.         }
    229.  
    230.         [DefaultValue(null)]
    231.         [Category("Фильтр 2"), DisplayName("Минимум")]
    232.         public int? Filter2Min
    233.         {
    234.             get => Filter2MinParam.Get(SettingsLongKey);
    235.             set
    236.             {
    237.                 if (!Filter2MinParam.Set(SettingsLongKey, value, 0))
    238.                 {
    239.                     return;
    240.                 }
    241.  
    242.                 OnPropertyChanged();
    243.             }
    244.         }
    245.  
    246.         private IndicatorNullIntParam _filter2MaxParam;
    247.  
    248.         [DataMember(Name = "Filter2MaxParam")]
    249.         public IndicatorNullIntParam Filter2MaxParam
    250.         {
    251.             get => _filter2MaxParam ?? (_filter2MaxParam = new IndicatorNullIntParam(null));
    252.             set => _filter2MaxParam = value;
    253.         }
    254.  
    255.         [DefaultValue(null)]
    256.         [Category("Фильтр 2"), DisplayName("Максимум")]
    257.         public int? Filter2Max
    258.         {
    259.             get => Filter2MaxParam.Get(SettingsLongKey);
    260.             set
    261.             {
    262.                 if (!Filter2MaxParam.Set(SettingsLongKey, value, 0))
    263.                 {
    264.                     return;
    265.                 }
    266.  
    267.                 OnPropertyChanged();
    268.             }
    269.         }
    270.  
    271.         private XBrush _filter2Brush;
    272.  
    273.         private XPen _filter2Pen;
    274.  
    275.         private XColor _filter2Color;
    276.  
    277.         [DataMember(Name = "Filter2Color")]
    278.         [Category("Фильтр 2"), DisplayName("Цвет")]
    279.         public XColor Filter2Color
    280.         {
    281.             get => _filter2Color;
    282.             set
    283.             {
    284.                 if (value == _filter2Color)
    285.                 {
    286.                     return;
    287.                 }
    288.  
    289.                 _filter2Color = value;
    290.  
    291.                 _filter2Brush = new XBrush(_filter2Color);
    292.                 _filter2Pen = new XPen(_filter2Brush, 1);
    293.  
    294.                 OnPropertyChanged();
    295.             }
    296.         }
    297.  
    298.         private ChartAlertSettings _filter2Alert;
    299.  
    300.         [DataMember(Name = "Filter2Alert")]
    301.         [Category("Фильтр 2"), DisplayName("Оповещение")]
    302.         public ChartAlertSettings Filter2Alert
    303.         {
    304.             get => _filter2Alert ?? (_filter2Alert = new ChartAlertSettings());
    305.             set
    306.             {
    307.                 if (Equals(value, _filter2Alert))
    308.                 {
    309.                     return;
    310.                 }
    311.  
    312.                 _filter2Alert = value;
    313.  
    314.                 OnPropertyChanged();
    315.             }
    316.         }
    317.  
    318.         private IndicatorNullIntParam _filter3MinParam;
    319.  
    320.         [DataMember(Name = "Filter3MinParam")]
    321.         public IndicatorNullIntParam Filter3MinParam
    322.         {
    323.             get => _filter3MinParam ?? (_filter3MinParam = new IndicatorNullIntParam(null));
    324.             set => _filter3MinParam = value;
    325.         }
    326.  
    327.         [DefaultValue(null)]
    328.         [Category("Фильтр 3"), DisplayName("Минимум")]
    329.         public int? Filter3Min
    330.         {
    331.             get => Filter3MinParam.Get(SettingsLongKey);
    332.             set
    333.             {
    334.                 if (!Filter3MinParam.Set(SettingsLongKey, value, 0))
    335.                 {
    336.                     return;
    337.                 }
    338.  
    339.                 OnPropertyChanged();
    340.             }
    341.         }
    342.  
    343.         private IndicatorNullIntParam _filter3MaxParam;
    344.  
    345.         [DataMember(Name = "Filter3MaxParam")]
    346.         public IndicatorNullIntParam Filter3MaxParam
    347.         {
    348.             get => _filter3MaxParam ?? (_filter3MaxParam = new IndicatorNullIntParam(null));
    349.             set => _filter3MaxParam = value;
    350.         }
    351.  
    352.         [DefaultValue(null)]
    353.         [Category("Фильтр 3"), DisplayName("Максимум")]
    354.         public int? Filter3Max
    355.         {
    356.             get => Filter3MaxParam.Get(SettingsLongKey);
    357.             set
    358.             {
    359.                 if (!Filter3MaxParam.Set(SettingsLongKey, value, 0))
    360.                 {
    361.                     return;
    362.                 }
    363.  
    364.                 OnPropertyChanged();
    365.             }
    366.         }
    367.  
    368.         private XBrush _filter3Brush;
    369.  
    370.         private XPen _filter3Pen;
    371.  
    372.         private XColor _filter3Color;
    373.  
    374.         [DataMember(Name = "Filter3Color")]
    375.         [Category("Фильтр 3"), DisplayName("Цвет")]
    376.         public XColor Filter3Color
    377.         {
    378.             get => _filter3Color;
    379.             set
    380.             {
    381.                 if (value == _filter3Color)
    382.                 {
    383.                     return;
    384.                 }
    385.  
    386.                 _filter3Color = value;
    387.  
    388.                 _filter3Brush = new XBrush(_filter3Color);
    389.                 _filter3Pen = new XPen(_filter3Brush, 1);
    390.  
    391.                 OnPropertyChanged();
    392.             }
    393.         }
    394.  
    395.         private ChartAlertSettings _filter3Alert;
    396.  
    397.         [DataMember(Name = "Filter3Alert")]
    398.         [Category("Фильтр 3"), DisplayName("Оповещение")]
    399.         public ChartAlertSettings Filter3Alert
    400.         {
    401.             get => _filter3Alert ?? (_filter3Alert = new ChartAlertSettings());
    402.             set
    403.             {
    404.                 if (Equals(value, _filter3Alert))
    405.                 {
    406.                     return;
    407.                 }
    408.  
    409.                 _filter3Alert = value;
    410.  
    411.                 OnPropertyChanged();
    412.             }
    413.         }
    414.  
    415.         [Browsable(false)]
    416.         public override IndicatorCalculation Calculation => IndicatorCalculation.OnEachTick;
    417.  
    418.         public override bool IntegerValues => true;
    419.  
    420.         private int _filter1SignalIndex;
    421.         private int _filter2SignalIndex;
    422.         private int _filter3SignalIndex;
    423.  
    424.         private double _max;
    425.  
    426.         public TradesIndicator()
    427.         {
    428.             UpColor = Color.FromArgb(255, 30, 144, 255);
    429.             DownColor = Color.FromArgb(255, 178, 34, 34);
    430.  
    431.             DeltaColored = false;
    432.  
    433.             Filter1Color = Colors.Orange;
    434.             Filter2Color = Colors.Orange;
    435.             Filter3Color = Colors.Orange;
    436.  
    437.             _filter1SignalIndex = -1;
    438.             _filter2SignalIndex = -1;
    439.             _filter3SignalIndex = -1;
    440.         }
    441.  
    442.         protected override void Execute()
    443.         {
    444.             if (ClearData)
    445.             {
    446.                 _filter1SignalIndex = -1;
    447.                 _filter2SignalIndex = -1;
    448.                 _filter3SignalIndex = -1;
    449.             }
    450.  
    451.             var index = DataProvider.Count;
    452.  
    453.             var cluster = DataProvider.GetCluster(index - 1);
    454.  
    455.             if (cluster == null)
    456.             {
    457.                 return;
    458.             }
    459.  
    460.             var trades = cluster.Trades;
    461.  
    462.             if (Filter1Alert.IsActive && _filter1SignalIndex < index)
    463.             {
    464.                 var min = Filter1Min ?? -1;
    465.                 var max = Filter1Max ?? -1;
    466.  
    467.                 if (min >= 0 && trades >= min && (max < 0 || trades <= max))
    468.                 {
    469.                     _filter1SignalIndex = index;
    470.  
    471.                     AddAlert(Filter1Alert,
    472.                         $"Trades: фильтр 1, значение {DataProvider.Symbol.FormatTrades(trades)}.");
    473.                 }
    474.             }
    475.  
    476.             if (Filter2Alert.IsActive && _filter2SignalIndex < index)
    477.             {
    478.                 var min = Filter2Min ?? -1;
    479.                 var max = Filter2Max ?? -1;
    480.  
    481.                 if (min >= 0 && trades >= min && (max < 0 || trades <= max))
    482.                 {
    483.                     _filter2SignalIndex = index;
    484.  
    485.                     AddAlert(Filter2Alert,
    486.                         $"Trades: фильтр 2, значение {DataProvider.Symbol.FormatTrades(trades)}.");
    487.                 }
    488.             }
    489.  
    490.             if (Filter3Alert.IsActive && _filter3SignalIndex < index)
    491.             {
    492.                 var min = Filter3Min ?? -1;
    493.                 var max = Filter3Max ?? -1;
    494.  
    495.                 if (min >= 0 && trades >= min && (max < 0 || trades <= max))
    496.                 {
    497.                     _filter3SignalIndex = index;
    498.  
    499.                     AddAlert(Filter3Alert,
    500.                         $"Trades: фильтр 3, значение {DataProvider.Symbol.FormatTrades(trades)}.");
    501.                 }
    502.             }
    503.         }
    504.  
    505.         public override bool GetMinMax(out double min, out double max)
    506.         {
    507.             min = 0.0;
    508.             max = 0.0;
    509.  
    510.             if (Canvas.IsStock)
    511.             {
    512.                 return false;
    513.             }
    514.  
    515.             for (var i = 0; i < Canvas.Count; i++)
    516.             {
    517.                 var index = Canvas.GetIndex(i);
    518.  
    519.                 var cluster = DataProvider.GetCluster(index);
    520.  
    521.                 if (cluster == null)
    522.                 {
    523.                     continue;
    524.                 }
    525.  
    526.                 var trades = (double)cluster.Trades;
    527.  
    528.                 if (max < trades)
    529.                 {
    530.                     max = trades;
    531.                 }
    532.             }
    533.  
    534.             var maxTrades = MaxTrades ?? -1;
    535.  
    536.             if (maxTrades >= 0 && max > maxTrades)
    537.             {
    538.                 max = maxTrades;
    539.             }
    540.  
    541.             return true;
    542.         }
    543.  
    544.         private double GetMax()
    545.         {
    546.             var max = 0.0;
    547.  
    548.             for (var i = 0; i < Canvas.Count; i++)
    549.             {
    550.                 var index = Canvas.GetIndex(i);
    551.  
    552.                 var cluster = DataProvider.GetCluster(index);
    553.  
    554.                 if (cluster == null)
    555.                 {
    556.                     continue;
    557.                 }
    558.  
    559.                 var trades = (double)cluster.Trades;
    560.  
    561.                 if (max < trades)
    562.                 {
    563.                     max = trades;
    564.                 }
    565.             }
    566.  
    567.             var maxTrades = MaxTrades ?? -1;
    568.  
    569.             if (maxTrades >= 0 && max > maxTrades)
    570.             {
    571.                 max = maxTrades;
    572.             }
    573.  
    574.             return max;
    575.         }
    576.  
    577.         public override void Render(DxVisualQueue visual)
    578.         {
    579.             if (Canvas.IsStock)
    580.             {
    581.                 RenderOnMain(visual);
    582.  
    583.                 return;
    584.             }
    585.  
    586.             var min1 = Filter1Min ?? -1;
    587.             var max1 = Filter1Max ?? -1;
    588.             var min2 = Filter2Min ?? -1;
    589.             var max2 = Filter2Max ?? -1;
    590.             var min3 = Filter3Min ?? -1;
    591.             var max3 = Filter3Max ?? -1;
    592.  
    593.             var maxTrades = MaxTrades ?? -1;
    594.             var maxPoint = GetY((double)maxTrades);
    595.  
    596.             var zeroPoint = GetY(0.0);
    597.  
    598.             var width = Math.Max(Canvas.ColumnWidth - 1, 1);
    599.  
    600.             for (var i = 0; i < Canvas.Count; i++)
    601.             {
    602.                 var index = Canvas.GetIndex(i);
    603.  
    604.                 var cluster = DataProvider.GetCluster(index);
    605.  
    606.                 if (cluster == null)
    607.                 {
    608.                     continue;
    609.                 }
    610.  
    611.                 var x = Canvas.GetX(index);
    612.                 var y = GetY((double)cluster.Trades);
    613.  
    614.                 if (maxTrades >= 0)
    615.                 {
    616.                     y = Math.Max(y, maxPoint);
    617.                 }
    618.  
    619.                 var h = (int)zeroPoint - (int)y;
    620.  
    621.                 if (h < 0)
    622.                 {
    623.                     continue;
    624.                 }
    625.  
    626.                 if (h < 1)
    627.                 {
    628.                     y = (int)zeroPoint - 1;
    629.                     h = 1;
    630.                 }
    631.  
    632.                 var isUp = DeltaColored ? cluster.Delta > 0 : cluster.IsUp;
    633.  
    634.                 XBrush filterBrush = null;
    635.                 XPen filterPen = null;
    636.  
    637.                 if (min1 >= 0 && cluster.Trades >= min1 && (max1 < 0 || cluster.Trades <= max1))
    638.                 {
    639.                     filterBrush = _filter1Brush;
    640.                     filterPen = _filter1Pen;
    641.                 }
    642.                 else if (min2 >= 0 && cluster.Trades >= min2 && (max2 < 0 || cluster.Trades <= max2))
    643.                 {
    644.                     filterBrush = _filter2Brush;
    645.                     filterPen = _filter2Pen;
    646.                 }
    647.                 else if (min3 >= 0 && cluster.Trades >= min3 && (max3 < 0 || cluster.Trades <= max3))
    648.                 {
    649.                     filterBrush = _filter3Brush;
    650.                     filterPen = _filter3Pen;
    651.                 }
    652.  
    653.                 if (width > 1)
    654.                 {
    655.                     if (filterBrush != null)
    656.                     {
    657.                         visual.FillRectangle(filterBrush, new Rect(x - width / 2.0, y, width, h));
    658.                     }
    659.                     else
    660.                     {
    661.                         visual.FillRectangle(isUp
    662.                             ? _upBackBrush
    663.                             : _downBackBrush, new Rect(x - width / 2.0, y, width, h));
    664.                     }
    665.                 }
    666.                 else
    667.                 {
    668.                     if (filterPen != null)
    669.                     {
    670.                         visual.DrawLine(filterPen, new Point(x, y), new Point(x, y + h));
    671.                     }
    672.                     else
    673.                     {
    674.                         visual.DrawLine(isUp
    675.                             ? _upBackPen
    676.                             : _downBackPen, new Point(x, y), new Point(x, y + h));
    677.                     }
    678.                 }
    679.             }
    680.         }
    681.  
    682.         public void RenderOnMain(DxVisualQueue visual)
    683.         {
    684.             var min1 = Filter1Min ?? -1;
    685.             var max1 = Filter1Max ?? -1;
    686.             var min2 = Filter2Min ?? -1;
    687.             var max2 = Filter2Max ?? -1;
    688.             var min3 = Filter3Min ?? -1;
    689.             var max3 = Filter3Max ?? -1;
    690.  
    691.             var maxTrades = MaxTrades ?? -1;
    692.  
    693.             var height = Canvas.Rect.Height * 0.2;
    694.             var minPoint = Canvas.Rect.Bottom - 2;
    695.             var maxPoint = minPoint - height;
    696.  
    697.             var width = Math.Max(Canvas.ColumnWidth - 1, 1);
    698.  
    699.             _max = GetMax();
    700.  
    701.             for (var i = 0; i < Canvas.Count; i++)
    702.             {
    703.                 var index = Canvas.GetIndex(i);
    704.  
    705.                 var cluster = DataProvider.GetCluster(index);
    706.  
    707.                 if (cluster == null)
    708.                 {
    709.                     continue;
    710.                 }
    711.  
    712.                 var x = Canvas.GetX(index);
    713.                 var y = minPoint - height * cluster.Trades / _max;
    714.  
    715.                 if (maxTrades >= 0)
    716.                 {
    717.                     y = Math.Max(y, maxPoint);
    718.                 }
    719.  
    720.                 var h = (int)minPoint - (int)y;
    721.  
    722.                 if (h < 0)
    723.                 {
    724.                     continue;
    725.                 }
    726.  
    727.                 var isUp = DeltaColored ? cluster.Delta > 0 : cluster.IsUp;
    728.  
    729.                 XBrush filterBrush = null;
    730.                 XPen filterPen = null;
    731.  
    732.                 if (min1 >= 0 && cluster.Trades >= min1 && (max1 < 0 || cluster.Trades <= max1))
    733.                 {
    734.                     filterBrush = _filter1Brush;
    735.                     filterPen = _filter1Pen;
    736.                 }
    737.                 else if (min2 >= 0 && cluster.Trades >= min2 && (max2 < 0 || cluster.Trades <= max2))
    738.                 {
    739.                     filterBrush = _filter2Brush;
    740.                     filterPen = _filter2Pen;
    741.                 }
    742.                 else if (min3 >= 0 && cluster.Trades >= min3 && (max3 < 0 || cluster.Trades <= max3))
    743.                 {
    744.                     filterBrush = _filter3Brush;
    745.                     filterPen = _filter3Pen;
    746.                 }
    747.  
    748.                 if (width > 1)
    749.                 {
    750.                     if (filterBrush != null)
    751.                     {
    752.                         visual.FillRectangle(filterBrush, new Rect(x - width / 2.0, y, width, h));
    753.                     }
    754.                     else
    755.                     {
    756.                         visual.FillRectangle(isUp
    757.                             ? _upBackBrush
    758.                             : _downBackBrush, new Rect(x - width / 2.0, y, width, h));
    759.                     }
    760.                 }
    761.                 else
    762.                 {
    763.                     if (filterPen != null)
    764.                     {
    765.                         visual.DrawLine(filterPen, new Point(x, y), new Point(x, y + h));
    766.                     }
    767.                     else
    768.                     {
    769.                         visual.DrawLine(isUp
    770.                             ? _upBackPen
    771.                             : _downBackPen, new Point(x, y), new Point(x, y + h));
    772.                     }
    773.                 }
    774.             }
    775.         }
    776.  
    777.         public override List<IndicatorValueInfo> GetValues(int cursorPos)
    778.         {
    779.             var info = new List<IndicatorValueInfo>();
    780.  
    781.             var cluster = DataProvider.GetCluster(cursorPos);
    782.  
    783.             if (cluster == null)
    784.             {
    785.                 return info;
    786.             }
    787.  
    788.             var s = Canvas.FormatValue((double)cluster.Trades);
    789.  
    790.             if (Canvas.IsStock)
    791.             {
    792.                 s = DataProvider.Symbol.FormatSizeShort(cluster.Trades);
    793.             }
    794.  
    795.             info.Add(new IndicatorValueInfo(s,
    796.                 new XBrush(cluster.IsUp ? _upBackColor : _downBackColor)));
    797.  
    798.             return info;
    799.         }
    800.  
    801.         public override void GetLabels(ref List<IndicatorLabelInfo> labels)
    802.         {
    803.             if (DataProvider.Count <= Canvas.Start)
    804.             {
    805.                 return;
    806.             }
    807.  
    808.             var cluster = DataProvider.GetCluster(DataProvider.Count - 1 - Canvas.Start);
    809.  
    810.             if (cluster == null)
    811.             {
    812.                 return;
    813.             }
    814.  
    815.             double? position = null;
    816.  
    817.             if (Canvas.IsStock)
    818.             {
    819.                 position = Canvas.Rect.Bottom -
    820.                            Canvas.Rect.Height * 0.2 * cluster.Trades / _max;
    821.             }
    822.  
    823.             labels.Add(new IndicatorLabelInfo(cluster.Trades,
    824.                 cluster.IsUp ? _upBackColor : _downBackColor, position));
    825.         }
    826.  
    827.         public override bool CheckAlert(double value, int distance, ref int lastIndex, ref double lastValue)
    828.         {
    829.             if (Canvas.IsStock)
    830.             {
    831.                 return false;
    832.             }
    833.  
    834.             if (DataProvider.Count == lastIndex && value == lastValue)
    835.             {
    836.                 return false;
    837.             }
    838.  
    839.             var cluster = DataProvider.GetCluster(DataProvider.Count - 1);
    840.  
    841.             if (cluster == null)
    842.             {
    843.                 return false;
    844.             }
    845.  
    846.             if (cluster.Trades < value - distance)
    847.             {
    848.                 return false;
    849.             }
    850.  
    851.             lastIndex = DataProvider.Count;
    852.             lastValue = value;
    853.  
    854.             return true;
    855.         }
    856.  
    857.         public override void ApplyColors(IChartTheme theme)
    858.         {
    859.             UpColor = theme.PaletteColor6;
    860.             DownColor = theme.PaletteColor7;
    861.  
    862.             base.ApplyColors(theme);
    863.         }
    864.  
    865.         public override void CopyTemplate(IndicatorBase indicator, bool style)
    866.         {
    867.             var i = (TradesIndicator)indicator;
    868.  
    869.             UpColor = i.UpColor;
    870.             DownColor = i.DownColor;
    871.  
    872.             DeltaColored = i.DeltaColored;
    873.  
    874.             MaxTradesParam.Copy(i.MaxTradesParam);
    875.  
    876.             Filter1MinParam.Copy(i.Filter1MinParam);
    877.             Filter1MaxParam.Copy(i.Filter1MaxParam);
    878.  
    879.             OnPropertyChanged(nameof(Filter1Min));
    880.             OnPropertyChanged(nameof(Filter1Max));
    881.  
    882.             Filter1Color = i.Filter1Color;
    883.  
    884.             Filter1Alert.Copy(i.Filter1Alert, !style);
    885.  
    886.             OnPropertyChanged(nameof(Filter1Alert));
    887.  
    888.             Filter2MinParam.Copy(i.Filter2MinParam);
    889.             Filter2MaxParam.Copy(i.Filter2MaxParam);
    890.  
    891.             OnPropertyChanged(nameof(Filter2Min));
    892.             OnPropertyChanged(nameof(Filter2Max));
    893.  
    894.             Filter2Color = i.Filter2Color;
    895.  
    896.             Filter2Alert.Copy(i.Filter2Alert, !style);
    897.  
    898.             OnPropertyChanged(nameof(Filter2Alert));
    899.  
    900.             Filter3MinParam.Copy(i.Filter3MinParam);
    901.             Filter3MaxParam.Copy(i.Filter3MaxParam);
    902.  
    903.             OnPropertyChanged(nameof(Filter3Min));
    904.             OnPropertyChanged(nameof(Filter3Max));
    905.  
    906.             Filter3Color = i.Filter3Color;
    907.  
    908.             Filter3Alert.Copy(i.Filter3Alert, !style);
    909.  
    910.             OnPropertyChanged(nameof(Filter3Alert));
    911.  
    912.             base.CopyTemplate(indicator, style);
    913.         }
    914.     }
    915. }
     
    #1 Support, 6 июл 2019
    Последнее редактирование: 26 июл 2019