Прямоугольник

Тема в разделе "Примеры графических объектов", создана пользователем Support, 6 янв 2020.

  1. Support

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

    Регистрация:
    5 сен 2015
    Сообщения:
    1 326
    Симпатии:
    292
    Код графического объекта Прямоугольник
    1. //------------------------------------------------------------------------------
    2. //
    3. // Графический объект Rectangle. Copyright (c) 2020 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.Base;
    14. using TigerTrade.Chart.Base.Enums;
    15. using TigerTrade.Chart.Objects.Common;
    16. using TigerTrade.Dx;
    17. using TigerTrade.Dx.Enums;
    18.  
    19. namespace TigerTrade.Chart.Objects.Custom
    20. {
    21.     [DataContract(Name = "RectangleObject", Namespace = "http://schemas.datacontract.org/2004/07/TigerTrade.Chart.Objects.Custom")]
    22.     [ChartObject("X_Rectangle", "Прямоугольник", 2, Type = typeof(RectangleObject))]
    23.     public sealed class RectangleObject : ObjectBase
    24.     {
    25.         private bool _drawBorder;
    26.  
    27.         [DataMember(Name = "DrawBorder")]
    28.         [Category("Граница"), DisplayName("Граница")]
    29.         public bool DrawBorder
    30.         {
    31.             get => _drawBorder;
    32.             set
    33.             {
    34.                 if (value == _drawBorder)
    35.                 {
    36.                     return;
    37.                 }
    38.  
    39.                 _drawBorder = value;
    40.  
    41.                 OnPropertyChanged();
    42.             }
    43.         }
    44.  
    45.         private XBrush _lineBrush;
    46.  
    47.         private XPen _linePen;
    48.  
    49.         private XColor _lineColor;
    50.  
    51.         [DataMember(Name = "LineColor")]
    52.         [Category("Граница"), DisplayName("Цвет линии")]
    53.         public XColor LineColor
    54.         {
    55.             get => _lineColor;
    56.             set
    57.             {
    58.                 if (value == _lineColor)
    59.                 {
    60.                     return;
    61.                 }
    62.  
    63.                 _lineColor = value;
    64.  
    65.                 _lineBrush = new XBrush(_lineColor);
    66.                 _linePen = new XPen(_lineBrush, LineWidth, LineStyle);
    67.  
    68.                 OnPropertyChanged();
    69.             }
    70.         }
    71.  
    72.         private int _lineWidth;
    73.  
    74.         [DataMember(Name = "LineWidth")]
    75.         [Category("Граница"), DisplayName("Толщина линии")]
    76.         public int LineWidth
    77.         {
    78.             get => _lineWidth;
    79.             set
    80.             {
    81.                 value = Math.Max(1, Math.Min(10, value));
    82.  
    83.                 if (value == _lineWidth)
    84.                 {
    85.                     return;
    86.                 }
    87.  
    88.                 _lineWidth = value;
    89.  
    90.                 _linePen = new XPen(_lineBrush, _lineWidth, LineStyle);
    91.  
    92.                 OnPropertyChanged();
    93.             }
    94.         }
    95.  
    96.         private XDashStyle _lineStyle;
    97.  
    98.         [DataMember(Name = "LineStyle")]
    99.         [Category("Граница"), DisplayName("Стиль линии")]
    100.         public XDashStyle LineStyle
    101.         {
    102.             get => _lineStyle;
    103.             set
    104.             {
    105.                 if (value == _lineStyle)
    106.                 {
    107.                     return;
    108.                 }
    109.  
    110.                 _lineStyle = value;
    111.  
    112.                 _linePen = new XPen(_lineBrush, LineWidth, _lineStyle);
    113.  
    114.                 OnPropertyChanged();
    115.             }
    116.         }
    117.  
    118.         private bool _drawBack;
    119.  
    120.         [DataMember(Name = "DrawBack")]
    121.         [Category("Фон"), DisplayName("Фон")]
    122.         public bool DrawBack
    123.         {
    124.             get => _drawBack;
    125.             set
    126.             {
    127.                 if (value == _drawBack)
    128.                 {
    129.                     return;
    130.                 }
    131.  
    132.                 _drawBack = value;
    133.  
    134.                 OnPropertyChanged();
    135.             }
    136.         }
    137.  
    138.         private XBrush _backBrush;
    139.  
    140.         private XColor _backColor;
    141.  
    142.         [DataMember(Name = "BackColor")]
    143.         [Category("Фон"), DisplayName("Цвет фона")]
    144.         public XColor BackColor
    145.         {
    146.             get => _backColor;
    147.             set
    148.             {
    149.                 if (value == _backColor)
    150.                 {
    151.                     return;
    152.                 }
    153.  
    154.                 _backColor = value;
    155.  
    156.                 _backBrush = new XBrush(_backColor);
    157.  
    158.                 OnPropertyChanged();
    159.             }
    160.         }
    161.  
    162.         protected override int PenWidth => LineWidth;
    163.  
    164.         private bool _isObjectInArea;
    165.  
    166.         public class RectangleInfo
    167.         {
    168.             public Point ControlPoint1;
    169.             public Point ControlPoint2;
    170.  
    171.             public Point ExtraPoint1;
    172.             public Point ExtraPoint2;
    173.  
    174.             public Rect Rectangle;
    175.         }
    176.  
    177.         private RectangleInfo _rectInfo;
    178.  
    179.         public RectangleObject()
    180.         {
    181.             DrawBorder = true;
    182.             LineColor = Colors.Black;
    183.             LineWidth = 1;
    184.             LineStyle = XDashStyle.Solid;
    185.  
    186.             DrawBack = true;
    187.             BackColor = Color.FromArgb(30, 0, 0, 0);
    188.         }
    189.  
    190.         protected override void Prepare()
    191.         {
    192.             var point1 = ToPoint(ControlPoints[0]);
    193.             var point2 = ToPoint(ControlPoints[1]);
    194.  
    195.             var ep1 = ToPoint(ExtraPoints[0]);
    196.             var ep2 = ToPoint(ExtraPoints[1]);
    197.  
    198.             var w = Canvas.ColumnWidth / 2.0;
    199.             var h = Canvas.StepHeight / 2.0;
    200.  
    201.             var extendHeight = Canvas.StockType == ChartStockType.Clusters;
    202.  
    203.             if (point1.X > point2.X)
    204.             {
    205.                 point1.X += w;
    206.                 point2.X -= w;
    207.             }
    208.             else
    209.             {
    210.                 point1.X -= w;
    211.                 point2.X += w;
    212.             }
    213.  
    214.             if (extendHeight)
    215.             {
    216.                 if (point1.Y > point2.Y)
    217.                 {
    218.                     point1.Y += h;
    219.                     point2.Y -= h;
    220.                 }
    221.                 else
    222.                 {
    223.                     point1.Y -= h;
    224.                     point2.Y += h;
    225.                 }
    226.             }
    227.  
    228.             if (ep1.X > ep2.X)
    229.             {
    230.                 ep1.X += w;
    231.                 ep2.X -= w;
    232.             }
    233.             else
    234.             {
    235.                 ep1.X -= w;
    236.                 ep2.X += w;
    237.             }
    238.  
    239.             if (extendHeight)
    240.             {
    241.                 if (ep1.Y > ep2.Y)
    242.                 {
    243.                     ep1.Y += h;
    244.                     ep2.Y -= h;
    245.                 }
    246.                 else
    247.                 {
    248.                     ep1.Y -= h;
    249.                     ep2.Y += h;
    250.                 }
    251.             }
    252.  
    253.             _rectInfo = new RectangleInfo
    254.             {
    255.                 ControlPoint1 = point1,
    256.                 ControlPoint2 = point2,
    257.                 ExtraPoint1 = ep1,
    258.                 ExtraPoint2 = ep2,
    259.                 Rectangle = new Rect(point1, point2)
    260.             };
    261.  
    262.             _isObjectInArea = Canvas.Rect.IntersectsWith(_rectInfo.Rectangle);
    263.         }
    264.  
    265.         protected override void Draw(DxVisualQueue visual, ref List<ObjectLabelInfo> labels)
    266.         {
    267.             if (DrawBack)
    268.             {
    269.                 visual.FillRectangle(_backBrush, _rectInfo.Rectangle);
    270.             }
    271.  
    272.             if (DrawBorder)
    273.             {
    274.                 visual.DrawRectangle(_linePen, _rectInfo.Rectangle);
    275.             }
    276.         }
    277.  
    278.         public override void DrawControlPoints(DxVisualQueue visual)
    279.         {
    280.             if (_rectInfo == null)
    281.             {
    282.                 return;
    283.             }
    284.  
    285.             DrawControlPoint(visual, _rectInfo.ControlPoint1);
    286.             DrawControlPoint(visual, _rectInfo.ControlPoint2);
    287.  
    288.             DrawControlPoint(visual, _rectInfo.ExtraPoint1);
    289.             DrawControlPoint(visual, _rectInfo.ExtraPoint2);
    290.         }
    291.  
    292.         public override int GetControlPoint(int x, int y)
    293.         {
    294.             if (Canvas == null || _rectInfo == null)
    295.             {
    296.                 return -1;
    297.             }
    298.  
    299.             var points = new[] { _rectInfo.ControlPoint1, _rectInfo.ControlPoint2 };
    300.  
    301.             for (var i = 0; i < points.Length; i++)
    302.             {
    303.                 var distX = points[i].X - x;
    304.                 var distY = points[i].Y - y;
    305.  
    306.                 if (distX * distX + distY * distY < 9.0 + PenWidth / 2.0)
    307.                 {
    308.                     return i;
    309.                 }
    310.             }
    311.  
    312.             return -1;
    313.         }
    314.  
    315.         public override int GetExtraPoint(int x, int y)
    316.         {
    317.             if (Canvas == null || _rectInfo == null)
    318.             {
    319.                 return -1;
    320.             }
    321.  
    322.             var points = new[] { _rectInfo.ExtraPoint1, _rectInfo.ExtraPoint2 };
    323.  
    324.             for (var i = 0; i < points.Length; i++)
    325.             {
    326.                 var distX = points[i].X - x;
    327.                 var distY = points[i].Y - y;
    328.  
    329.                 if (distX * distX + distY * distY < 9.0 + PenWidth / 2.0)
    330.                 {
    331.                     return i;
    332.                 }
    333.             }
    334.  
    335.             return -1;
    336.         }
    337.  
    338.         protected override bool IsObjectInArea()
    339.         {
    340.             return _isObjectInArea;
    341.         }
    342.  
    343.         protected override bool InObject(int x, int y)
    344.         {
    345.             if (_rectInfo == null)
    346.             {
    347.                 return false;
    348.             }
    349.  
    350.             return _rectInfo.Rectangle != Rect.Empty && _rectInfo.Rectangle.Contains(x, y);
    351.         }
    352.  
    353.         protected override int GetMinDist(int x, int y)
    354.         {
    355.             var rect = _rectInfo.Rectangle;
    356.  
    357.             var dx = Math.Min(rect.X + rect.Width - x, x - rect.X);
    358.             var dy = Math.Min(rect.Y + rect.Height - y, y - rect.Y);
    359.  
    360.             var result = Math.Min(dx, dy);
    361.  
    362.             return result > 0 ? (int)result : -1;
    363.         }
    364.  
    365.         public override ObjectPoint[] ExtraPoints
    366.         {
    367.             get
    368.             {
    369.                 var cp1 = ControlPoints[0];
    370.                 var cp2 = ControlPoints[1];
    371.  
    372.                 var ep1 = new ObjectPoint(cp2.X, cp1.Y);
    373.                 var ep2 = new ObjectPoint(cp1.X, cp2.Y);
    374.  
    375.                 var extraPoints = new[] { ep1, ep2 };
    376.  
    377.                 return extraPoints;
    378.             }
    379.         }
    380.  
    381.         public override void ExtraPointChanged(int index, ObjectPoint op)
    382.         {
    383.             switch (index)
    384.             {
    385.                 case 0:
    386.  
    387.                     ControlPoints[1].X = op.X;
    388.                     ControlPoints[0].Y = op.Y;
    389.  
    390.                     break;
    391.  
    392.                 case 1:
    393.  
    394.                     ControlPoints[0].X = op.X;
    395.                     ControlPoints[1].Y = op.Y;
    396.  
    397.                     break;
    398.             }
    399.         }
    400.  
    401.         public override void ApplyTheme(IChartTheme theme)
    402.         {
    403.             base.ApplyTheme(theme);
    404.  
    405.             LineColor = theme.ChartObjectLineColor;
    406.             BackColor = theme.ChartObjectFillColor;
    407.         }
    408.  
    409.         public override void CopyTemplate(ObjectBase objectBase, bool style)
    410.         {
    411.             if (objectBase is RectangleObject obj)
    412.             {
    413.                 DrawBorder = obj.DrawBorder;
    414.                 LineColor = obj.LineColor;
    415.                 LineWidth = obj.LineWidth;
    416.                 LineStyle = obj.LineStyle;
    417.  
    418.                 DrawBack = obj.DrawBack;
    419.                 BackColor = obj.BackColor;
    420.             }
    421.  
    422.             base.CopyTemplate(objectBase, style);
    423.         }
    424.     }
    425. }
     
    #1 Support, 6 янв 2020
    Последнее редактирование: 6 янв 2020