English
preview
Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте

Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте

MetaTrader 5 — Торговые системы |
14 2
Allan Munene Mutiiria
Allan Munene Mutiiria

Введение

В предыдущей статье (часть 35) мы расширили слой рисования на холсте, добавив семь категорий аналитических инструментов рисования с несколькими опорными точками — каналы, вилы, инструменты Ганна и Фибоначчи — и подключив их к тому же конвейеру проверки попадания, выделения, изменения формы и предварительного просмотра в режиме "резинки", что и базовые инструменты рисования линий. Набор аналитических инструментов теперь укомплектован, но на холсте по-прежнему не хватает двух составляющих, необходимых для любой полноценной работы с аннотациями на графике: фигур, которые трейдер может заливать цветом и форму которых может изменять (прямоугольников, треугольников, кругов, эллипсов, дуг, кривых, контуров, повернутых прямоугольников), и инструментов аннотирования с редактируемым текстом (примечаний, выносок, комментариев, стрелок, ценовых меток). Без них холст доступен только для просмотра: трейдер может отмечать структуру, но не может подписать её, прокомментировать торговую ситуацию или закрепить ценовое примечание рядом с уровнем.

Мы добавили семнадцать новых инструментов в двух категориях. Категория "Фигуры" включает восемь инструментов: "Прямоугольник" (теперь с восемью маркерами), "Треугольник", "Повернутый прямоугольник", "Повернутый эллипс", "Контур" (ломаная из N точек), "Окружность", "Дуга" (квадратичная кривая Безье с ограничением положения вершины) и "Кривая" (квадратичная кривая Безье со свободной вершиной). В категории "Аннотации" представлены остальные девять инструментов: "Текст", "Стрелка", "Маркер стрелки", "Стрелка вверх", "Стрелка вниз", "Примечание", "Примечание к цене", "Выноска" и "Комментарий". У большинства этих инструментов метки можно редактировать, поэтому мы реализуем текстовый редактор, работающий непосредственно на холсте. Он поддерживает конечный автомат редактирования, основанный на положении текстового курсора, многострочный перенос слов (подбор вмещающегося префикса бинарным поиском), отрисовку текста с суперсэмплингом и попиксельным извлечением альфа-канала, определение позиции текстового курсора по щелчку мыши, преобразование в Unicode кодов виртуальных клавиш Windows, а также выделение текста сочетаниями Shift со стрелками.

Эта статья предназначена для разработчиков среднего и продвинутого уровня, использующих MetaQuotes Language 5 (MQL5) и хорошо знакомых с цепочкой наследования, которую мы построили в предыдущих частях. Мы рассмотрим следующие темы:

  1. От аналитических инструментов к визуальным аннотациям с редактируемым текстом
  2. Реализация инструментов рисования фигур
  3. Реализация инструментов аннотирования
  4. Реализация системы редактирования меток на месте
  5. Визуализация
  6. Заключение

В итоге слой рисования на холсте будет содержать полный набор инструментов для создания фигур и аннотаций с редактируемыми текстовыми метками, а трейдер сможет щелкнуть любую аннотацию и вводить текст прямо на графике — с мигающим текстовым курсором, переносом слов, навигацией клавишами со стрелками и выделением сочетанием Shift+стрелка. Всё это будет отображаться на холсте в виде сглаженных пикселей без использования единого встроенного графического объекта MetaTrader 5.


От аналитических инструментов к визуальным аннотациям с редактируемым текстом

Все инструменты, которые мы добавили до сих пор, описывают структуру на графике. Канал охватывает тренд. Вилы обрамляют свинг. Уровни коррекции Фибоначчи обозначают ключевые соотношения. Однако ни один из них не передаёт смысл, который трейдер выразил своими словами. Например, канал регрессии не может сообщить: "Это зона покупки, если цена удержится на уровне 1,0865". Веер Ганна не может пояснить, от какого луча произошла следующая реакция цены. Новые инструменты решают эту проблему. Они добавляют фигуры с заливкой для визуального выделения и редактируемые текстовые аннотации.

Новые инструменты делятся на две категории (фигуры и аннотации) и используют общий третий архитектурный слой — редактирование текста на месте. Фигуры представляют собой заполненные области, определяемые двумя или тремя опорными точками, с полупрозрачной заливкой, отображаемой с использованием сглаживания по знаковому расстоянию. Благодаря этому границы выглядят чёткими даже у повернутых фигур. Аннотации — это метки, содержащие текст, введенный пользователем. Примечание привязывает прямоугольник к опорной точке с помощью соединительной линии. Выноска добавляет к прямоугольнику хвост, указывающий на какой-либо объект. Комментарий размещает плашку с закруглёнными углами вплотную к точке щелчка. Стрелка рисует указатель направления с закрашенным треугольным наконечником. Слой редактирования текста — самая сложная часть. Нам нужен перенос слов, который находит подходящую точку переноса для каждой визуальной строки с помощью двоичного поиска с измерением ширины префиксов текста. Мигание текстового курсора управляется таймером. Координаты щелчка мыши преобразуются в позиции символов. Перехват виртуальных клавиш Windows обеспечивает ввод текста. Навигация с помощью клавиш со стрелками учитывает визуальные строки после переноса слов. Сочетание клавиши Shift с клавишей со стрелкой расширяет выделение. Переопределение клавиатурного управления графиком гарантирует, что ввод текста не будет запускать встроенную навигацию MetaTrader 5. Большую часть этого мы уже рассматривали в серии статей об ИИ, поэтому просто сошлёмся на неё, так как здесь используется та же логика.

Чтобы не переписывать цепочку наследования, мы добавляем два уровня. CFibonacciTools становится базовым классом для CShapeTools, а CShapeTools — для CAnnotationTools. Затем CAnnotationTools становится родительским классом для реестра инструментов и движка рисования. Каждый уровень добавляет процедуры рисования, тестеры попадания и общие вспомогательные функции. К ним относятся заливка скруглённых прямоугольников с суперсэмплингом, двухпроходное извлечение альфа-канала текста с отрисовкой на чёрном и белом фоне, проверки принадлежности точки многоугольнику для залитых силуэтов, двухпроходное разделяемое прямоугольное размытие для теней, а также общие вспомогательные функции переноса слов и отрисовки текста. Всё это вдохновлено стандартными инструментами анализа веб-графика MQL5, для расширения которых мы приложили дополнительные усилия. Ниже представлена визуализация наших целей.

АРХИТЕКТУРА ВИЗУАЛЬНЫХ АННОТАЦИЙ

Теперь, когда схема готова, мы можем приступить к реализации.


Реализация инструментов для работы с фигурами

Объявление класса инструментов рисования фигур

Мы начинаем реализацию с объявления CShapeTools — нового слоя, который расширяет класс инструментов Фибоначчи за счёт примитивов рисования фигур. Мы используем его как слой интерфейса для восьми новых инструментов рисования фигур, объявляя все открытые процедуры рисования и тестеры попадания, чтобы предоставить движку рисования стабильный интерфейс вызовов.

//+------------------------------------------------------------------+
//|                                          ToolsPalette_Shapes.mqh |
//|                           Copyright 2026, Allan Munene Mutiiria. |
//|                                   https://t.me/Forex_Algo_Trader |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Allan Munene Mutiiria."
#property link "https://t.me/Forex_Algo_Trader"
#property version "1.00"
#property strict

//--- Guard against multiple inclusion of this header
#ifndef TOOLS_PALETTE_SHAPES_MQH
#define TOOLS_PALETTE_SHAPES_MQH

//--- Pull in CFibonacciTools (the parent class in the tool chain)
#include "ToolsPalette_Fibonacci.mqh"

//+------------------------------------------------------------------+
//| CShapeTools owns the geometric shape drawing and hit-test paths  |
//+------------------------------------------------------------------+
class CShapeTools : public CFibonacciTools
  {
public:
   //--- Rectangle: 2 stored anchors (opposite corners) + 8 derived handles
   void   DrawRectangleOn(CCanvas &canvas, int x1, int y1, int x2, int y2,
                           color objColor, bool selected, bool hovered,
                           int lineWidth = 2, int lineOpacity = 100,
                           int lineStyle = 0,
                           color fillColor = clrNONE, int fillOpacity = 30);

   //--- Triangle: 3 vertex anchors (P1, P2, P3); each handle drags one vertex
   void   DrawTriangleOn(CCanvas &canvas,
                          int x1, int y1, int x2, int y2, int x3, int y3,
                          color objColor, bool selected, bool hovered,
                          int lineWidth = 2, int lineOpacity = 100,
                          int lineStyle = 0,
                          color fillColor = clrNONE, int fillOpacity = 30);
   bool   HitTestTriangle(int mx, int my,
                           int x1, int y1, int x2, int y2, int x3, int y3,
                           int threshold);
   //--- Sign-of-cross-product point-in-triangle test (helper for HitTestTriangle)
   bool   HitTestTriangleInside(int mx, int my,
                                 int x1, int y1, int x2, int y2, int x3, int y3);

   //--- Rotated Ellipse: P1, P2 = major-axis endpoints; P3 sets perpendicular semi-minor distance
   void   DrawEllipseOn(CCanvas &canvas, int x1, int y1, int x2, int y2, int x3, int y3,
                         color objColor, bool selected, bool hovered,
                         int lineWidth = 2, int lineOpacity = 100,
                         int lineStyle = 0,
                         color fillColor = clrNONE, int fillOpacity = 30);
   bool   HitTestEllipseRotated(int mx, int my,
                                 int x1, int y1, int x2, int y2, int x3, int y3,
                                 int threshold);

   //--- Compute the 6 handle positions for the rotated rectangle (canonical TL/TR/BR/BL order)
   void   ComputeRotatedRectHandles(int x1, int y1, int x2, int y2, int x3, int y3,
                                     int &outX[], int &outY[]);
   //--- Rotated Rectangle: P1-P2 sets the length/axis; P3 inflates the perpendicular width
   void   DrawRotatedRectangleOn(CCanvas &canvas,
                                  int x1, int y1, int x2, int y2, int x3, int y3,
                                  color objColor, bool selected, bool hovered,
                                  int lineWidth = 2, int lineOpacity = 100,
                                  int lineStyle = 0,
                                  color fillColor = clrNONE, int fillOpacity = 30);
   bool   HitTestRotatedRectangle(int mx, int my,
                                   int x1, int y1, int x2, int y2, int x3, int y3,
                                   int threshold);

   //--- Path (polyline): N-point arrays; draws N-1 SDF AA segments + optional arrowhead
   void   DrawPathOn(CCanvas &canvas,
                      const int &xs[], const int &ys[],
                      color objColor, bool selected, bool hovered,
                      bool drawArrowhead = true,
                      int lineWidth = 2, int lineOpacity = 100,
                      int lineStyle = 0);
   bool   HitTestPath(int mx, int my, const int &xs[], const int &ys[], int threshold);

   //--- Circle: P1 = center, P2 = border point; radius = screen-distance(P1, P2)
   void   DrawCircleOn(CCanvas &canvas,
                        int cx, int cy, int bx, int by,
                        color objColor, bool selected, bool hovered,
                        bool hideCenterHandle,
                        int lineWidth = 2, int lineOpacity = 100,
                        int lineStyle = 0,
                        color fillColor = clrNONE, int fillOpacity = 30);
   bool   HitTestCircle(int mx, int my, int cx, int cy, int bx, int by, int threshold);

   //--- Arc: 3-click quadratic Bezier (P1=start, P2=end, P3=clamped apex); chord-enclosed fill
   void   DrawArcOn(CCanvas &canvas,
                     int x1, int y1, int x2, int y2, int x3, int y3,
                     color objColor, bool selected, bool hovered,
                     int lineWidth = 2, int lineOpacity = 100,
                     int lineStyle = 0,
                     color fillColor = clrNONE, int fillOpacity = 30);
   bool   HitTestArc(int mx, int my, int x1, int y1, int x2, int y2, int x3, int y3,
                      int threshold);
   //--- Compute the clamped apex (apX, apY) and the X-component of the Bezier control point
   bool   ArcCircumcircle(int x1, int y1, int x2, int y2, int x3, int y3,
                           double &apX, double &apY, double &cpX);

   //--- Curve: 3-click quadratic Bezier with FREE apex (no clamp, no fill, no chord)
   void   DrawCurveOn(CCanvas &canvas,
                       int x1, int y1, int x2, int y2, int x3, int y3,
                       color objColor, bool selected, bool hovered,
                       int lineWidth = 2, int lineOpacity = 100,
                       int lineStyle = 0);
   bool   HitTestCurve(int mx, int my, int x1, int y1, int x2, int y2, int x3, int y3,
                        int threshold);
  };

Сначала мы защищаем заголовочный файл от повторного включения с помощью макроса TOOLS_PALETTE_SHAPES_MQH, а затем подключаем заголовочный файл инструментов Фибоначчи. Чтобы получить доступ к примитивам альфа-композитинга, заливке многоугольников по строкам развёртки, вспомогательной функции определения конечных точек регрессии и двухпроходному рендереру меток из предыдущих частей, мы наследуемся от CFibonacciTools, поэтому повторно объявлять их здесь не требуется.

Далее мы объявляем восемь инструментов рисования фигур, каждый со своим тестером попадания. Чтобы не усложнять два самых простых инструмента, мы задаём для DrawRectangleOn и DrawTriangleOn  соответственно две и три опорные точки, а также полупрозрачную заливку и обводку границы. Затем мы переходим к функциям DrawEllipseOn и DrawRotatedRectangleOn, каждая из которых принимает три опорные точки: первые две определяют большую ось или длину, а третья — размер в перпендикулярном направлении. Чтобы индексы маркеров повернутого прямоугольника оставались неизменными независимо от того, по какую сторону оси находится третья опорная точка, мы добавляем вспомогательную функцию ComputeRotatedRectHandles, которая определяет положения шести маркеров в каноническом визуальном порядке: верхняя левая, верхняя правая, нижняя правая, нижняя левая, затем середины двух боковых сторон.

Далее мы объявляем функцию DrawPathOn для инструмента "контур", представляющего собой ломаную из N точек; вместо обычной сигнатуры P1/P2/P3 функция принимает параллельные массивы пиксельных координат, чтобы движок мог построить контур по хранящимся в объекте массивам времени и цены. Чтобы реализовать функцию рисования круга двумя щелчками, мы добавляем функцию DrawCircleOn, в которой P1 является центром, а P2 находится на границе. Наконец, мы дополняем это семейство функциями DrawArcOn и DrawCurveOn — двумя вариантами квадратичной кривой Безье: дуга ограничивает положение третьей опорной точки областью, перпендикулярной хорде, и заливает замкнутую область, тогда как кривая оставляет вершину свободной и совсем не использует заливку. Чтобы при размещении и отрисовке использовались одни и те же формулы для вычисления положения вершины с учётом ограничения и координаты X вычисляемой по ней управляющей точки Безье, мы используем в обоих случаях общую вспомогательную функцию ArcCircumcircle. Объявив интерфейс, переходим к реализации. Начнём с треугольника (3 маркера); в остальных инструментах используется тот же подход к проверке попадания и сглаживанию границ.

Рисование треугольника и проверка попадания

Треугольник — первый инструмент в этой части, для которого границу нельзя нарисовать простым сканированием вдоль координатных осей, поскольку все три стороны расположены под произвольными углами. Чтобы аккуратно решить эту задачу, мы вводим сглаживание по знаковому расстоянию для границы, которое затем будем использовать для всех повернутых фигур и фигур, не выровненных по координатным осям, в этом файле.

