Volume

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

  1. Support

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

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