Торговые инструменты MQL5 (Часть 36): Фигуры и аннотации в слое рисования с редактированием меток прямо на холсте
Введение
В предыдущей статье (часть 35) мы расширили слой рисования на холсте, добавив семь категорий аналитических инструментов рисования с несколькими опорными точками — каналы, вилы, инструменты Ганна и Фибоначчи — и подключив их к тому же конвейеру проверки попадания, выделения, изменения формы и предварительного просмотра в режиме "резинки", что и базовые инструменты рисования линий. Набор аналитических инструментов теперь укомплектован, но на холсте по-прежнему не хватает двух составляющих, необходимых для любой полноценной работы с аннотациями на графике: фигур, которые трейдер может заливать цветом и форму которых может изменять (прямоугольников, треугольников, кругов, эллипсов, дуг, кривых, контуров, повернутых прямоугольников), и инструментов аннотирования с редактируемым текстом (примечаний, выносок, комментариев, стрелок, ценовых меток). Без них холст доступен только для просмотра: трейдер может отмечать структуру, но не может подписать её, прокомментировать торговую ситуацию или закрепить ценовое примечание рядом с уровнем.
Мы добавили семнадцать новых инструментов в двух категориях. Категория "Фигуры" включает восемь инструментов: "Прямоугольник" (теперь с восемью маркерами), "Треугольник", "Повернутый прямоугольник", "Повернутый эллипс", "Контур" (ломаная из N точек), "Окружность", "Дуга" (квадратичная кривая Безье с ограничением положения вершины) и "Кривая" (квадратичная кривая Безье со свободной вершиной). В категории "Аннотации" представлены остальные девять инструментов: "Текст", "Стрелка", "Маркер стрелки", "Стрелка вверх", "Стрелка вниз", "Примечание", "Примечание к цене", "Выноска" и "Комментарий". У большинства этих инструментов метки можно редактировать, поэтому мы реализуем текстовый редактор, работающий непосредственно на холсте. Он поддерживает конечный автомат редактирования, основанный на положении текстового курсора, многострочный перенос слов (подбор вмещающегося префикса бинарным поиском), отрисовку текста с суперсэмплингом и попиксельным извлечением альфа-канала, определение позиции текстового курсора по щелчку мыши, преобразование в Unicode кодов виртуальных клавиш Windows, а также выделение текста сочетаниями Shift со стрелками.
Эта статья предназначена для разработчиков среднего и продвинутого уровня, использующих MetaQuotes Language 5 (MQL5) и хорошо знакомых с цепочкой наследования, которую мы построили в предыдущих частях. Мы рассмотрим следующие темы:
- От аналитических инструментов к визуальным аннотациям с редактируемым текстом
- Реализация инструментов рисования фигур
- Реализация инструментов аннотирования
- Реализация системы редактирования меток на месте
- Визуализация
- Заключение
В итоге слой рисования на холсте будет содержать полный набор инструментов для создания фигур и аннотаций с редактируемыми текстовыми метками, а трейдер сможет щелкнуть любую аннотацию и вводить текст прямо на графике — с мигающим текстовым курсором, переносом слов, навигацией клавишами со стрелками и выделением сочетанием 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.

Второй — небольшая группа констант, задающих фиксированные размеры в пикселях для маркеров "Стрелка вверх" и "Стрелка вниз" (общая высота, длина наконечника, половина ширины стержня, половина ширины наконечника), благодаря чему силуэт сохраняет одинаковый размер независимо от масштаба.
В классе для каждого инструмента аннотирования объявляются процедура рисования и соответствующий тестер попадания. Для аннотации "Текст" также предусмотрена вспомогательная функция 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, который мы уже рассматривали при знакомстве с универсальными вспомогательными функциями для работы с текстом; в основе лежит тот же приём, который мы подробно разобрали в статье из серии "Торговые системы на базе искусственного интеллекта", посвящённой отрисовке текста. Читателям, желающим подробнее изучить математику суперсэмплинга, приём с чёрным и белым фоном и попиксельное извлечение альфа-канала, рекомендуется обратиться к той статье: здесь та же логика применяется к редактируемому буферу с отслеживанием текстового курсора, а не к статической строке метки. Вопросы тестирования и визуализации рассматриваются в следующем разделе.
Визуализация
Мы компилируем программу, прикрепляем её к графику и опробуем каждый новый инструмент: размещаем каждую фигуру, добавляем каждую аннотацию и вводим текст в редактируемые текстовые метки.

Во время тестирования фигуры размещались корректно, а их динамический предварительный контур следовал за указателем мыши между щелчками; инструменты аннотаций сразу переходили в режим редактирования с мигающим текстовым курсором внутри прямоугольника, а перенос слов в метках фигур "Прямоугольник", "Окружность" и "Эллипс" срабатывал автоматически, когда вводимый текст превышал ширину содержащей его фигуры. Клавиши со стрелками перемещали текстовый курсор по визуальным строкам, сочетание 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
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.
Это действительно отличная работа! Я как раз сейчас её тестирую.