//+------------------------------------------------------------------+
//| Draw a Triangle: 30% fill + SDF-AA or dashed border + 3 handles  |
//+------------------------------------------------------------------+
void CShapeTools::DrawTriangleOn(CCanvas &canvas,
                                  int x1, int y1, int x2, int y2, int x3, int y3,
                                  color objColor, bool selected, bool hovered,
                                  int lineWidth = 2, int lineOpacity = 100,
                                  int lineStyle = 0,
                                  color fillColor = clrNONE, int fillOpacity = 30)
  {
   //--- Clamp the line width and style into the supported ranges
   if(lineWidth < 1) lineWidth = 1;
   if(lineWidth > 4) lineWidth = 4;
   if(lineStyle < 0) lineStyle = 0;
   if(lineStyle > 3) lineStyle = 3;
   //--- fillColor=clrNONE means "use the object's stroke color for the fill"
   color fc = (fillColor == clrNONE) ? objColor : fillColor;
   const int thick = lineWidth;
   //--- Interior fill at fillOpacity% alpha via the inherited HR triangle rasterizer
   const uint fillArgb = ColorWithPercentOpacity(fc, fillOpacity);
   FillTriangleHR(canvas, x1, y1, x2, y2, x3, y3, fillArgb);
   //--- Border stroke color at lineOpacity% alpha
   const uint borderFullArgb = ColorWithPercentOpacity(objColor, lineOpacity);
   //--- Dashed/dotted/dash-dot border: render each edge with the dashed AA path
   if(lineStyle != 0)
     {
      //--- Build the stroke pattern; n>0 means a valid pattern was produced
      int pat[];
      const int n = BuildLineStylePattern(lineStyle, thick, pat);
      if(n > 0)
        {
         //--- Render the 3 dashed edges in order
         WidgetDashedLineAA(canvas, x1, y1, x2, y2, thick, borderFullArgb, pat);
         WidgetDashedLineAA(canvas, x2, y2, x3, y3, thick, borderFullArgb, pat);
         WidgetDashedLineAA(canvas, x3, y3, x1, y1, thick, borderFullArgb, pat);
         //--- Handles when selected/hovered (early return so we skip the solid SDF path below)
         if(selected || hovered)
           {
            if(m_hideHandleIdx != 0) DrawHandleOnCanvas(canvas, x1, y1, selected, objColor, m_haloHandleIdx == 0);
            if(m_hideHandleIdx != 1) DrawHandleOnCanvas(canvas, x2, y2, selected, objColor, m_haloHandleIdx == 1);
            if(m_hideHandleIdx != 2) DrawHandleOnCanvas(canvas, x3, y3, selected, objColor, m_haloHandleIdx == 2);
           }
         return;
        }
      //--- Pattern build failed: fall through to the solid SDF AA border path below
     }
   //--- Solid SDF AA border: scan the bounding box and compute distance to nearest triangle edge
   uint  borderRGBmask  = borderFullArgb & 0x00FFFFFF;
   const uchar borderAlpha = (uchar)((borderFullArgb >> 24) & 0xFF);
   //--- Bounding box of the 3 vertices (with 1px padding for AA boundary)
   int xLo = x1; if(x2 < xLo) xLo = x2; if(x3 < xLo) xLo = x3;
   int xHi = x1; if(x2 > xHi) xHi = x2; if(x3 > xHi) xHi = x3;
   int yLo = y1; if(y2 < yLo) yLo = y2; if(y3 < yLo) yLo = y3;
   int yHi = y1; if(y2 > yHi) yHi = y2; if(y3 > yHi) yHi = y3;
   //--- Cache canvas extents and clip the bounding box accordingly
   int cWT = canvas.Width(), cHT = canvas.Height();
   xLo -= 1; yLo -= 1; xHi += 1; yHi += 1;
   if(xLo < 0)     xLo = 0;
   if(yLo < 0)     yLo = 0;
   if(xHi >= cWT)  xHi = cWT - 1;
   if(yHi >= cHT)  yHi = cHT - 1;
   //--- Cache half-thickness for the coverage formula
   double halfThick = (double)thick * 0.5;
   //--- Walk every pixel in the bounding box and compute its border coverage
   for(int yy = yLo; yy <= yHi; yy++)
     {
      for(int xx = xLo; xx <= xHi; xx++)
        {
         //--- Distance from the pixel to each of the 3 triangle edges
         double d1 = PointToSegmentDistance(xx, yy, x1, y1, x2, y2);
         double d2 = PointToSegmentDistance(xx, yy, x2, y2, x3, y3);
         double d3 = PointToSegmentDistance(xx, yy, x3, y3, x1, y1);
         //--- Use the smallest distance for the coverage calculation
         double dMin = d1;
         if(d2 < dMin) dMin = d2;
         if(d3 < dMin) dMin = d3;
         //--- Coverage shrinks linearly with distance from the nearest edge centerline
         double cov = halfThick + 0.5 - dMin;
         if(cov <= 0.0) continue;
         if(cov > 1.0) cov = 1.0;
         //--- Compose the coverage-weighted alpha and blend the pixel
         uchar aCov = (uchar)((double)borderAlpha * cov + 0.5);
         uint  covArgb = ((uint)aCov << 24) | borderRGBmask;
         ChannelBlendPixelSet(canvas, xx, yy, covArgb);
        }
     }
   //--- 3 vertex handles when selected/hovered
   if(selected || hovered)
     {
      if(m_hideHandleIdx != 0) DrawHandleOnCanvas(canvas, x1, y1, selected, objColor, m_haloHandleIdx == 0);
      if(m_hideHandleIdx != 1) DrawHandleOnCanvas(canvas, x2, y2, selected, objColor, m_haloHandleIdx == 1);
      if(m_hideHandleIdx != 2) DrawHandleOnCanvas(canvas, x3, y3, selected, objColor, m_haloHandleIdx == 2);
     }
  }

//+------------------------------------------------------------------+
//| Point-in-triangle test via sign of cross products                |
//+------------------------------------------------------------------+
bool CShapeTools::HitTestTriangleInside(int mx, int my,
                                         int x1, int y1, int x2, int y2, int x3, int y3)
  {
   //--- Cross-product sign for each triangle edge relative to the cursor point
   double d1 = (double)(mx - x2) * (double)(y1 - y2) - (double)(x1 - x2) * (double)(my - y2);
   double d2 = (double)(mx - x3) * (double)(y2 - y3) - (double)(x2 - x3) * (double)(my - y3);
   double d3 = (double)(mx - x1) * (double)(y3 - y1) - (double)(x3 - x1) * (double)(my - y1);
   //--- Inside the triangle iff all signs are the same (no mix of positive and negative)
   bool hasNeg = (d1 < 0) || (d2 < 0) || (d3 < 0);
   bool hasPos = (d1 > 0) || (d2 > 0) || (d3 > 0);
   return !(hasNeg && hasPos);
  }

//+------------------------------------------------------------------+
//| Hit-test Triangle: interior + edge proximity within threshold    |
//+------------------------------------------------------------------+
bool CShapeTools::HitTestTriangle(int mx, int my,
                                   int x1, int y1, int x2, int y2, int x3, int y3,
                                   int threshold)
  {
   //--- Interior hit always counts
   if(HitTestTriangleInside(mx, my, x1, y1, x2, y2, x3, y3)) return true;
   //--- Edge proximity test for each of the 3 triangle edges
   if(PointToSegmentDistance(mx, my, x1, y1, x2, y2) <= threshold) return true;
   if(PointToSegmentDistance(mx, my, x2, y2, x3, y3) <= threshold) return true;
   if(PointToSegmentDistance(mx, my, x3, y3, x1, y1) <= threshold) return true;
   return false;
  }

Мы определяем функцию DrawTriangleOn так, чтобы она принимала три опорные точки и отображала внутреннюю заливку, границу и три маркера вершин именно в таком порядке. После приведения ширины и стиля линии к допустимым значениям мы определяем цвет заливки (по умолчанию используется цвет объекта, если вызывающая сторона передала clrNONE) и заливаем внутреннюю область с непрозрачностью fillOpacity процентов с помощью унаследованной вспомогательной функции FillTriangleHR.

Для пунктирных границ мы последовательно обходим три стороны и обводим каждую с помощью WidgetDashedLineAA, передавая шаблон, построенный функцией BuildLineStylePattern. Чтобы избежать повторного рисования маркеров в этой ветви кода, мы рисуем их прямо здесь и сразу выходим из функции. Если по какой-либо причине построить шаблон не удаётся, в качестве запасного варианта выполнение переходит к расположенному ниже коду рисования сплошной границы на основе SDF.

Для сплошных границ мы используем сглаживание по знаковому расстоянию. Идея проста: вместо того чтобы растрировать каждую сторону отдельно и продумывать их соединение в вершинах, мы вычисляем ограничивающий прямоугольник для всех трёх вершин, обходим каждый пиксель в нём и с помощью PointToSegmentDistance определяем расстояние от пикселя до ближайшей из трёх сторон треугольника. По этому минимальному расстоянию мы вычисляем значение субпиксельного покрытия: пиксели на осевой линии получают полное покрытие, пиксели на расстоянии ровно в половину толщины границы — нулевое, а между ними покрытие линейно убывает. Это значение покрытия масштабирует альфа-компонент исходного цвета перед смешиванием пикселя с помощью ChannelBlendPixelSet. Поскольку для каждого пикселя выполняется один и тот же расчёт минимального расстояния, стороны естественным образом стыкуются во всех трёх вершинах без швов от наложения.

При проверке попадания функция HitTestTriangleInside определяет, находится ли точка внутри треугольника, по знаку векторного произведения: для каждой стороны мы вычисляем векторное произведение вектора стороны и вектора от её начальной точки к указателю мыши; если все три знака совпадают, указатель находится внутри. Внешняя функция-обёртка HitTestTriangle объединяет эту проверку внутренней области с проверками близости к каждой из трёх сторон с помощью PointToSegmentDistance, поэтому щелчок по границе чуть за пределами внутренней области всё равно считается попаданием, если расстояние не превышает порога. По той же логике мы реализуем и другие фигуры, например прямоугольники. Для эллипса используется тот же подход, что и для круга, поэтому мы опишем логику работы с эллипсом.

Рисование повернутого эллипса и проверка попадания в него

Повернутый эллипс задаётся тремя опорными точками: P1 и P2 обозначают концы большой оси, а P3 может находиться в любой точке плоскости и задаёт длину малой полуоси своим перпендикулярным расстоянием до большой оси. При отрисовке используется тот же принцип сглаживания по знаковому расстоянию, что и для треугольника, но применяется он к неявному уравнению эллипса, а не к трём отрезкам.

//+------------------------------------------------------------------+
//| Draw a rotated Ellipse: 30% fill + SDF AA border + 4 handles     |
//+------------------------------------------------------------------+
void CShapeTools::DrawEllipseOn(CCanvas &canvas,
                                 int x1, int y1, int x2, int y2, int x3, int y3,
                                 color objColor, bool selected, bool hovered,
                                 int lineWidth = 2, int lineOpacity = 100,
                                 int lineStyle = 0,
                                 color fillColor = clrNONE, int fillOpacity = 30)
  {
   //--- Clamp the line width into the [1, 4] px range
   if(lineWidth < 1) lineWidth = 1;
   if(lineWidth > 4) lineWidth = 4;
   //--- fillColor=clrNONE means "use the object's stroke color for the fill"
   color fc = (fillColor == clrNONE) ? objColor : fillColor;
   const int thick = lineWidth;
   //--- Center = midpoint of the major axis (P1-P2)
   double cx = (x1 + x2) * 0.5;
   double cy = (y1 + y2) * 0.5;
   //--- Major-axis vector and length; reject degenerate ellipses
   double dxM = (double)(x2 - x1);
   double dyM = (double)(y2 - y1);
   double lenM = MathSqrt(dxM * dxM + dyM * dyM);
   if(lenM < 2.0) return;
   //--- Semi-major (a) = half of the major-axis length
   double a = lenM * 0.5;
   //--- Rotation angle's cosine and sine come from the major-axis direction
   double cosT = dxM / lenM;
   double sinT = dyM / lenM;
   //--- P3 relative to the center; its perpendicular projection onto the minor axis = b
   double dx3 = (double)x3 - cx;
   double dy3 = (double)y3 - cy;
   double b   = MathAbs(-dx3 * sinT + dy3 * cosT);
   //--- Clamp the semi-minor to at least 1 pixel so degenerate ellipses still render
   if(b < 1.0) b = 1.0;
   //--- Fill color at fillOpacity% alpha
   const uint fillArgb = ColorWithPercentOpacity(fc, fillOpacity);
   //--- Cache canvas extents for the bounding-box clip
   int   cWE       = canvas.Width();
   int   cHE       = canvas.Height();
   //--- Axis-aligned bounding box of the rotated ellipse (from the extremum formula)
   double halfW = MathSqrt(a * a * cosT * cosT + b * b * sinT * sinT);
   double halfH = MathSqrt(a * a * sinT * sinT + b * b * cosT * cosT);
   int   bxLo = (int)MathFloor(cx - halfW) - 1;
   int   bxHi = (int)MathCeil (cx + halfW) + 1;
   int   byLo = (int)MathFloor(cy - halfH) - 1;
   int   byHi = (int)MathCeil (cy + halfH) + 1;
   //--- Clip the bounding box to canvas bounds
   if(bxLo < 0)    bxLo = 0;
   if(byLo < 0)    byLo = 0;
   if(bxHi >= cWE) bxHi = cWE - 1;
   if(byHi >= cHE) byHi = cHE - 1;
   //--- Cached squared semi-axes for the ellipse-equation tests
   double aSq = a * a;
   double bSq = b * b;
   //--- PASS 1: interior fill - walk bounding box and paint pixels where F<=1
   for(int yy = byLo; yy <= byHi; yy++)
     {
      for(int xx = bxLo; xx <= bxHi; xx++)
        {
         //--- Translate to center origin, then inverse-rotate into the ellipse's local (u, v) frame
         double dxp =  (double)xx - cx;
         double dyp =  (double)yy - cy;
         double u   =  dxp * cosT + dyp * sinT;
         double v   = -dxp * sinT + dyp * cosT;
         //--- Ellipse equation: F = (u^2)/(a^2) + (v^2)/(b^2). F<=1 means inside
         double F   = (u * u) / aSq + (v * v) / bSq;
         if(F <= 1.0)
            ChannelBlendPixelSet(canvas, xx, yy, fillArgb);
        }
     }
   //--- PASS 2: SDF AA border - signed-distance approximation to the ellipse boundary
   uint  borderFullArgb = ColorWithPercentOpacity(objColor, lineOpacity);
   uint  borderRGBmask  = borderFullArgb & 0x00FFFFFF;
   const uchar borderAlpha = (uchar)((borderFullArgb >> 24) & 0xFF);
   double halfThick = (double)thick * 0.5;
   //--- Safety margin so the bounding box covers the AA boundary
   double safety = halfThick + 1.5;
   //--- Walk every pixel in the bounding box and compute its border coverage
   for(int yy = byLo; yy <= byHi; yy++)
     {
      for(int xx = bxLo; xx <= bxHi; xx++)
        {
         //--- Translate to center origin and inverse-rotate into the ellipse's local frame
         double dxp =  (double)xx - cx;
         double dyp =  (double)yy - cy;
         double u   =  dxp * cosT + dyp * sinT;
         double v   = -dxp * sinT + dyp * cosT;
         //--- Quick reject: skip pixels well outside the [a + safety, b + safety] envelope
         double absU = MathAbs(u);
         double absV = MathAbs(v);
         if(absU > a + safety || absV > b + safety) continue;
         //--- Ellipse equation and its square root (used as the F-distance to the boundary)
         double F   = (u * u) / aSq + (v * v) / bSq;
         double sqrtF = MathSqrt(F);
         if(sqrtF < 1e-9) continue;
         //--- Gradient magnitude (used to convert F into approximate Euclidean distance)
         double gu = u / aSq;
         double gv = v / bSq;
         double gmag = MathSqrt(gu * gu + gv * gv);
         if(gmag < 1e-12) continue;
         //--- Perpendicular distance from the pixel to the ellipse boundary
         double dist = MathAbs((sqrtF - 1.0) / gmag);
         //--- Edge-case rejects outside the ellipse: prevent the AA from leaking into far pixels
         if(absV > b + halfThick + 1.0 && sqrtF > 1.0) continue;
         if(absU > a + halfThick + 1.0 && sqrtF > 1.0) continue;
         //--- Coverage shrinks linearly with distance from the boundary centerline
         double cov  = halfThick + 0.5 - dist;
         if(cov <= 0.0) continue;
         if(cov > 1.0) cov = 1.0;
         //--- Compose the coverage-weighted alpha and blend the pixel
         uchar aCov = (uchar)((double)borderAlpha * cov + 0.5);
         uint  covArgb = ((uint)aCov << 24) | borderRGBmask;
         ChannelBlendPixelSet(canvas, xx, yy, covArgb);
        }
     }
   //--- 4 handles when selected or hovered: 2 major-axis ends + 2 minor-axis ends
   if(selected || hovered)
     {
      //--- P3's sign determines which side of the major axis the (+) minor handle lands on
      double perpSide = -dx3 * sinT + dy3 * cosT;
      double signP3 = (perpSide >= 0.0) ? 1.0 : -1.0;
      //--- Perpendicular unit vector pointing toward P3's side of the major axis
      double perpX = -sinT * signP3;
      double perpY =  cosT * signP3;
      //--- Major-axis handles sit at the stored P1 and P2 positions
      int h0x = x1,                               h0y = y1;
      int h1x = x2,                               h1y = y2;
      //--- Minor-axis handles sit at center +/- b along the perpendicular
      int h2x = (int)MathRound(cx + perpX * b);   int h2y = (int)MathRound(cy + perpY * b);
      int h3x = (int)MathRound(cx - perpX * b);   int h3y = (int)MathRound(cy - perpY * b);
      //--- Render the 4 handles honoring hide/halo state
      if(m_hideHandleIdx != 0) DrawHandleOnCanvas(canvas, h0x, h0y, selected, objColor, m_haloHandleIdx == 0);
      if(m_hideHandleIdx != 1) DrawHandleOnCanvas(canvas, h1x, h1y, selected, objColor, m_haloHandleIdx == 1);
      if(m_hideHandleIdx != 2) DrawHandleOnCanvas(canvas, h2x, h2y, selected, objColor, m_haloHandleIdx == 2);
      if(m_hideHandleIdx != 3) DrawHandleOnCanvas(canvas, h3x, h3y, selected, objColor, m_haloHandleIdx == 3);
     }
  }

//+------------------------------------------------------------------+
//| Hit-test rotated Ellipse: inside-ellipse or near boundary        |
//+------------------------------------------------------------------+
bool CShapeTools::HitTestEllipseRotated(int mx, int my,
                                         int x1, int y1, int x2, int y2, int x3, int y3,
                                         int threshold)
  {
   //--- Center of the rotated ellipse = midpoint of the major axis (P1-P2)
   double cx = (x1 + x2) * 0.5;
   double cy = (y1 + y2) * 0.5;
   //--- Major-axis vector and length; reject degenerate ellipses
   double dxM = (double)(x2 - x1);
   double dyM = (double)(y2 - y1);
   double lenM = MathSqrt(dxM * dxM + dyM * dyM);
   if(lenM < 2.0) return false;
   //--- Semi-major (a) and rotation cosine/sine
   double a = lenM * 0.5;
   double cosT = dxM / lenM;
   double sinT = dyM / lenM;
   //--- Semi-minor (b) = perpendicular distance from P3 to the major axis
   double dx3 = (double)x3 - cx;
   double dy3 = (double)y3 - cy;
   double b   = MathAbs(-dx3 * sinT + dy3 * cosT);
   if(b < 1.0) b = 1.0;
   //--- Translate the cursor to center origin and inverse-rotate into the ellipse's local frame
   double dxp =  (double)mx - cx;
   double dyp =  (double)my - cy;
   double u   =  dxp * cosT + dyp * sinT;
   double v   = -dxp * sinT + dyp * cosT;
   //--- F<=1 means inside the ellipse: interior hit
   double F   = (u * u) / (a * a) + (v * v) / (b * b);
   if(F <= 1.0) return true;
   //--- Outside the ellipse: estimate distance to boundary via gradient magnitude
   double sqrtF = MathSqrt(F);
   if(sqrtF < 1e-9) return true;
   double gu = u / (a * a);
   double gv = v / (b * b);
   double gmag = MathSqrt(gu * gu + gv * gv);
   if(gmag < 1e-12) return true;
   double dist = MathAbs((sqrtF - 1.0) / gmag);
   //--- Hit iff cursor is within threshold pixels of the ellipse boundary
   return (dist <= (double)threshold);
  }

Мы начинаем реализацию функции DrawEllipseOn с вычисления центра как середины отрезка между точками P1 и P2 и определения большой полуоси (a) как половины расстояния между ними. Косинус и синус угла поворота получаются из компонент вектора направления большой оси, делённых на его длину, поэтому нет необходимости вызывать MathAtan2, а затем отдельно MathCos и MathSin. Чтобы получить малую полуось (b), мы с помощью скалярного произведения проецируем смещение P3 на перпендикулярное направление, берём модуль результата и ограничиваем его снизу одним пикселем, чтобы даже вырожденные эллипсы оставались видимыми.

При заливке внутренней области мы обходим ограничивающий прямоугольник повернутого эллипса, вычисленный по формуле экстремумов, чтобы охватить эллипс целиком при любом угле поворота; для каждого пикселя переносим начало координат в центр эллипса и обратным поворотом переводим координаты в локальную систему эллипса. Затем стандартное уравнение эллипса F = u^2/a^2 + v^2/b^2 позволяет определить, находится ли пиксель внутри: все пиксели, для которых F <= 1.0, смешиваются с помощью ChannelBlendPixelSet с альфа-значением заливки. Давайте наглядно представим геометрию эллипса, чтобы было проще следить за ходом рассуждений.

ГЕОМЕТРИЯ ЭЛЛИПСА

Для границы мы используем тот же подход на основе знакового расстояния, который применяли для треугольника, но теперь расстояние до границы определяется по неявно заданной кривой, а не по отрезкам. Вместо вычисления точного расстояния по перпендикуляру (для чего потребовалось бы итеративно искать ближайшую точку на эллипсе) мы приближённо определяем его по модулю градиента уравнения эллипса: выражение (sqrt(F) - 1) / |gradient| даёт знаковое расстояние, точное до первого порядка вблизи границы, то есть именно в полосе сглаживания. Две проверки граничных случаев отсекают пиксели, расположенные далеко за пределами эллипса, не давая сглаживанию затрагивать их; затем та же формула покрытия преобразует расстояние в альфа-значение для смешивания с субпиксельной точностью.

При выделении эллипса или наведении на него указателя мыши мы отображаем четыре маркера: две — в сохранённых позициях P1 и P2 на концах большой оси, а ещё две — в точках, полученных прибавлением к центру и вычитанием из него перпендикулярного вектора, умноженного на b. Знак проекции P3 показывает, с какой стороны большой оси находилась исходная точка P3; мы используем этот знак, чтобы при необходимости изменить направление перпендикулярного вектора на противоположное, так что третий маркер (с индексом 2) всегда оказывается с той же стороны, где была размещена P3.

HitTestEllipseRotated использует то же преобразование координат и то же уравнение эллипса. Если значение F в позиции указателя мыши не превышает 1,0, указатель находится внутри эллипса; в противном случае мы оцениваем расстояние по модулю градиента и регистрируем попадание, если расстояние от указателя до границы не превышает порогового значения в пикселях. Далее мы определим инструмент "Контур"; ключевое нововведение здесь — алгоритм построения наконечника стрелки, поскольку логика рисования линий уже неоднократно рассматривалась.

Рисование контура и проверка попадания для инструмента "Контур"

Инструмент "Контур" представляет собой полилинию из N точек: вместо фиксированных опорных точек P1/P2/P3 он хранит произвольное число вершин в параллельных массивах координат, рисует соединяющие отрезки как единую полилинию с обводкой и при необходимости добавляет наконечник стрелки на конце последнего отрезка.

//+------------------------------------------------------------------+
//| Draw a Path (polyline): N-1 SDF segments + optional arrowhead    |
//+------------------------------------------------------------------+
void CShapeTools::DrawPathOn(CCanvas &canvas,
                              const int &xs[], const int &ys[],
                              color objColor, bool selected, bool hovered,
                              bool drawArrowhead,
                              int lineWidth = 2, int lineOpacity = 100,
                              int lineStyle = 0)
  {
   //--- Reject paths with fewer than 2 points (no segments to render)
   int N = ArraySize(xs);
   if(N < 2) return;
   //--- Clamp line width and style into supported ranges
   if(lineWidth < 1) lineWidth = 1;
   if(lineWidth > 4) lineWidth = 4;
   if(lineStyle < 0) lineStyle = 0;
   if(lineStyle > 3) lineStyle = 3;
   const int thick = lineWidth;
   //--- Border stroke ARGB and unpacked alpha/RGB for coverage-weighted blending
   const uint  borderFullArgb = ColorWithPercentOpacity(objColor, lineOpacity);
   uint  borderRGBmask  = borderFullArgb & 0x00FFFFFF;
   const uchar borderAlpha = (uchar)((borderFullArgb >> 24) & 0xFF);
   //--- Cache half-thickness and canvas extents for the per-segment scan
   double halfThick = (double)thick * 0.5;
   int cW = canvas.Width();
   int cH = canvas.Height();
   //--- Walk every segment in the polyline (N-1 segments for N points)
   for(int s = 0; s < N - 1; s++)
     {
      //--- Endpoints of this segment
      int ax = xs[s],     ay = ys[s];
      int bx = xs[s + 1], by = ys[s + 1];
      //--- Dashed/dotted/dash-dot path: build a stroke pattern and dispatch dashed AA
      if(lineStyle != 0)
        {
         int pat[];
         const int n = BuildLineStylePattern(lineStyle, thick, pat);
         if(n > 0)
           {
            WidgetDashedLineAA(canvas, ax, ay, bx, by, thick, borderFullArgb, pat);
            continue;
           }
        }
      //--- Solid SDF AA path: scan the segment's bounding box for per-pixel coverage
      int xLo = (ax < bx) ? ax : bx;
      int xHi = (ax < bx) ? bx : ax;
      int yLo = (ay < by) ? ay : by;
      int yHi = (ay < by) ? by : ay;
      //--- 2px padding around the bounding box for AA boundary
      xLo -= 2;  xHi += 2;  yLo -= 2;  yHi += 2;
      //--- Clip the bounding box to canvas bounds
      if(xLo < 0)     xLo = 0;
      if(yLo < 0)     yLo = 0;
      if(xHi >= cW)   xHi = cW - 1;
      if(yHi >= cH)   yHi = cH - 1;
      //--- Walk every pixel in the bounding box and compute its segment coverage
      for(int yy = yLo; yy <= yHi; yy++)
        {
         for(int xx = xLo; xx <= xHi; xx++)
           {
            //--- Distance from the pixel to the segment
            double d = PointToSegmentDistance(xx, yy, ax, ay, bx, by);
            //--- Coverage shrinks linearly with distance from the segment centerline
            double cov = halfThick + 0.5 - d;
            if(cov <= 0.0) continue;
            if(cov > 1.0) cov = 1.0;
            //--- Compose the coverage-weighted alpha and blend the pixel
            uchar aCov = (uchar)((double)borderAlpha * cov + 0.5);
            uint  covArgb = ((uint)aCov << 24) | borderRGBmask;
            ChannelBlendPixelSet(canvas, xx, yy, covArgb);
           }
        }
     }
   //--- Arrowhead at the final vertex (two wing segments back along the last shaft direction)
   if(drawArrowhead && N >= 2)
     {
      //--- End vertex and the prior vertex (defines the incoming shaft direction)
      int ex = xs[N - 1];
      int ey = ys[N - 1];
      int px = xs[N - 2];
      int py = ys[N - 2];
      //--- Final segment vector and length
      double dxS = (double)(ex - px);
      double dyS = (double)(ey - py);
      double lenS = MathSqrt(dxS * dxS + dyS * dyS);
      //--- Skip arrowhead if the final segment is degenerate
      if(lenS >= 1.0)
        {
         //--- Unit direction along the final segment
         double ux = dxS / lenS;
         double uy = dyS / lenS;
         //--- Wing length and spread half-angle (each wing rotated +/-25deg from the shaft)
         double wingLen = 12.0;
         double wingAng = 25.0 * 3.14159265358979 / 180.0;
         double cA = MathCos(wingAng);
         double sA = MathSin(wingAng);
         //--- Two wing direction vectors (back along the shaft, rotated +/-25deg)
         double w1dx = -(ux * cA - uy * sA);
         double w1dy = -(uy * cA + ux * sA);
         double w2dx = -(ux * cA + uy * sA);
         double w2dy = -(uy * cA - ux * sA);
         //--- Wing endpoints in canvas coords
         int w1x = (int)MathRound((double)ex + w1dx * wingLen);
         int w1y = (int)MathRound((double)ey + w1dy * wingLen);
         int w2x = (int)MathRound((double)ex + w2dx * wingLen);
         int w2y = (int)MathRound((double)ey + w2dy * wingLen);
         //--- Pack the 2 wing endpoints into parallel arrays for the rendering loop
         int wxs[2] = {w1x, w2x};
         int wys[2] = {w1y, w2y};
         //--- Render each wing as an SDF AA segment from the tip back along the wing direction
         for(int w = 0; w < 2; w++)
           {
            //--- Bounding box of this wing segment with 2px AA padding
            int wxLo = (ex < wxs[w]) ? ex : wxs[w];
            int wxHi = (ex < wxs[w]) ? wxs[w] : ex;
            int wyLo = (ey < wys[w]) ? ey : wys[w];
            int wyHi = (ey < wys[w]) ? wys[w] : ey;
            wxLo -= 2; wxHi += 2; wyLo -= 2; wyHi += 2;
            //--- Clip the bounding box to canvas bounds
            if(wxLo < 0)    wxLo = 0;
            if(wyLo < 0)    wyLo = 0;
            if(wxHi >= cW)  wxHi = cW - 1;
            if(wyHi >= cH)  wyHi = cH - 1;
            //--- Walk every pixel in the wing's bounding box and compute its segment coverage
            for(int yy = wyLo; yy <= wyHi; yy++)
              {
               for(int xx = wxLo; xx <= wxHi; xx++)
                 {
                  //--- Distance from the pixel to the wing segment
                  double d = PointToSegmentDistance(xx, yy, ex, ey, wxs[w], wys[w]);
                  //--- Coverage shrinks linearly with distance from the segment centerline
                  double cov = halfThick + 0.5 - d;
                  if(cov <= 0.0) continue;
                  if(cov > 1.0) cov = 1.0;
                  //--- Compose the coverage-weighted alpha and blend the pixel
                  uchar aCov = (uchar)((double)borderAlpha * cov + 0.5);
                  uint  covArgb = ((uint)aCov << 24) | borderRGBmask;
                  ChannelBlendPixelSet(canvas, xx, yy, covArgb);
                 }
              }
           }
        }
     }
   //--- N handles when selected or hovered (one per path vertex)
   if(selected || hovered)
     {
      for(int hi = 0; hi < N; hi++)
         if(m_hideHandleIdx != hi)
            DrawHandleOnCanvas(canvas, xs[hi], ys[hi], selected, objColor, m_haloHandleIdx == hi);
     }
  }

//+------------------------------------------------------------------+
//| Hit-test Path: cursor within threshold of any of the N-1 segments|
//+------------------------------------------------------------------+
bool CShapeTools::HitTestPath(int mx, int my, const int &xs[], const int &ys[], int threshold)
  {
   //--- Reject paths with fewer than 2 points
   int N = ArraySize(xs);
   if(N < 2) return false;
   //--- Test every segment in turn; any match returns true
   for(int s = 0; s < N - 1; s++)
     {
      if(PointToSegmentDistance(mx, my, xs[s], ys[s], xs[s + 1], ys[s + 1]) <= threshold)
         return true;
     }
   return false;
  }

Мы определяем функцию DrawPathOn так, чтобы она принимала параллельные массивы xs и ys с координатами на холсте, а также флаг наличия наконечника стрелки. Если точек меньше двух, отрезков для рисования нет, поэтому мы сразу выходим из функции. После ограничения ширины и стиля линии допустимыми значениями мы один раз вычисляем альфа-значение границы и маску RGB вне цикла по отрезкам, затем перебираем все пары соседних вершин, чтобы нарисовать N - 1 отрезков.

Для штриховых стилей мы передаём каждый отрезок в WidgetDashedLineAA с шаблоном из BuildLineStylePattern. Для сплошных линий мы используем тот же подход к сглаживанию по знаковому расстоянию, который уже применяли для треугольника: строим ограничивающий прямоугольник вокруг отрезка, перебираем все пиксели внутри него, вычисляем расстояние до отрезка с помощью PointToSegmentDistance, определяем субпиксельное покрытие на основе линейного спада и выполняем смешивание через ChannelBlendPixelSet. Каждый отрезок рисуется независимо, но благодаря симметричному и непрерывному спаду покрытия, определяемого SDF, соседние отрезки с общей вершиной плавно соединяются без швов в местах перекрытия.

Наконечник стрелки в последней вершине — новый геометрический элемент, на котором стоит остановиться подробнее, поскольку инструмент аннотации "Стрелка" в следующем подразделе будет использовать точно такое же построение. Мы вычисляем единичный вектор направления последнего отрезка, затем поворачиваем его на +25 и −25 градусов и меняем знак полученных векторов, чтобы оба вектора боковых сторон наконечника были направлены назад вдоль стержня стрелки. Умножив каждый повернутый единичный вектор на фиксированную длину боковой стороны наконечника — 12 пикселей — и прибавив результат к конечной вершине, получаем концы двух боковых отрезков. Затем каждое крыло рисуется как отдельный сегмент со сглаживанием по знаковому расстоянию (SDF AA) с использованием того же тела цикла, что и для основного стержня стрелки, поэтому крылья имеют ту же толщину, сглаживание и непрозрачность, что и остальная часть полилинии.

Когда контур выделен или на него наведён указатель мыши, мы рисуем по одному маркеру для каждой сохранённой вершины, перебирая индексы от нуля до N - 1 и вызывая для каждой вершины функцию  DrawHandleOnCanvas с учётом заданных движком индексов скрытия и ореола.

HitTestPath работает по простому принципу — мы просматриваем каждый сегмент и проверяем расстояние до курсора с помощью функции PointToSegmentDistance. При попадании на любой сегмент сразу возвращается значение true. Проверка попадания во внутреннюю область не проводится, поскольку контуры представляют собой незамкнутые полилинии, а не замкнутые области. После добавления этой функциональности в движок получаем следующий результат.

ИНСТРУМЕНТ «КОНТУР» ДЛЯ АНАЛИЗА

Теперь определим логику работы инструмента "Дуга", в которой используется подход на основе дискретизации кривой Безье; это стоит отметить, чтобы в дальнейшем было проще к нему вернуться.

Рисование дуги и проверка попадания по ней

Дуга представляет собой квадратичную кривую Безье, задаваемую тремя щелчками, с заливкой области между кривой и хордой: P1 и P2 задают концы хорды, а третья опорная точка — высоту вершины над хордой. Мы ограничиваем положение вершины так, чтобы она лежала точно на срединном перпендикуляре к хорде и кривая всегда оставалась симметричной, а затем рисуем полупрозрачную заливку области между хордой и кривой и поверх неё — сглаженную обводку кривой.

//+------------------------------------------------------------------+
//| Compute the apex + Bezier control X for the Arc 3-click input    |
//+------------------------------------------------------------------+
bool CShapeTools::ArcCircumcircle(int x1, int y1, int x2, int y2, int x3, int y3,
                                   double &apX, double &apY, double &cpX)
  {
   //--- Chord vector and length; reject degenerate chords
   double chx = (double)(x2 - x1);
   double chy = (double)(y2 - y1);
   double chordLen = MathSqrt(chx * chx + chy * chy);
   if(chordLen < 2.0) return false;
   //--- Unit-along and unit-perpendicular vectors of the chord
   double ux = chx / chordLen;
   double uy = chy / chordLen;
   double nx = -uy;
   double ny =  ux;
   //--- Project P3 onto the perpendicular to get the signed perpendicular distance from the chord
   double dx3 = (double)x3 - (double)x1;
   double dy3 = (double)y3 - (double)y1;
   double perp = dx3 * nx + dy3 * ny;
   //--- Chord midpoint - the symmetric apex sits at midpoint + perp * perpendicular_unit
   double midCX = 0.5 * ((double)x1 + (double)x2);
   double midCY = 0.5 * ((double)y1 + (double)y2);
   //--- Symmetric apex on the perpendicular bisector at distance perp from the midpoint
   apX = midCX + perp * nx;
   apY = midCY + perp * ny;
   //--- Bezier control X = reflection of midpoint through apex (so the curve midpoint hits apex)
   cpX = 2.0 * apX - midCX;
   return true;
  }

//+------------------------------------------------------------------+
//| Evaluate a quadratic Bezier curve at parameter t                 |
//+------------------------------------------------------------------+
void ArcBezierEval(double p1x, double p1y, double cpX, double cpY,
                    double p2x, double p2y, double t,
                    double &outX, double &outY)
  {
   //--- Standard quadratic Bezier formula: B(t) = (1-t)^2*P1 + 2(1-t)t*CP + t^2*P2
   double u = 1.0 - t;
   outX = u * u * p1x + 2.0 * u * t * cpX + t * t * p2x;
   outY = u * u * p1y + 2.0 * u * t * cpY + t * t * p2y;
  }

//+------------------------------------------------------------------+
//| Approximate distance from a point to a quadratic Bezier curve    |
//+------------------------------------------------------------------+
double ArcDistToBezier(double px, double py,
                        double p1x, double p1y, double cpX, double cpY,
                        double p2x, double p2y)
  {
   //--- Sample the curve in 64 line segments and find the minimum point-to-segment distance
   const int N = 64;
   double prevX, prevY;
   //--- Start at t=0 (curve start point)
   ArcBezierEval(p1x, p1y, cpX, cpY, p2x, p2y, 0.0, prevX, prevY);
   double dMin = 1e18;
   //--- Walk every sample step and accumulate the minimum squared distance
   for(int i = 1; i <= N; i++)
     {
      //--- Evaluate the curve at parameter t for the current segment endpoint
      double t = (double)i / (double)N;
      double cx, cy;
      ArcBezierEval(p1x, p1y, cpX, cpY, p2x, p2y, t, cx, cy);
      //--- Segment vector and squared length for the projection math
      double sdx = cx - prevX;
      double sdy = cy - prevY;
      double slen2 = sdx * sdx + sdy * sdy;
      //--- Project the point onto the segment; clamp parameter to [0, 1]
      double tSeg = 0.0;
      if(slen2 > 1e-12)
         tSeg = ((px - prevX) * sdx + (py - prevY) * sdy) / slen2;
      if(tSeg < 0.0) tSeg = 0.0;
      if(tSeg > 1.0) tSeg = 1.0;
      //--- Compute the projected foot and its squared distance to the input point
      double qx = prevX + tSeg * sdx;
      double qy = prevY + tSeg * sdy;
      double dx = px - qx, dy = py - qy;
      double d2 = dx * dx + dy * dy;
      //--- Track the minimum squared distance across all segments
      if(d2 < dMin) dMin = d2;
      //--- Advance to the next segment's starting point
      prevX = cx; prevY = cy;
     }
   return MathSqrt(dMin);
  }

//+------------------------------------------------------------------+
//| Draw an Arc (quadratic Bezier): chord-enclosed fill + AA curve   |
//+------------------------------------------------------------------+
void CShapeTools::DrawArcOn(CCanvas &canvas,
                             int x1, int y1, int x2, int y2, int x3, int y3,
                             color objColor, bool selected, bool hovered,
                             int lineWidth, int lineOpacity,
                             int lineStyle,
                             color fillColor, int fillOpacity)
  {
   //--- Clamp line width into the [1, 4] px range
   if(lineWidth < 1) lineWidth = 1;
   if(lineWidth > 4) lineWidth = 4;
   //--- fillColor=clrNONE means "use the object's stroke color for the fill"
   color fc = (fillColor == clrNONE) ? objColor : fillColor;
   const int thick = lineWidth;
   //--- Compute the clamped apex and the Bezier control point X via the helper
   double apX = 0, apY = 0, cpX = 0;
   bool ok = ArcCircumcircle(x1, y1, x2, y2, x3, y3, apX, apY, cpX);
   //--- Degenerate chord: skip the curve render but still draw the 3 handles
   if(!ok)
     {
      if(selected || hovered)
        {
         if(m_hideHandleIdx != 0) DrawHandleOnCanvas(canvas, x1, y1, selected, objColor, m_haloHandleIdx == 0);
         if(m_hideHandleIdx != 1) DrawHandleOnCanvas(canvas, x2, y2, selected, objColor, m_haloHandleIdx == 1);
         if(m_hideHandleIdx != 2) DrawHandleOnCanvas(canvas, x3, y3, selected, objColor, m_haloHandleIdx == 2);
        }
      return;
     }
   //--- CP.y is the mirror of the chord midpoint Y through the apex Y
   double cpY = 2.0 * apY - 0.5 * ((double)y1 + (double)y2);
   //--- Cache endpoint coordinates as doubles for the Bezier math
   double p1x = (double)x1, p1y = (double)y1;
   double p2x = (double)x2, p2y = (double)y2;
   //--- Chord vector (used for side-of-chord testing)
   double chx = p2x - p1x;
   double chy = p2y - p1y;
   //--- Side of the chord that the apex sits on (sign of the cross product)
   double sideApex = chx * (apY - p1y) - chy * (apX - p1x);
   if(MathAbs(sideApex) < 1e-9) sideApex = 1.0;
   double signApex = (sideApex >= 0.0) ? 1.0 : -1.0;
   //--- Bounding box of the curve: start from chord endpoints, expand via sampled curve points
   double bMinX = MathMin(p1x, p2x);
   double bMaxX = MathMax(p1x, p2x);
   double bMinY = MathMin(p1y, p2y);
   double bMaxY = MathMax(p1y, p2y);
   //--- Sample the curve in 16 steps to find the true axis-aligned bounding box
   const int samp = 16;
   for(int i = 0; i <= samp; i++)
     {
      //--- Evaluate the Bezier curve at parameter t and expand the bounding box
      double t = (double)i / (double)samp;
      double cx_, cy_;
      ArcBezierEval(p1x, p1y, cpX, cpY, p2x, p2y, t, cx_, cy_);
      if(cx_ < bMinX) bMinX = cx_;
      if(cx_ > bMaxX) bMaxX = cx_;
      if(cy_ < bMinY) bMinY = cy_;
      if(cy_ > bMaxY) bMaxY = cy_;
     }
   //--- Integer bounding box with 2px AA padding
   int xLo = (int)MathFloor(bMinX) - 2;
   int xHi = (int)MathCeil (bMaxX) + 2;
   int yLo = (int)MathFloor(bMinY) - 2;
   int yHi = (int)MathCeil (bMaxY) + 2;
   //--- Cache canvas extents and clip the bounding box accordingly
   int cW = canvas.Width(), cH = canvas.Height();
   if(xLo < 0)    xLo = 0;
   if(yLo < 0)    yLo = 0;
   if(xHi >= cW)  xHi = cW - 1;
   if(yHi >= cH)  yHi = cH - 1;
   //--- Compose fill and border ARGB values + unpacked alpha/RGB masks
   const uint  fillArgb       = ColorWithPercentOpacity(fc, fillOpacity);
   const uint  borderFullArgb = ColorWithPercentOpacity(objColor, lineOpacity);
   const uint  borderRGBmask  = borderFullArgb & 0x00FFFFFF;
   const uchar borderBaseA    = (uchar)((borderFullArgb >> 24) & 0xFF);
   double halfThick = (double)thick * 0.5;
   //--- Chord unit-along (u) and unit-perpendicular (n) vectors
   double ux_c, uy_c, nx_c, ny_c;
   {
      double cLen = MathSqrt(chx * chx + chy * chy);
      ux_c = chx / cLen;  uy_c = chy / cLen;
      nx_c = -uy_c;       ny_c =  ux_c;
   }
   //--- Sample the Bezier curve into N line segments for the per-pixel distance + side-of-curve tests
   const int N = 64;
   double segAx[64], segAy[64], segBx[64], segBy[64];
   {
      //--- Walk every sample step and fill the segment endpoint arrays
      double prevX, prevY;
      ArcBezierEval(p1x, p1y, cpX, cpY, p2x, p2y, 0.0, prevX, prevY);
      for(int si = 0; si < N; si++)
        {
         //--- Current segment's end-of-segment point at parameter t
         double t = (double)(si + 1) / (double)N;
         double cx_, cy_;
         ArcBezierEval(p1x, p1y, cpX, cpY, p2x, p2y, t, cx_, cy_);
         segAx[si] = prevX; segAy[si] = prevY;
         segBx[si] = cx_;   segBy[si] = cy_;
         prevX = cx_; prevY = cy_;
        }
   }
   //--- Walk every pixel in the bounding box and compute fill + border coverage
   for(int yy = yLo; yy <= yHi; yy++)
     {
      for(int xx = xLo; xx <= xHi; xx++)
        {
         //--- Pixel relative to P1; decomposed into along-chord and perp-to-chord components
         double rx = (double)xx - p1x;
         double ry = (double)yy - p1y;
         double alongPx = rx * ux_c + ry * uy_c;
         //--- Signed perpendicular distance (positive on the apex side via signApex)
         double perpPx  = (rx * nx_c + ry * ny_c) * signApex;
         //--- Depth from the chord (positive inside the arc, negative outside)
         double depthChord = perpPx;
         //--- Find the minimum squared distance from the pixel to any of the curve's N sampled segments
         double dMin2 = 1e18;
         for(int si = 0; si < N; si++)
           {
            //--- Segment vector and squared length for the projection math
            double sdx = segBx[si] - segAx[si];
            double sdy = segBy[si] - segAy[si];
            double slen2 = sdx * sdx + sdy * sdy;
            //--- Project the pixel onto the segment; clamp parameter into [0, 1]
            double tSeg = 0.0;
            if(slen2 > 1e-12)
               tSeg = (((double)xx - segAx[si]) * sdx + ((double)yy - segAy[si]) * sdy) / slen2;
            if(tSeg < 0.0) tSeg = 0.0;
            if(tSeg > 1.0) tSeg = 1.0;
            //--- Compute the projected foot and its squared distance to the pixel
            double qx = segAx[si] + tSeg * sdx;
            double qy = segAy[si] + tSeg * sdy;
            double ddx = (double)xx - qx, ddy = (double)yy - qy;
            double d2 = ddx * ddx + ddy * ddy;
            //--- Track the minimum across all curve segments
            if(d2 < dMin2) dMin2 = d2;
           }
         //--- Convert minimum squared distance into actual distance to the curve
         double distCurve = MathSqrt(dMin2);
         //--- Determine the curve's perpendicular depth at the same along-chord coordinate (side-of-curve test)
         double curvePerp = 0.0;
         bool   found = false;
         for(int si = 0; si < N; si++)
           {
            //--- Each segment's along-chord range
            double ax_ = segAx[si], ay_ = segAy[si];
            double bx_ = segBx[si], by_ = segBy[si];
            double aA = (ax_ - p1x) * ux_c + (ay_ - p1y) * uy_c;
            double aB = (bx_ - p1x) * ux_c + (by_ - p1y) * uy_c;
            double lo = MathMin(aA, aB), hi = MathMax(aA, aB);
            //--- Test whether the pixel's along-chord coordinate falls inside this segment's range
            if(alongPx >= lo && alongPx <= hi)
              {
               //--- Interpolate along the segment to find the curve point at the same alongPx
               double rng = aB - aA;
               double tt  = (MathAbs(rng) > 1e-9) ? (alongPx - aA) / rng : 0.0;
               double cxs = ax_ + tt * (bx_ - ax_);
               double cys = ay_ + tt * (by_ - ay_);
               //--- Perpendicular depth of the curve at this along-chord position
               double rxc = cxs - p1x;
               double ryc = cys - p1y;
               double perpC = (rxc * nx_c + ryc * ny_c) * signApex;
               //--- Track the maximum curve depth across all matching segments
               if(perpC > curvePerp) curvePerp = perpC;
               found = true;
              }
           }
         //--- Chord length (cached for the along-range test below)
         double cLen2 = MathSqrt(chx * chx + chy * chy);
         //--- Along-chord range test: pixel must be within [0, chord-length]
         bool alongInRange = (alongPx >= 0.0 && alongPx <= cLen2);
         //--- Pixel is "inside" the arc region iff inside the chord X-range AND on the apex side of the curve
         bool insideCurveSide = found && alongInRange && (perpPx <= curvePerp);
         //--- Curve-depth signed distance (positive when inside, negative when outside)
         double depthCurve = insideCurveSide ? distCurve : -distCurve;
         //--- The smaller of chord-depth and curve-depth is the inside-region SDF value
         double depthInside = (depthChord < depthCurve) ? depthChord : depthCurve;
         //--- Fill coverage: depth-based smooth boundary at 0.5 transition
         double fillCov = 0.5 + depthInside;
         if(fillCov > 1.0) fillCov = 1.0;
         if(fillCov > 0.0)
           {
            //--- Compose the coverage-weighted fill alpha and blend the pixel
            const uchar fillBaseA = (uchar)((fillArgb >> 24) & 0xFF);
            uchar aFill = (uchar)((double)fillBaseA * fillCov + 0.5);
            uint  argb  = ((uint)aFill << 24) | (fillArgb & 0x00FFFFFF);
            ChannelBlendPixelSet(canvas, xx, yy, argb);
           }
         //--- Border coverage: only nonzero near the curve
         if(distCurve <= halfThick + 0.5)
           {
            //--- Coverage shrinks linearly with distance from the curve centerline
            double cov = halfThick + 0.5 - distCurve;
            if(cov > 1.0) cov = 1.0;
            if(cov > 0.0)
              {
               //--- Compose the coverage-weighted border alpha and blend the pixel
               uchar aCov = (uchar)((double)borderBaseA * cov + 0.5);
               uint  covArgb = ((uint)aCov << 24) | borderRGBmask;
               ChannelBlendPixelSet(canvas, xx, yy, covArgb);
              }
           }
        }
     }
   //--- 3 handles when selected or hovered: P1, P2, and the CLAMPED apex
   if(selected || hovered)
     {
      //--- Round the clamped apex to integer pixel coords for the handle (idx 2 lands on the curve midpoint)
      int iApX = (int)MathRound(apX);
      int iApY = (int)MathRound(apY);
      //--- Render handles honoring hide/halo state
      if(m_hideHandleIdx != 0) DrawHandleOnCanvas(canvas, x1, y1, selected, objColor, m_haloHandleIdx == 0);
      if(m_hideHandleIdx != 1) DrawHandleOnCanvas(canvas, x2, y2, selected, objColor, m_haloHandleIdx == 1);
      if(m_hideHandleIdx != 2) DrawHandleOnCanvas(canvas, iApX, iApY, selected, objColor, m_haloHandleIdx == 2);
     }
  }

//+------------------------------------------------------------------+
//| Hit-test Arc: cursor near the curve OR inside the enclosed region|
//+------------------------------------------------------------------+
bool CShapeTools::HitTestArc(int mx, int my, int x1, int y1, int x2, int y2, int x3, int y3,
                              int threshold)
  {
   //--- Compute the clamped apex and the Bezier control X via the helper; reject degenerate chords
   double apX = 0, apY = 0, cpX = 0;
   if(!ArcCircumcircle(x1, y1, x2, y2, x3, y3, apX, apY, cpX)) return false;
   //--- CP.y is the mirror of the chord midpoint Y through the apex Y
   double cpY = 2.0 * apY - 0.5 * ((double)y1 + (double)y2);
   //--- Cache endpoint coords as doubles
   double p1x = (double)x1, p1y = (double)y1;
   double p2x = (double)x2, p2y = (double)y2;
   //--- Approximate distance from the cursor to the Bezier curve
   double d = ArcDistToBezier((double)mx, (double)my, p1x, p1y, cpX, cpY, p2x, p2y);
   //--- Cursor within threshold of the curve always counts
   if(d <= threshold) return true;
   //--- Otherwise test whether the cursor sits in the enclosed (chord-to-curve) region
   double chx = p2x - p1x;
   double chy = p2y - p1y;
   //--- Side of the chord that the apex sits on (sign of the cross product)
   double sideApex = chx * (apY - p1y) - chy * (apX - p1x);
   if(MathAbs(sideApex) < 1e-9) return false;
   double signApex = (sideApex >= 0.0) ? 1.0 : -1.0;
   //--- Side of the chord that the cursor sits on; reject if opposite the apex
   double sideM = chx * ((double)my - p1y) - chy * ((double)mx - p1x);
   if(sideM * signApex < 0.0) return false;
   //--- Chord length (reject degenerate chords)
   double cLen = MathSqrt(chx * chx + chy * chy);
   if(cLen < 1e-9) return false;
   //--- Chord unit-along (u) and unit-perpendicular (n) vectors
   double ux_c = chx / cLen, uy_c = chy / cLen;
   double nx_c = -uy_c,      ny_c =  ux_c;
   //--- Cursor decomposed into along-chord and signed perp-to-chord components
   double alongPx = ((double)mx - p1x) * ux_c + ((double)my - p1y) * uy_c;
   double perpPx  = (((double)mx - p1x) * nx_c + ((double)my - p1y) * ny_c) * signApex;
   //--- Along-chord range test: cursor must be within [0, chord-length]
   if(alongPx < 0.0 || alongPx > cLen) return false;
   //--- Determine the curve's perpendicular depth at the cursor's along-chord position
   const int N = 64;
   double prevX, prevY;
   ArcBezierEval(p1x, p1y, cpX, cpY, p2x, p2y, 0.0, prevX, prevY);
   double curvePerp = 0.0;
   for(int si = 0; si < N; si++)
     {
      //--- Sample the curve at parameter t for this segment's endpoint
      double t = (double)(si + 1) / (double)N;
      double cx_, cy_;
      ArcBezierEval(p1x, p1y, cpX, cpY, p2x, p2y, t, cx_, cy_);
      //--- Along-chord range of this segment
      double aA = (prevX - p1x) * ux_c + (prevY - p1y) * uy_c;
      double aB = (cx_   - p1x) * ux_c + (cy_   - p1y) * uy_c;
      double lo = MathMin(aA, aB), hi = MathMax(aA, aB);
      //--- Does the cursor's along-chord position fall in this segment's range?
      if(alongPx >= lo && alongPx <= hi)
        {
         //--- Interpolate along the segment to find the curve point at the same alongPx
         double rng = aB - aA;
         double tt  = (MathAbs(rng) > 1e-9) ? (alongPx - aA) / rng : 0.0;
         double cxs = prevX + tt * (cx_ - prevX);
         double cys = prevY + tt * (cy_ - prevY);
         //--- Perpendicular depth of the curve at this along-chord position
         double perpC = ((cxs - p1x) * nx_c + (cys - p1y) * ny_c) * signApex;
         //--- Track the maximum curve depth across matching segments
         if(perpC > curvePerp) curvePerp = perpC;
        }
      prevX = cx_; prevY = cy_;
     }
   //--- Cursor is inside the enclosed region iff its perp depth is between 0 (chord) and curvePerp (curve)
   return (perpPx >= 0.0 && perpPx <= curvePerp);
  }

Начнём с ArcCircumcircle — общей вспомогательной функции, которая по трём точкам, заданным щелчками, вычисляет вершину с учётом ограничения её положения и координату X контрольной точки кривой Безье. Вектор хорды и перпендикулярный ему единичный вектор получаем непосредственно из разности координат P1 и P2, а вектор смещения от середины хорды до P3 проецируем на этот перпендикуляр, чтобы получить расстояние со знаком. Тогда вершина с учётом ограничения лежит на срединном перпендикуляре к хорде на полученном расстоянии со знаком от её середины, а координата X контрольной точки кривой Безье получается отражением координаты X середины хорды относительно координаты X вершины — именно это отражение гарантирует, что кривая проходит через вершину при параметре t = 0,5.

Далее идут две небольшие вспомогательные функции, не являющиеся методами класса, которые используются и для дуги, и для кривой. ArcBezierEval вычисляет значение квадратичной кривой Безье при заданном параметре t по классической формуле в развёрнутом виде. Функция ArcDistToBezier оценивает расстояние от точки до кривой путем дискретизации кривой на 64 отрезка, проецирования точки на каждый отрезок и вычисления минимального перпендикулярного расстояния. 64 отрезка достаточно, чтобы кривая выглядела плавной при любом разумном масштабе, а вычислительные затраты во внутреннем цикле для каждого пикселя оставались небольшими. Это произвольное значение, которое мы приняли за стандарт; при желании вы можете увеличить или уменьшить его.

Затем внутри функции DrawArcOn мы вычисляем координаты вершины и управляющей точки с помощью вспомогательной функции, а затем определяем координату Y управляющей точки как отражение координаты Y середины хорды относительно координаты Y вершины. Ограничивающий прямоугольник кривой определяется по результатам её дискретизации с 16 шагами, поэтому AABB охватывает всю кривую Безье, а не только три конечные точки. Затем мы извлекаем единичные векторы вдоль хорды и перпендикулярно ей и предварительно дискретизируем кривую, сохраняя конечные точки 64 сегментов в параллельных массивах — внутренний попиксельный цикл просматривает эти массивы вместо повторного вычисления формулы Безье для каждого пикселя.

Для отрисовки заливки используется подход на основе знакового расстояния, аналогичный применяемому для эллипса. Мы объединяем два поля: расстояние до хорды и расстояние до дискретизированной кривой Безье. Пиксель считается находящимся внутри области, если его координата вдоль хорды лежит в её пределах, а сам он расположен между хордой и кривой со стороны вершины. Чтобы определить глубину кривой, мы перебираем 64 сегмента, полученных при дискретизации, и ищем те, чей диапазон вдоль хорды содержит соответствующую координату пикселя; затем интерполяцией находим глубину кривой по перпендикуляру к хорде в этой позиции и берём максимальное значение среди всех подходящих сегментов. Меньшая из двух глубин даёт нам знаковое расстояние до границы области, которое мы преобразуем в долю покрытия пикселя заливкой с субпиксельной точностью с помощью стандартного сглаживания 0.5 + depth.

Отрисовка границы выполняется в том же попиксельном цикле. Минимальное расстояние до любого из 64 сегментов, полученных при дискретизации, уже вычислено при определении глубины кривой, поэтому мы повторно используем его для обводки со сглаживанием по знаковому расстоянию — пикселям на расстоянии от кривой не более половины толщины линии назначается значение альфа-канала с учётом доли покрытия, после чего они смешиваются с фоном через ChannelBlendPixelSet. При выделении дуги или наведении на неё указателя отображаются три маркера: две — в сохранённых позициях P1 и P2, а третья — в вершине после ограничения её положения, которая всегда совпадает с видимой серединой кривой.

HitTestArc повторно использует ту же геометрию. Мы вычисляем расстояние до кривой с помощью ArcDistToBezier, и если указатель находится от неё на расстоянии в пределах порога, регистрируется попадание. Если указатель не попал на кривую, мы выполняем те же проверки стороны относительно хорды, диапазона координат вдоль хорды и глубины кривой, чтобы определить, находится ли указатель внутри ограниченной области. Нахождение курсора внутри этой области также считается попаданием. Инструмент "Кривая" использует ту же дискретизацию кривой Безье и ту же логику обводки на основе знакового расстояния — он лишь пропускает ограничение положения вершины (оставляя P3 свободной по обеим осям) и рисует только обводку кривой без заливки, поэтому мы не будем отдельно рассматривать его процедуру отрисовки. Однако мы строим не просто стандартную, а параметрическую кривую, что даёт нам больше свободы при выборе диапазона. Вот что мы получаем с помощью инструментов "Дуга" и "Кривая".

ИНСТРУМЕНТЫ ДЛЯ СОЗДАНИЯ ДУГ И КРИВЫХ

Следующим шагом будет реализация инструментов для создания аннотаций.


Реализация инструментов аннотирования

Объявление класса инструментов аннотирования

Теперь перейдем к инструментам аннотирования, объявив CAnnotationTools — следующий уровень в цепочке наследования. Это слой интерфейса для девяти инструментов аннотирования — "Текст", "Стрелка", "Маркер стрелки", "Стрелка вверх", "Стрелка вниз", "Примечание", "Примечание к цене", "Выноска" и "Комментарий". Класс наследуется от CShapeTools, поэтому все примитивы фигур, вспомогательные функции для каналов и двухпроходные средства отрисовки меток, которые мы подготовили ранее, уже доступны.

//+------------------------------------------------------------------+
//|                                     ToolsPalette_Annotations.mqh |
//|                           Copyright 2026, Allan Munene Mutiiria. |
//|                                   https://t.me/Forex_Algo_Trader |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Allan Munene Mutiiria."
#property link "https://t.me/Forex_Algo_Trader"
#property version "1.00"
#property strict

//--- Guard against multiple inclusion of this header
#ifndef TOOLS_PALETTE_ANNOTATIONS_MQH
#define TOOLS_PALETTE_ANNOTATIONS_MQH

//--- Pull in the base shape tools class that this class extends
#include "ToolsPalette_Shapes.mqh"

//+------------------------------------------------------------------+
//| Callout shaft attach case enum                                   |
//+------------------------------------------------------------------+
enum ENUM_CALLOUT_ATTACH
  {
   CA_E,    // East: right edge midpoint
   CA_NE,   // North-east corner
   CA_N,    // North: top edge midpoint
   CA_NW,   // North-west corner
   CA_W,    // West: left edge midpoint
   CA_SW,   // South-west corner
   CA_S,    // South: bottom edge midpoint
   CA_SE    // South-east corner
  };

//+------------------------------------------------------------------+
//| Arrow Up/Down fixed pixel parameters                             |
//+------------------------------------------------------------------+
const double ARROW_UPDOWN_TOTAL_H  = 28.0; // Total arrow length apex-to-base
const double ARROW_UPDOWN_HEAD_LEN = 13.0; // Head triangle height
const double ARROW_UPDOWN_SHAFT_HW = 4.0;  // Half-width of the shaft
const double ARROW_UPDOWN_HEAD_HW  = 9.0;  // Half-width of the wings

//+------------------------------------------------------------------+
//| CAnnotationTools class declaration                               |
//+------------------------------------------------------------------+
class CAnnotationTools : public CShapeTools
  {
public:
   //--- Draw a Text annotation box centered at (ax, ay)
   void   DrawTextAnnotationOn(CCanvas &canvas,
                                int ax, int ay,
                                const string committedText,
                                bool isEditing, const string editBuffer,
                                int caretPos,
                                color objColor, bool selected, bool hovered,
                                int &outL, int &outT, int &outR, int &outB,
                                int fontSize = 12, bool bold = false,
                                int vAlign = 0, int hAlign = 0,
                                int textOpacityPct = 100);
   //--- Hit-test for a Text annotation box
   bool   HitTestTextAnnotation(int mx, int my,
                                 int ax, int ay,
                                 const string committedText,
                                 bool isEditing, const string editBuffer,
                                 int fontSize = 12, bool bold = false);
   //--- Compute the Text annotation bounding box
   void   ComputeTextAnnotationBox(int ax, int ay,
                                    const string committedText,
                                    bool isEditing, const string editBuffer,
                                    int &outL, int &outT, int &outR, int &outB,
                                    int fontSize = 12, bool bold = false);
   //--- Draw a 2-click annotation Arrow with filled triangular head
   void   DrawArrowOn(CCanvas &canvas,
                       int x1, int y1, int x2, int y2,
                       color objColor, bool selected, bool hovered,
                       int lineWidth = 2, int lineOpacity = 100);
   //--- Hit-test for an Arrow shaft or either wing
   bool   HitTestArrow(int mx, int my, int x1, int y1, int x2, int y2, int threshold);
   //--- Draw an Arrow Marker (6-vertex filled dart silhouette)
   void   DrawArrowMarkerOn(CCanvas &canvas,
                             int x1, int y1, int x2, int y2,
                             color objColor, bool selected, bool hovered,
                             bool outlineOnly = false,
                             int lineOpacity = 100);
   //--- Hit-test for an Arrow Marker silhouette
   bool   HitTestArrowMarker(int mx, int my, int x1, int y1, int x2, int y2, int threshold);
   //--- Draw an Arrow Up/Down single-click fixed-size marker
   void   DrawArrowUpDownOn(CCanvas &canvas,
                             int ax, int ay,
                             bool pointsUp,
                             color objColor, bool selected, bool hovered,
                             bool outlineOnly = false,
                             int lineOpacity = 100);
   //--- Hit-test for an Arrow Up/Down marker
   bool   HitTestArrowUpDown(int mx, int my, int ax, int ay, bool pointsUp, int threshold);
   //--- Compute the 7 silhouette vertices for an Arrow Up/Down marker
   void   ComputeArrowUpDownVerts(int ax, int ay, bool pointsUp,
                                   double &vx[], double &vy[]);
   //--- Draw a Note (anchor P1 plus rectangle at P2 with connector line and shadow)
   void   DrawNoteOn(CCanvas &canvas,
                      int p1x, int p1y, int p2x, int p2y,
                      const string committedText,
                      bool isEditing, const string editBuffer,
                      int caretPos,
                      color objColor, bool selected, bool hovered,
                      int &outBoxL, int &outBoxT, int &outBoxR, int &outBoxB,
                      int lineOpacity = 100, int fontSize = 12,
                      bool bold = false,
                      color fillColor = clrNONE, int fillOpacity = 100,
                      color textColor = clrNONE, int textOpacity = 100);
   //--- Hit-test for a Note (rect, connector line, or anchor dot)
   bool   HitTestNote(int mx, int my,
                       int p1x, int p1y, int p2x, int p2y,
                       const string committedText,
                       bool isEditing, const string editBuffer,
                       int fontSize = 12);
   //--- Compute the Note rectangle bounds with edge-midpoint attach to P2
   void   ComputeNoteBox(int p1x, int p1y, int p2x, int p2y,
                          const string committedText,
                          bool isEditing, const string editBuffer,
                          int &outL, int &outT, int &outR, int &outB,
                          int fontSize = 12);
   //--- Draw a Price Note (Note variant showing formatted anchor price)
   void   DrawPriceNoteOn(CCanvas &canvas,
                           int p1x, int p1y, int p2x, int p2y,
                           double anchorPrice,
                           color objColor, bool selected, bool hovered,
                           int &outBoxL, int &outBoxT, int &outBoxR, int &outBoxB,
                           int lineOpacity = 100, int fontSize = 10,
                           color fillColor = clrNONE, int fillOpacity = 100,
                           color textColor = clrNONE, int textOpacity = 100);
   //--- Hit-test for a Price Note
   bool   HitTestPriceNote(int mx, int my,
                            int p1x, int p1y, int p2x, int p2y,
                            double anchorPrice,
                            int fontSize = 10);
   //--- Compute the Callout rectangle bounds plus shaft attach points and case
   void   ComputeCalloutGeometry(int p1x, int p1y, int p2x, int p2y,
                                  const string committedText,
                                  bool isEditing, const string editBuffer,
                                  int &outBoxL, int &outBoxT,
                                  int &outBoxR, int &outBoxB,
                                  int &outA1x, int &outA1y,
                                  int &outA2x, int &outA2y,
                                  ENUM_CALLOUT_ATTACH &outCase,
                                  int fontSize = 12);
   //--- Draw a Callout (rounded rect plus shaft to P1 with continuous border and fill)
   void   DrawCalloutOn(CCanvas &canvas,
                         int p1x, int p1y, int p2x, int p2y,
                         const string committedText,
                         bool isEditing, const string editBuffer,
                         int caretPos,
                         color objColor, bool selected, bool hovered,
                         int &outBoxL, int &outBoxT, int &outBoxR, int &outBoxB,
                         int lineOpacity = 100, int fontSize = 12,
                         bool bold = false,
                         color fillColor = clrNONE, int fillOpacity = 100,
                         color textColor = clrNONE, int textOpacity = 100);
   //--- Hit-test for a Callout (rect interior, shaft triangle, or P1 handle)
   bool   HitTestCallout(int mx, int my,
                          int p1x, int p1y, int p2x, int p2y,
                          const string text,
                          bool isEditing, const string editBuffer,
                          int fontSize = 12);
   //--- Draw a Comment (1-click rectangle with mixed corner radii; P1 = bottom-left)
   void   DrawCommentOn(CCanvas &canvas,
                         int p1x, int p1y,
                         const string committedText,
                         bool isEditing, const string editBuffer,
                         int caretPos,
                         color objColor, bool selected, bool hovered,
                         int &outBoxL, int &outBoxT, int &outBoxR, int &outBoxB,
                         int lineOpacity = 100, int fontSize = 12,
                         bool bold = false,
                         color fillColor = clrNONE, int fillOpacity = 100,
                         color textColor = clrNONE, int textOpacity = 100);
   //--- Compute the Comment rectangle bounds
   void   ComputeCommentBox(int p1x, int p1y,
                             const string committedText,
                             bool isEditing, const string editBuffer,
                             int &outL, int &outT, int &outR, int &outB,
                             int fontSize = 12);
   //--- Hit-test for a Comment rectangle
   bool   HitTestComment(int mx, int my, int p1x, int p1y,
                          const string text,
                          bool isEditing, const string editBuffer,
                          int fontSize = 12);
   //--- Compute the 6 silhouette vertices for an Arrow Marker dart shape
   void   ComputeArrowMarkerVerts(int x1, int y1, int x2, int y2,
                                   double &vx[], double &vy[]);
  };

Заголовочный файл защищён от повторного включения макросом TOOLS_PALETTE_ANNOTATIONS_MQH; мы подключаем заголовочный файл инструментов фигур, чтобы унаследовать все их возможности. Перед самим классом мы определяем два вспомогательных элемента в области видимости файла, которые должны быть доступны коду реализации. Первый — ENUM_CALLOUT_ATTACH, перечисление, задающее восемь возможных точек присоединения на границе выноски: четыре середины сторон (E, N, W, S) и четыре угла (NE, NW, SW, SE). Мы используем его для классификации положения, в котором конец стержня соединяется с прямоугольником. За основу мы берём точки привязки для выравнивания текста в TextOut в MQL5.

ПРИМЕР ФЛАГОВ ВЫРАВНИВАНИЯ TEXTOUT В MQL5

Второй — небольшая группа констант, задающих фиксированные размеры в пикселях для маркеров "Стрелка вверх" и "Стрелка вниз" (общая высота, длина наконечника, половина ширины стержня, половина ширины наконечника), благодаря чему силуэт сохраняет одинаковый размер независимо от масштаба.

В классе для каждого инструмента аннотирования объявляются процедура рисования и соответствующий тестер попадания. Для аннотации "Текст" также предусмотрена вспомогательная функция  ComputeTextAnnotationBox, благодаря которой средство отрисовки и тестер попадания вычисляют ограничивающий прямоугольник на основе одних и тех же данных. Для "Стрелки" задаются две опорные точки (начало в P1, остриё в P2); она отрисовывается как стержень, проведённый линией, с залитым треугольным наконечником стрелки. "Маркер стрелки" представляет собой залитый силуэт дротика с шестью вершинами; функция ComputeArrowMarkerVerts формирует вершины многоугольника, которые используются как для рисования, так и для проверки попадания. Маркеры "Стрелка вверх" и "Стрелка вниз" представляют собой варианты фиксированного размера, создаваемые одним щелчком мыши; функция ComputeArrowUpDownVerts формирует их силуэты из семи вершин.

Элементы "Примечание", "Примечание к цене", "Выноска" и "Комментарий" содержат редактируемый текст, поэтому их сигнатуры предоставляют доступ к параметрам committedText, isEditing, editBuffer и caretPos, которые механизм рисования передаёт из состояния редактирования метки. Кроме того, каждый из них возвращает свой ограничивающий прямоугольник через выходные параметры, чтобы механизм рисования мог сохранить его для последующей проверки попадания в область текста во время редактирования. У "Примечания" и "Примечания к цене" одинаковый принцип присоединения к середине стороны: их вспомогательная функция "ComputeNoteBox" выбирает сторону прямоугольника, середина которой находится в P2, исходя из преобладающей оси направления от P1 к P2. "Выноска" устроена сложнее: конец стержня присоединяется в одной из восьми точек на границе прямоугольника, поэтому функция расчёта геометрии ComputeCalloutGeometry возвращает границы прямоугольника, две точки присоединения стержня и выбранный вариант присоединения. "Комментарий" — самый простой из четырёх инструментов: это прямоугольник, создаваемый одним щелчком мыши, с левым нижним углом в точке P1. Его вспомогательная функция ComputeCommentBox подбирает размеры прямоугольника по текстовому содержимому. Объявив интерфейс, переходим к реализации. Начнём с инструмента "Примечание", в котором используется алгоритм заливки с тенью, и применим тот же подход к остальным инструментам для создания аннотаций.

Скруглённый прямоугольник с суперсэмплингом и тень

Мы определяем две общие вспомогательные функции отрисовки, на которых основаны инструменты "Примечание", "Примечание к цене" и "Выноска". Функция FillNoteRoundRect рисует основную часть в виде прямоугольника со скруглёнными углами с помощью суперсэмплинга с последующим понижением разрешения, а функция DrawNoteDropShadow создаёт мягкую тень под ней с помощью двухпроходного разделяемого прямоугольного размытия.

//+------------------------------------------------------------------+
//| Fill a rounded rectangle with 4x SSAA and downsample averaging   |
//+------------------------------------------------------------------+
void FillNoteRoundRect(CCanvas &canvas, int boxL, int boxT, int boxR, int boxB,
                       int cornerRadius, uint argb)
  {
   //--- Compute box dimensions and reject empty rectangles
   int w = boxR - boxL;
   int h = boxB - boxT;
   if(w <= 0 || h <= 0) return;
   //--- Configure the 4x supersampling factor and HR canvas dimensions
   const int SS = 4;
   int wHR = w * SS;
   int hHR = h * SS;
   int crHR = cornerRadius * SS;
   //--- Create the temporary high-res canvas; fall back to plain rendering on failure
   CCanvas tmpHR;
   if(!tmpHR.Create("NoteRectHR_tmp", wHR, hHR, COLOR_FORMAT_ARGB_NORMALIZE))
     {
      //--- Fallback path uses non-supersampled CCanvas primitives
      int radius = cornerRadius;
      //--- Clamp radius to half the shorter dimension
      if(radius > w / 2) radius = w / 2;
      if(radius > h / 2) radius = h / 2;
      //--- Zero-radius case is a plain rectangle
      if(radius <= 0)
        {
         canvas.FillRectangle(boxL, boxT, boxR - 1, boxB - 1, argb);
         return;
        }
      //--- Paint the four corner circles plus two cross strips for the rounded shape
      canvas.FillCircle(boxL + radius,     boxT + radius,     radius, argb);
      canvas.FillCircle(boxR - radius - 1, boxT + radius,     radius, argb);
      canvas.FillCircle(boxL + radius,     boxB - radius - 1, radius, argb);
      canvas.FillCircle(boxR - radius - 1, boxB - radius - 1, radius, argb);
      canvas.FillRectangle(boxL + radius, boxT,          boxR - radius - 1, boxB - 1,          argb);
      canvas.FillRectangle(boxL,          boxT + radius, boxR - 1,          boxB - radius - 1, argb);
      return;
     }
   //--- Render the rounded rect at high resolution into the temp canvas
   tmpHR.Erase(0x00000000);
   int radiusHR = crHR;
   //--- Clamp HR radius to half the HR dimension
   if(radiusHR > wHR / 2) radiusHR = wHR / 2;
   if(radiusHR > hHR / 2) radiusHR = hHR / 2;
   if(radiusHR <= 0)
     {
      //--- Zero-radius HR case is a plain rectangle
      tmpHR.FillRectangle(0, 0, wHR - 1, hHR - 1, argb);
     }
   else
     {
      //--- Paint four corner circles and two cross strips at high resolution
      tmpHR.FillCircle(radiusHR,         radiusHR,         radiusHR, argb);
      tmpHR.FillCircle(wHR - radiusHR - 1, radiusHR,         radiusHR, argb);
      tmpHR.FillCircle(radiusHR,         hHR - radiusHR - 1, radiusHR, argb);
      tmpHR.FillCircle(wHR - radiusHR - 1, hHR - radiusHR - 1, radiusHR, argb);
      tmpHR.FillRectangle(radiusHR, 0,        wHR - radiusHR - 1, hHR - 1,        argb);
      tmpHR.FillRectangle(0,        radiusHR, wHR - 1,            hHR - radiusHR - 1, argb);
     }
   //--- Downsample the high-res buffer by averaging each SS x SS block
   int ss2 = SS * SS;
   int cW = canvas.Width(), cH = canvas.Height();
   for(int py = 0; py < h; py++)
     {
      //--- Compute the canvas target Y row with clipping
      int targetY = boxT + py;
      if(targetY < 0 || targetY >= cH) continue;
      for(int px = 0; px < w; px++)
        {
         //--- Compute the canvas target X column with clipping
         int targetX = boxL + px;
         if(targetX < 0 || targetX >= cW) continue;
         //--- Accumulate alpha and RGB sums across the SS x SS source block
         int sumA = 0, sumR = 0, sumG = 0, sumB = 0, wc = 0;
         for(int dy = 0; dy < SS; dy++)
           {
            for(int dx = 0; dx < SS; dx++)
              {
               //--- Read the HR pixel and accumulate channel sums for opaque samples
               int sx = px * SS + dx;
               int sy = py * SS + dy;
               uint p = tmpHR.PixelGet(sx, sy);
               uchar pa = (uchar)((p >> 24) & 0xFF);
               sumA += pa;
               if(pa > 0)
                 {
                  sumR += (int)((p >> 16) & 0xFF);
                  sumG += (int)((p >>  8) & 0xFF);
                  sumB += (int)( p        & 0xFF);
                  wc++;
                 }
              }
           }
         //--- Compose the averaged pixel and blend onto the target canvas
         uchar fa = (uchar)(sumA / ss2);
         if(fa == 0 || wc == 0) continue;
         uchar fr = (uchar)(sumR / wc);
         uchar fg = (uchar)(sumG / wc);
         uchar fb = (uchar)(sumB / wc);
         uint outArgb = ((uint)fa << 24) | ((uint)fr << 16) | ((uint)fg << 8) | (uint)fb;
         BlendPxNote(canvas, targetX, targetY, outArgb);
        }
     }
   //--- Release the temporary high-res canvas
   tmpHR.Destroy();
  }

//+------------------------------------------------------------------+
//| Draw a Note drop shadow using a 2-pass separable box blur        |
//+------------------------------------------------------------------+
void DrawNoteDropShadow(CCanvas &canvas,
                        int boxL, int boxT, int boxR, int boxB,
                        int cornerRadius)
  {
   //--- Shadow tuning parameters: offset, blur radius, and base alpha
   int offX      = 1;
   int offY      = 1;
   int blurR     = 3;
   int baseAlpha = 80;
   //--- Compute the offset shadow silhouette bounds
   int shL = boxL + offX;
   int shT = boxT + offY;
   int shR = boxR + offX;
   int shB = boxB + offY;
   //--- Compute padding for the blur kernel plus offset overhang
   int padLeft   = blurR + (offX < 0 ? -offX : 0);
   int padTop    = blurR + (offY < 0 ? -offY : 0);
   int padRight  = blurR + (offX > 0 ?  offX : 0);
   int padBottom = blurR + (offY > 0 ?  offY : 0);
   //--- Compute the padded working buffer dimensions
   int bufL = boxL - padLeft;
   int bufT = boxT - padTop;
   int bufR = boxR + padRight;
   int bufB = boxB + padBottom;
   int bufW = bufR - bufL;
   int bufH = bufB - bufT;
   if(bufW <= 0 || bufH <= 0) return;
   //--- Allocate and zero-initialize the silhouette alpha buffer
   uchar silhouette[];
   ArrayResize(silhouette, bufW * bufH);
   ArrayInitialize(silhouette, 0);
   //--- Build the rounded-rect silhouette via SDF-style inner-rect distance
   double cr = (double)cornerRadius;
   double innerL = (double)shL + cr;
   double innerR = (double)shR - cr;
   double innerT = (double)shT + cr;
   double innerB = (double)shB - cr;
   for(int yy = 0; yy < bufH; yy++)
     {
      //--- Compute the pixel-center Y for the distance query
      double py = (double)(yy + bufT) + 0.5;
      for(int xx = 0; xx < bufW; xx++)
        {
         //--- Compute the pixel-center X for the distance query
         double px = (double)(xx + bufL) + 0.5;
         //--- Compute distance from the pixel to the inner rectangle
         double ddx = MathMax(MathMax(innerL - px, px - innerR), 0.0);
         double ddy = MathMax(MathMax(innerT - py, py - innerB), 0.0);
         double dist = MathSqrt(ddx * ddx + ddy * ddy);
         //--- Mark pixels inside the rounded boundary at the base alpha
         if(dist <= cr)
            silhouette[yy * bufW + xx] = (uchar)baseAlpha;
        }
     }
   //--- Horizontal box-blur pass writing into a temporary buffer
   uchar tempH[];
   ArrayResize(tempH, bufW * bufH);
   int kernelSize = 2 * blurR + 1;
   for(int yy = 0; yy < bufH; yy++)
     {
      //--- Compute the row base offset for this scanline
      int rowBase = yy * bufW;
      //--- Seed the sliding-window sum with the leftmost kernel placement
      int runSum = 0;
      for(int k = -blurR; k <= blurR; k++)
        {
         int sx = k;
         if(sx < 0) sx = 0;
         if(sx >= bufW) sx = bufW - 1;
         runSum += (int)silhouette[rowBase + sx];
        }
      //--- Slide the window across the row writing averaged output
      for(int xx = 0; xx < bufW; xx++)
        {
         //--- Write the averaged output pixel for this column
         tempH[rowBase + xx] = (uchar)(runSum / kernelSize);
         //--- Update the sliding sum: remove leftmost, add rightmost
         int subX = xx - blurR;
         if(subX < 0) subX = 0;
         int addX = xx + blurR + 1;
         if(addX >= bufW) addX = bufW - 1;
         runSum -= (int)silhouette[rowBase + subX];
         runSum += (int)silhouette[rowBase + addX];
        }
     }
   //--- Vertical box-blur pass writing back into the silhouette buffer
   for(int xx = 0; xx < bufW; xx++)
     {
      //--- Seed the column sliding-window sum with the topmost kernel placement
      int runSum = 0;
      for(int k = -blurR; k <= blurR; k++)
        {
         int sy = k;
         if(sy < 0) sy = 0;
         if(sy >= bufH) sy = bufH - 1;
         runSum += (int)tempH[sy * bufW + xx];
        }
      //--- Slide the window down the column writing averaged output
      for(int yy = 0; yy < bufH; yy++)
        {
         //--- Write the averaged output pixel for this row
         silhouette[yy * bufW + xx] = (uchar)(runSum / kernelSize);
         //--- Update the sliding sum: remove topmost, add bottommost
         int subY = yy - blurR;
         if(subY < 0) subY = 0;
         int addY = yy + blurR + 1;
         if(addY >= bufH) addY = bufH - 1;
         runSum -= (int)tempH[subY * bufW + xx];
         runSum += (int)tempH[addY * bufW + xx];
        }
     }
   //--- Composite the blurred shadow onto the destination canvas
   int cW = canvas.Width(), cH = canvas.Height();
   for(int yy = 0; yy < bufH; yy++)
     {
      //--- Compute the canvas target Y with clipping
      int canvasY = yy + bufT;
      if(canvasY < 0 || canvasY >= cH) continue;
      for(int xx = 0; xx < bufW; xx++)
        {
         //--- Compute the canvas target X with clipping
         int canvasX = xx + bufL;
         if(canvasX < 0 || canvasX >= cW) continue;
         //--- Skip fully transparent shadow pixels
         uchar a = silhouette[yy * bufW + xx];
         if(a == 0) continue;
         //--- Blend a black pixel at the blurred alpha onto the canvas
         uint shadowArgb = ((uint)a << 24) | 0x00000000;
         BlendPxNote(canvas, canvasX, canvasY, shadowArgb);
        }
     }
  }

Подход с использованием суперсэмплинга в функции FillNoteRoundRect основан на той же идее, которую мы использовали для рендеринга текста в статье о торговых системах на базе искусственного интеллекта: сначала фигура отображается на временном холсте с разрешением, в четыре раза превышающим исходное, а затем производится понижение разрешения путем усреднения каждого блока размером 4×4. При отрисовке в высоком разрешении используются встроенные примитивы FillCircle и FillRectangle, чтобы нарисовать четыре круга в углах и две перекрещивающиеся полосы, образующие скруглённую фигуру, а на этапе усреднения зубчатые края кругов превращаются в плавную сглаженную кривую. На случай, если не удастся выделить память для временного холста, предусмотрен резервный вариант без суперсэмплинга: та же конструкция из четырёх кругов в углах и перекрещивающихся полос рисуется непосредственно на целевом холсте без сглаживания.

Что касается DrawNoteDropShadow, то новым приёмом, заслуживающим отдельного объяснения, является двухпроходное разделяемое прямоугольное размытие. При простом двумерном размытии значение каждого выходного пикселя вычисляется свёрткой по всем пикселям квадратного ядра, что требует примерно kernelSize^2 операций на пиксель. Разделяемый вариант использует тот факт, что прямоугольное ядро можно разложить на два одномерных прохода — горизонтальное размытие, за которым следует вертикальное, — что снижает вычислительные затраты до 2 * kernelSize операций на пиксель.

Сначала мы формируем силуэт скруглённого прямоугольника в одноканальном альфа-буфере, используя ту же проверку расстояния до внутреннего прямоугольника на основе SDF, что и в других местах: каждому пикселю внутри скруглённой границы присваивается базовое значение альфа-канала тени (80), а остальные значения остаются нулевыми. Затем горизонтальный проход обрабатывает каждую строку, поддерживая сумму значений в скользящем окне: начальная сумма вычисляется при положении ядра у крайнего левого столбца, после чего для каждого выходного столбца записывается среднее значение, а сумма обновляется вычитанием значения крайнего левого пикселя и прибавлением значения крайнего правого пикселя, только что вошедшего в окно. Благодаря этому вычислительные затраты на пиксель остаются постоянными независимо от размера ядра. Вертикальный проход выполняет те же действия по столбцам, считывая данные из результатов горизонтального прохода и записывая их обратно в исходный буфер силуэта.

На заключительном этапе композитинга выполняется проход по размытому альфа-буферу, и каждый пиксель смешивается с соответствующим пикселем холста согласно своему значению альфа-канала в буфере. Смещение на один пиксель по обеим осям сдвигает тень вправо и вниз, при этом ореол размытия по-прежнему распространяется во все стороны, создавая едва заметное ощущение, что прямоугольник приподнят над поверхностью, с направлением тени, характерным для настоящих теней. Принцип отрисовки инструмента "Примечание" такой же, как у других инструментов.

"Примечание": геометрия, отрисовка и проверка попадания

Аннотация "Примечание" использует несколько вспомогательных функций, которые мы уже подготовили. Мы вычисляем границы её прямоугольника по правилу присоединения к середине стороны, чтобы соединительная линия естественным образом входила в прямоугольник, рисуем тень и поверх неё заливку скруглённого прямоугольника, а затем размещаем внутри текст с помощью универсальной вспомогательной функции RenderEditableTextBlockAA.

//+------------------------------------------------------------------+
//| Compute the Note rectangle bounds with edge-midpoint attach      |
//+------------------------------------------------------------------+
void CAnnotationTools::ComputeNoteBox(int p1x, int p1y, int p2x, int p2y,
                                       const string committedText,
                                       bool isEditing, const string editBuffer,
                                       int &outL, int &outT, int &outR, int &outB,
                                       int fontSize)
  {
   //--- Resolve the text used for sizing the rectangle
   string content    = isEditing ? editBuffer : committedText;
   bool   hasContent = (StringLen(content) > 0);
   string measure;
   if(isEditing && !hasContent)
      measure = "Add text";
   else if(StringLen(content) > 0)
      measure = content;
   else
      measure = "  ";
   //--- Measure the multi-line text block via the shared helper
   int textW = 0, textH = 0, lineH = 0;
   MeasureTextBlock(measure, "Arial", fontSize, textW, textH, lineH);
   if(textW < 1) textW = 1;
   if(textH < 1) textH = lineH;
   //--- Compute the total box dimensions including padding and cursor slack
   int cursorReserve = 2;
   int padX = 10;
   int padY = 6;
   int boxW = textW + cursorReserve + 2 * padX;
   int boxH = textH + 2 * padY;
   //--- Pick the attaching edge based on the dominant direction from P1 to P2
   int dx = p2x - p1x;
   int dy = p2y - p1y;
   bool horizontalDominant = (MathAbs(dx) >= MathAbs(dy));
   if(horizontalDominant)
     {
      //--- Horizontal dominant: attach the rect's left or right edge midpoint at P2
      if(dx >= 0)
        { outL = p2x; outR = p2x + boxW; }
      else
        { outR = p2x; outL = p2x - boxW; }
      outT = p2y - boxH / 2;
      outB = outT + boxH;
     }
   else
     {
      //--- Vertical dominant: attach the rect's top or bottom edge midpoint at P2
      if(dy >= 0)
        { outT = p2y; outB = p2y + boxH; }
      else
        { outB = p2y; outT = p2y - boxH; }
      outL = p2x - boxW / 2;
      outR = outL + boxW;
     }
  }

//+------------------------------------------------------------------+
//| Draw a Note (anchor dot, connector line, rect with text)         |
//+------------------------------------------------------------------+
void CAnnotationTools::DrawNoteOn(CCanvas &canvas,
                                   int p1x, int p1y, int p2x, int p2y,
                                   const string committedText,
                                   bool isEditing, const string editBuffer,
                                   int caretPos,
                                   color objColor, bool selected, bool hovered,
                                   int &outBoxL, int &outBoxT, int &outBoxR, int &outBoxB,
                                   int lineOpacity, int fontSize, bool bold,
                                   color fillColor, int fillOpacity,
                                   color textColor, int textOpacity)
  {
   //--- Clamp all opacity values to [0, 100]
   if(lineOpacity < 0)   lineOpacity = 0;
   if(lineOpacity > 100) lineOpacity = 100;
   if(fillOpacity < 0)   fillOpacity = 0;
   if(fillOpacity > 100) fillOpacity = 100;
   if(textOpacity < 0)   textOpacity = 0;
   if(textOpacity > 100) textOpacity = 100;
   //--- Clamp the font size to a sane range
   if(fontSize < 6)  fontSize = 6;
   if(fontSize > 32) fontSize = 32;
   //--- Resolve the effective fill color (user-set or chart background)
   color effFillColor = (fillColor == clrNONE)
                         ? (color)ChartGetInteger(0, CHART_COLOR_BACKGROUND)
                         : fillColor;
   //--- Resolve the effective text color (user-set or object color)
   color effTextColor = (textColor == clrNONE) ? objColor : textColor;
   //--- Compose the connector line ARGB at the requested opacity
   uint  connectorArgb = ColorWithPercentOpacity(objColor, lineOpacity);
   //--- Compute the rectangle bounds via the shared geometry helper
   int boxL=0, boxT=0, boxR=0, boxB=0;
   ComputeNoteBox(p1x, p1y, p2x, p2y, committedText, isEditing, editBuffer,
                   boxL, boxT, boxR, boxB, fontSize);
   outBoxL = boxL; outBoxT = boxT; outBoxR = boxR; outBoxB = boxB;
   int boxW = boxR - boxL;
   int boxH = boxB - boxT;
   int radius = 4;
   //--- Draw the soft drop shadow first so the rect renders on top
   DrawNoteDropShadow(canvas, boxL, boxT, boxR, boxB, radius);
   //--- Draw the connector line between the anchor point and the rectangle
   DrawNoteConnectorLine(canvas, (double)p1x, (double)p1y,
                          (double)p2x, (double)p2y, connectorArgb);
   //--- Fill the rounded rectangle body
   uint rectFillArgb = ColorWithPercentOpacity(effFillColor, fillOpacity);
   FillNoteRoundRect(canvas, boxL, boxT, boxR, boxB, radius, rectFillArgb);
   //--- Resolve which text to render (committed, placeholder, or buffer)
   string labelPart  = isEditing ? editBuffer : committedText;
   bool   hasContent = (StringLen(labelPart) > 0);
   bool   usePlaceholder = isEditing && !hasContent;
   string renderText = usePlaceholder ? "Add text" : labelPart;
   int effectiveCaret = usePlaceholder ? 0 : caretPos;
   //--- Compute the inner text rectangle from rect padding
   int textL = boxL + 10;
   int textT = boxT + 6;
   int textR = boxR - 10;
   int textB = boxB - 6;
   //--- Center the text block within the rectangle interior
   if(StringLen(renderText) > 0)
     {
      //--- Measure the wrapped block for centering math
      int measW = 0, measH = 0, measLineH = 0;
      MeasureTextBlock(renderText, "Arial", fontSize, measW, measH, measLineH);
      //--- Vertically center if the block is shorter than the available height
      int avail = (boxB - boxT) - 12;
      if(measH < avail)
         textT = boxT + 6 + (avail - measH) / 2;
      //--- Horizontally center if the block is narrower than the available width
      int availW = (boxB - boxT > 0) ? (boxR - boxL) - 20 : 0;
      if(availW > 0 && measW < availW)
         textL = boxL + 10 + (availW - measW) / 2;
     }
   //--- Render the text into the rectangle interior
   if(StringLen(renderText) > 0 || isEditing)
     {
      RenderEditableTextBlockAA(canvas, renderText, isEditing, effectiveCaret,
                                  textL, textT, boxL + 10, boxT + 6,
                                  boxR - 10, boxB - 6,
                                  "Arial", fontSize, effTextColor, effTextColor,
                                  0, bold, 0, 0, textOpacity);
     }
   //--- Render the anchor dot only when idle (the handle takes over on hover/select)
   if(!(selected || hovered))
     {
      int dotR = 3;
      //--- Paint a small AA-filled disc at P1
      for(int dy = -dotR; dy <= dotR; dy++)
        {
         for(int dx = -dotR; dx <= dotR; dx++)
           {
            //--- Subsample inside the candidate pixel to compute coverage
            double sub = 4.0;
            int inside = 0, tot = 0;
            for(int sy = 0; sy < 4; sy++)
               for(int sx = 0; sx < 4; sx++)
                 {
                  //--- Compute the subpixel sample offset and test against the disc
                  double sdx = dx - 0.5 + (sx + 0.5) / sub;
                  double sdy = dy - 0.5 + (sy + 0.5) / sub;
                  if(sdx * sdx + sdy * sdy <= (double)dotR * dotR) inside++;
                  tot++;
                 }
            if(inside == 0) continue;
            //--- Compose the dot pixel ARGB at the coverage alpha
            uchar aCov = (uchar)(255 * inside / tot);
            uint dotArgb = ((uint)aCov << 24) | (connectorArgb & 0x00FFFFFF);
            int px = p1x + dx, py = p1y + dy;
            if(px >= 0 && py >= 0 && px < canvas.Width() && py < canvas.Height())
               BlendPxNote(canvas, px, py, dotArgb);
           }
        }
     }
   //--- Draw selection handles at P1 and P2
   if(selected || hovered)
     {
      if(m_hideHandleIdx != 0) DrawHandleOnCanvas(canvas, p1x, p1y, selected, objColor, m_haloHandleIdx == 0);
      if(m_hideHandleIdx != 1) DrawHandleOnCanvas(canvas, p2x, p2y, selected, objColor, m_haloHandleIdx == 1);
     }
  }

//+------------------------------------------------------------------+
//| Hit-test for a Note (rect, connector line, or anchor dot)        |
//+------------------------------------------------------------------+
bool CAnnotationTools::HitTestNote(int mx, int my,
                                    int p1x, int p1y, int p2x, int p2y,
                                    const string committedText,
                                    bool isEditing, const string editBuffer,
                                    int fontSize)
  {
   //--- Compute the rectangle bounds via the shared geometry helper
   int boxL=0, boxT=0, boxR=0, boxB=0;
   ComputeNoteBox(p1x, p1y, p2x, p2y, committedText, isEditing, editBuffer,
                   boxL, boxT, boxR, boxB, fontSize);
   //--- Inside the rectangle counts as a hit
   if(mx >= boxL && mx <= boxR && my >= boxT && my <= boxB) return true;
   //--- Inside the small anchor dot counts as a hit
   double dotR = 4.0;
   double dxP = mx - p1x, dyP = my - p1y;
   if(dxP * dxP + dyP * dyP <= dotR * dotR) return true;
   //--- Near the connector line counts as a hit
   double dx = p2x - p1x, dy = p2y - p1y;
   double len2 = dx * dx + dy * dy;
   if(len2 > 1e-6)
     {
      //--- Project (mx, my) onto the line and clamp to the segment
      double t = ((mx - p1x) * dx + (my - p1y) * dy) / len2;
      if(t < 0) t = 0; else if(t > 1) t = 1;
      //--- Compute the closest segment point and its distance to the cursor
      double qx = p1x + t * dx, qy = p1y + t * dy;
      double d  = MathSqrt((mx - qx)*(mx - qx) + (my - qy)*(my - qy));
      if(d <= 4.0) return true;
     }
   return false;
  }

ComputeNoteBox — единственный источник достоверных данных о границах прямоугольника примечания. Мы выбираем текст для расчёта размеров — содержимое буфера во время редактирования, сохранённый текст в остальных случаях или текст-заполнитель "Add text" (добавить текст) при редактировании пустого буфера — и измеряем его с помощью MeasureTextBlock. Полные размеры блока включают внутренние отступы по обеим осям и небольшой дополнительный запас по горизонтали, чтобы текстовый курсор мог находиться в конце строки, не обрезаясь границей прямоугольника.

Логика присоединения к середине стороны определяет, середина какой стороны прямоугольника будет находиться точно в точке P2. Мы сравниваем абсолютные значения компонент X и Y вектора от P1 к P2: если преобладает горизонтальная компонента, прямоугольник располагается слева или справа от P2 в зависимости от знака dx, а его центр по вертикали совпадает с координатой Y точки P2. Если преобладает вертикальная компонента, прямоугольник располагается выше или ниже P2 в зависимости от знака dy, а его центр по горизонтали совпадает с координатой X точки P2. В результате соединительная линия из точки P1 всегда подходит к прямоугольнику через середину ближайшей стороны, а не проходит сквозь заливку.

DrawNoteOn координирует многослойный рендеринг. Мы ограничиваем каждое значение непрозрачности допустимым диапазоном, определяем фактические цвета заливки и текста (если пользователь передал  clrNONE, используем соответственно цвет фона графика и цвет объекта) и вычисляем границы прямоугольника с помощью вспомогательной геометрической функции. Здесь важен порядок рисования: сначала с помощью DrawNoteDropShadow рисуется тень, чтобы прямоугольник оказался поверх неё; затем с помощью DrawNoteConnectorLine рисуется соединительная линия; далее заливка скруглённого прямоугольника с помощью FillNoteRoundRect перекрывает линию там, где она входит в прямоугольник; наконец, поверх всего выводится текст.

Код отрисовки текста определяет, что следует отобразить (содержимое буфера редактирования, сохранённый текст или текст-заполнитель "Добавить текст"), и измеряет блок с переносом слов с помощью  MeasureTextBlock, чтобы вычислить смещения для его центрирования внутри прямоугольника. Затем мы вызываем RenderEditableTextBlockAA, передавая внутреннюю область текста и прямоугольник отсечения содержащего его объекта; вспомогательная функция сама выполняет отрисовку текстового курсора, компоновку с переносом слов и наложение глифов с суперсэмплингом. Когда примечание неактивно (не выделено и указатель мыши на него не наведён), мы рисуем в P1 небольшую закрашенную опорную точку со сглаживанием, используя субпиксельную проверку принадлежности кругу. Когда примечание выделено или на него наведён указатель мыши, вместо точки отображаются маркеры выделения в P1 и P2.

HitTestNote последовательно проверяет три условия: находится ли указатель мыши внутри прямоугольника, внутри небольшого круга вокруг опорной точки P1 или вблизи соединительной линии; последняя проверка использует проекцию на прямую, ограниченную концами отрезка. При попадании в любую из этих трёх областей возвращается true. Инструмент "Примечание к цене" использует ту же геометрию и тот же код заливки прямоугольника: редактируемый текст заменяется результатом вызова DoubleToString для цены опорной точки с числом знаков после запятой, заданным для торгового символа; тень убирается, а для заливки используется фиксированный синий цвет. Мы не будем отдельно рассматривать его процедуру отрисовки. Остальные инструменты используют существующий подход. Редактирование и отрисовку текста мы рассмотрим в следующем разделе.


Реализация системы редактирования меток на холсте

Модель выделения текста в метках

Подсистема редактирования меток находится в отдельном файле ToolsPalette_Engine_Edit.mqh, который содержит тела всех методов CDrawingEngine, управляющих редактором текста на холсте. Модель выделения — это базовый уровень: при каждой операции ввода, каждом нажатии Backspace и каждом расширении выделения сочетанием Shift со стрелкой происходит обращение к этому коду, чтобы определить, какой диапазон буфера выделен в данный момент. Мы определяем три небольших метода, которые в совокупности составляют весь API выделения.

//+------------------------------------------------------------------+
//|                                     ToolsPalette_Engine_Edit.mqh |
//|                           Copyright 2026, Allan Munene Mutiiria. |
//|                                   https://t.me/Forex_Algo_Trader |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Allan Munene Mutiiria."
#property link "https://t.me/Forex_Algo_Trader"
#property version "1.00"
#property strict

//--- Guard against multiple inclusion of this header
#ifndef TOOLS_PALETTE_ENGINE_EDIT_MQH
#define TOOLS_PALETTE_ENGINE_EDIT_MQH

//--- Pull in CDrawingEngine class declaration (Tools.mqh include guard handles double-load)
#include "ToolsPalette_Tools.mqh"

//+------------------------------------------------------------------+
//| Test whether the label buffer has an active selection range      |
//+------------------------------------------------------------------+
bool CDrawingEngine::HasLabelSelection()
  {
   //--- Anchor at -1 means selection inactive
   if(m_labelSelectionAnchor < 0)                       return false;
   //--- Anchor equal to caret means zero-width selection (treated as none)
   if(m_labelSelectionAnchor == m_labelCaretPos)        return false;
   return true;
  }

//+------------------------------------------------------------------+
//| Read the ordered [start, end) range of the active selection      |
//+------------------------------------------------------------------+
bool CDrawingEngine::GetLabelSelectionRange(int &outStart, int &outEnd)
  {
   //--- Bail out when no selection is active and zero the outputs
   if(!HasLabelSelection()) { outStart = outEnd = 0; return false; }
   //--- Order anchor and caret so start <= end regardless of selection direction
   outStart = (m_labelSelectionAnchor < m_labelCaretPos) ? m_labelSelectionAnchor : m_labelCaretPos;
   outEnd   = (m_labelSelectionAnchor > m_labelCaretPos) ? m_labelSelectionAnchor : m_labelCaretPos;
   //--- Clamp defensively in case the buffer was mutated mid-edit
   const int len = StringLen(m_labelEditBuffer);
   if(outStart < 0)   outStart = 0;
   if(outEnd   > len) outEnd   = len;
   if(outStart > outEnd) outStart = outEnd;
   return outEnd > outStart;
  }

//+------------------------------------------------------------------+
//| Delete the active selection from the buffer and return success   |
//+------------------------------------------------------------------+
bool CDrawingEngine::DeleteLabelSelection()
  {
   //--- Bail out when there is no selection to delete
   int s, e;
   if(!GetLabelSelectionRange(s, e)) return false;
   //--- Compute the buffer slices before and after the selection
   const int len = StringLen(m_labelEditBuffer);
   const string before = (s > 0) ? StringSubstr(m_labelEditBuffer, 0, s) : "";
   const string after  = (e < len) ? StringSubstr(m_labelEditBuffer, e, len - e) : "";
   //--- Concatenate the slices, park the caret at the deleted region start
   m_labelEditBuffer = before + after;
   m_labelCaretPos        = s;
   m_labelSelectionAnchor = -1;
   return true;
  }

Состояние выделения представлено двумя целочисленными полями движка: m_labelSelectionAnchor (позиция, с которой началось выделение) и m_labelCaretPos (текущая позиция текстового курсора). Если позиция начала выделения равна -1 или совпадает с позицией текстового курсора, активного выделения нет — предикат HasLabelSelection выражает это правило для всего вызывающего кода. Метод  GetLabelSelectionRange возвращает упорядоченные позиции начала и конца выделения. Мы упорядочиваем позицию начала выделения и позицию текстового курсора так, чтобы начало диапазона всегда было меньше или равно концу независимо от направления выделения мышью, и в качестве защитной меры ограничиваем оба значения длиной буфера на случай, если он был изменён какой-либо параллельной операцией.

Метод DeleteLabelSelection выполняет атомарное удаление, к которому обращаются обработчики Backspace, Delete и вставки любого символа при замене выделенного текста. Мы получаем диапазон выделения, выделяем из буфера часть до начала диапазона и часть после его конца, объединяем их, затем устанавливаем текстовый курсор в начало удалённого участка и сбрасываем позицию начала выделения, делая выделение неактивным.

Это единственный фрагмент кода из этого файла, который мы рассмотрим. Остальные методы в файле ToolsPalette_Engine_Edit.mqh — перехват клавиатурного ввода, управление жизненным циклом редактирования (StartLabelEdit, CommitLabel, CancelLabel), операции с текстовым курсором (вставка, удаление, Backspace, навигация стрелками, Home, End, Page Up, Page Down), расширение выделения с помощью Shift и определение позиции текстового курсора по щелчку с учётом повёрнутой системы координат метки — следуют той же схеме: небольшие целенаправленные изменения m_labelEditBuffer и m_labelCaretPos в ответ на клавиатурные события графика. Наиболее сложная техническая часть (двухпроходное извлечение альфа-канала с использованием чёрного и белого фона для отрисовки глифов, композиция текста с суперсэмплингом, мигание текстового курсора) реализована в RenderEditableTextBlockAA, который мы уже рассматривали при знакомстве с универсальными вспомогательными функциями для работы с текстом; в основе лежит тот же приём, который мы подробно разобрали в статье из серии "Торговые системы на базе искусственного интеллекта", посвящённой отрисовке текста. Читателям, желающим подробнее изучить математику суперсэмплинга, приём с чёрным и белым фоном и попиксельное извлечение альфа-канала, рекомендуется обратиться к той статье: здесь та же логика применяется к редактируемому буферу с отслеживанием текстового курсора, а не к статической строке метки. Вопросы тестирования и визуализации рассматриваются в следующем разделе.


Визуализация

Мы компилируем программу, прикрепляем её к графику и опробуем каждый новый инструмент: размещаем каждую фигуру, добавляем каждую аннотацию и вводим текст в редактируемые текстовые метки.

GIF-анимация бэктеста

Во время тестирования фигуры размещались корректно, а их динамический предварительный контур следовал за указателем мыши между щелчками; инструменты аннотаций сразу переходили в режим редактирования с мигающим текстовым курсором внутри прямоугольника, а перенос слов в метках фигур "Прямоугольник", "Окружность" и "Эллипс" срабатывал автоматически, когда вводимый текст превышал ширину содержащей его фигуры. Клавиши со стрелками перемещали текстовый курсор по визуальным строкам, сочетание Shift со стрелкой расширяло выделение, а подтверждение редактирования при пустом буфере аннотации приводило к удалению объекта, как и было задумано.


Заключение

Итак, мы расширили слой рисования холста, добавив восемь новых инструментов для создания фигур — "Прямоугольник", "Треугольник", "Повернутый прямоугольник", "Повернутый эллипс", "Контур", "Окружность", "Дуга" и "Кривая" — и девять инструментов для создания аннотаций — "Текст", "Стрелка", "Маркер стрелки", "Стрелка вверх", "Стрелка вниз", "Примечание", "Примечание к цене", "Выноска" и "Комментарий". Кроме того, мы реализовали полноценную систему редактирования текста меток на холсте с управлением текстовым курсором с клавиатуры, переносом слов с учетом визуальных строк, расширением выделения сочетаниями Shift со стрелками, установкой текстового курсора щелчком мыши с учетом поворота рамки метки, а также перехватом клавиатурного управления графиком, чтобы ввод текста не запускал встроенную навигацию MetaTrader 5. Каждый новый инструмент подключается к той же цепочке операций — проверке попадания, выделению, изменению формы и предварительному просмотру в режиме "резинки", — которая была реализована ранее в этой серии статей, а редактируемые аннотации используют единый набор вспомогательных функций для работы с текстом, благодаря чему все инструменты с текстовым буфером ведут себя единообразно. Прочитав эту статью, вы сможете:

  • Реализовать на пользовательском слое холста инструменты для рисования фигур с заливкой и сглаживанием границ по знаковому расстоянию, а также квадратичные кривые Безье с заливкой областей, замкнутых хордами.
  • Отрисовывать аннотации с присоединением к середине стороны, стержнями выносок в восьми направлениях, скруглёнными прямоугольниками с суперсэмплингом и тенями, полученными двухпроходным разделяемым прямоугольным размытием.
  • Создать на холсте полноценный текстовый редактор с переносом слов на несколько строк, мигающим текстовым курсором, выделением сочетаниями Shift со стрелками и установкой текстового курсора щелчком мыши с учетом поворота рамки метки.

В следующей части серии мы добавим ленту редактирования свойств отдельных объектов, которая будет появляться рядом с текущим выделением. С помощью специальных виджетов пользователь сможет настраивать цвета, непрозрачность, толщину линий, стили штриховых линий, размеры шрифта, видимость по уровням и все прочие свойства каждого инструмента. Изменения будут сразу отображаться в предварительном просмотре, как и при редактировании объектов в терминале. Следите за новостями.


Вложения

№ п/п Название Тип Описание
1 Tools Palette Part 7.mq5 Советник Основная точка входа советника, которая владеет глобальным экземпляром боковой панели и перенаправляет ему вызовы обработчиков инициализации, деинициализации, событий графика и таймера.
2 ToolsPalette_Annotations.mqh Файл включения Библиотека инструментов для создания аннотаций, включающая "Текст", "Стрелка", "Маркер стрелки", "Стрелка вверх", "Стрелка вниз", "Примечание", "Примечание к цене", "Выноска" и "Комментарий", а также универсальные вспомогательные функции для переноса слов, измерения текстовых блоков и отображения редактируемого текста.
3 ToolsPalette_Channels.mqh Файл включения Библиотека каналов, вил и инструментов Ганна, содержащая все процедуры рисования и тестеры попадания для этих инструментов, созданные в предыдущей части.
4 ToolsPalette_Crosshair.mqh Файл включения Менеджер перекрестия, управляющий холстами прицельной метки, лупы, перекрещивающихся линий и измерений, а также соответствующими метками на осях.
5 ToolsPalette_Engine_Edit.mqh Файл включения Тела методов движка рисования для подсистемы редактирования меток на месте, охватывающие жизненный цикл редактирования, операции с текстовым курсором, модель выделения, навигацию с расширением выделения при нажатой клавише Shift, определение позиции текстового курсора по щелчку мыши и перехват клавиатурного ввода графика.
6 ToolsPalette_Engine_Interact.mqh Файл включения Тела методов движка рисования для взаимодействия в режиме указателя, охватывающие диспетчеризацию проверок попадания, логику изменения формы с помощью маркеров, обработку перемещения при перетаскивании и отпускания кнопки мыши, а также управление выделением.
7 ToolsPalette_Engine_Render.mqh Файл включения Тела методов движка рисования для конвейера рендеринга, охватывающие диспетчеризацию полной перерисовки, предварительный просмотр с эффектом "резинки", рендеринг меток с обрезкой по фигурам и постоянные метки осей.
8 ToolsPalette_Fibonacci.mqh Файл включения Библиотека инструментов Фибоначчи, включающая уровни коррекции, расширение, канал, временные зоны, веер скоростного сопротивления и дуги скоростного сопротивления.
9 ToolsPalette_Lines.mqh Файл включения Базовый класс линейных инструментов, предоставляющий функции рисования линии тренда, луча, бесконечной прямой, горизонтальной линии, вертикальной линии, перекрещивающихся линий, информационной линии и линии тренда по углу, а также общий рендерер маркеров и механизм диспетчеризации значков инструментов.
10 ToolsPalette_Primitives.mqh Файл включения Базовые пиксельные примитивы, включающие установку пикселя с альфа-композитингом, рисование толстой линии со сглаживанием и заливку круга с суперсэмплингом, а также менеджер тем и объявления входных параметров.
11 ToolsPalette_Shapes.mqh Файл включения Библиотека инструментов для работы с фигурами, включающая процедуры рисования и тестеры попадания для прямоугольника, треугольника, повернутого прямоугольника, повернутого эллипса, контура, окружности, дуги и кривой.
12 ToolsPalette_Shell.mqh Файл включения Оболочка боковой панели, которая маршрутизирует события графика, распределяет клавиатурный ввод при редактировании меток, управляет таймером мигания текстового курсора и предоставляет публичный интерфейс верхнего уровня, используемый советником.
13 ToolsPalette_Sidebar.mqh Файл включения Рендерер боковой панели и раскрывающаяся панель: расположение плиток категорий, открытие и закрытие раскрывающейся панели, обработка прокрутки и панель удаления в категории действий.
14 ToolsPalette_Tools.mqh Файл включения Реестр инструментов и сам класс движка рисования, включая структуру нарисованного объекта, систему запоминания инструментов, движок размещения и цвета инструментов по умолчанию.
15 Tools Palette Part 7.zip
Архив Готовый к распаковке архив со всеми 14 файлами проекта в одной папке. Распакуйте архив в папку данных терминала MetaTrader 5. Все файлы будут размещены в нужных местах внутри MQL5/Experts/ и готовы к компиляции.


Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/22856

Прикрепленные файлы |
Последние комментарии | Перейти к обсуждению на форуме трейдеров (2)
DonEps
DonEps | 16 июн. 2026 в 10:30
Это действительно отличная работа! Я как раз сейчас её тестирую.
Allan Munene Mutiiria
Allan Munene Mutiiria | 16 июн. 2026 в 12:43
DonEps #:
Это действительно отличная работа! Я как раз сейчас её тестирую.
Спасибо за добрые отзывы. Конечно.
Особенности написания Пользовательских Индикаторов Особенности написания Пользовательских Индикаторов
Написание пользовательских индикаторов в торговой системе MetaTrader 4
Автоматизация классических рыночных методов на MQL5 (Часть 6): Система ключевых точек Джесси Ливермора Автоматизация классических рыночных методов на MQL5 (Часть 6): Система ключевых точек Джесси Ливермора
В данной статье представлен готовый советник на языке MQL5, в котором «рыночный ключ» Джесси Ливермора реализован в виде детерминированного конечного автомата. Он определяет ключевые уровни по консолидациям, используя ATR и рост объема, поэтапно наращивает позиции четырьмя траншами и закрывает их при аномальном поведении, определяемом по диапазону и объему. Советник проверяет входные параметры в OnInit, требует хеджингового счета и компилируется без дополнительных доработок для тестирования правил Ливермора на дневных данных.
Особенности написания экспертов Особенности написания экспертов
Написание и тестирование экспертов в торговой системе MetaTrader 4.
Разработка персонального советника (Часть 3): Управление рисками II — маржа и допустимый риск Разработка персонального советника (Часть 3): Управление рисками II — маржа и допустимый риск
Объем в лотах, рассчитанный по риску, все равно может превышать объем, который позволяет открыть свободная маржа. В статье добавляются лимит использования маржи с применением OrderCalcMargin(), опциональный адаптивный лимит использования маржи, который изменяется в зависимости от уровня маржи счета (ACCOUNT MARGIN LEVEL), и единый блок предторговой проверки, объединяющий ограничения по позициям, расчет объема позиции по риску и проверки маржи. Читатели получат конкретный код, позволяющий предотвратить отклонение ордеров и чрезмерное использование маржи, с понятными сообщениями в журнале при уменьшении объема сделки или отказе от ее открытия.