Торговые инструменты MQL5 (Часть 37): Добавление ленты редактирования свойств отдельных объектов в слой рисования на холсте
Введение
В предыдущей статье (часть 36) мы добавили инструменты для создания фигур и аннотаций с возможностью редактирования меток непосредственно на объектах, благодаря чему теперь можно рисовать фигуры с заливкой, размещать маркеры аннотаций и вводить текст непосредственно на объектах графика. Однако после размещения объекта его внешний вид фиксируется. Цвета, непрозрачность, ширина линий, стили линий, шрифты и видимость отдельных уровней — всё это фиксируется при создании на основе настроек инструмента по умолчанию или сохранённых для него настроек; нет возможности выделить прямоугольник и изменить цвет его заливки, приглушить уровень Фибоначчи, изменить стиль центральной линии канала или утолщить линию тренда уже после создания объекта. На слое рисования можно создавать объекты, но нельзя их редактировать.
В этой части эта проблема устраняется с помощью плавающей ленты редактирования свойств. Мы добавляем четыре новых файла, которые образуют стек свойств, управляемый дескрипторами:
- Система дескрипторов, определяющая, какие свойства предоставляет каждый инструмент
- API получения и установки со стороны движка с динамическим предварительным просмотром на основе моментальных снимков
- Рендереры виджетов для каждого элемента управления
- Панель ленты, которая отображается рядом с текущим выделением и связывает виджеты с движком
При выборе любого объекта отображаются его редактируемые свойства; изменение значения обновляет объект на графике в реальном времени, а отмена восстанавливает его исходное состояние. Эта статья предназначена для разработчиков среднего и продвинутого уровня, работающих на языке MetaQuotes Language 5 (MQL5) и хорошо знакомых с цепочкой наследования, которую мы создали в предыдущих частях. Мы рассмотрим следующие темы:
- От фиксированных стилей к свойствам, редактируемым пользователем
- Создание системы дескрипторов свойств
- Отображение виджетов редактирования свойств
- Сборка ленты свойств
- Визуализация
- Заключение
В итоге каждый объект на слое рисования холста можно будет полностью редактировать с помощью компактной перетаскиваемой ленты: для каждого инструмента будут отображаться только применимые к нему свойства, а предварительный просмотр в реальном времени будет обновлять график по мере перемещения ползунка или выбора цвета пользователем.
От фиксированных стилей к свойствам, редактируемым пользователем
Каждый нарисованный объект уже содержит полную информацию о своём визуальном состоянии в виде полей структуры объекта — ширину линии, стиль линии, цвет заливки и непрозрачность, цвет текста, размер шрифта, массивы соотношений и видимости для каждого уровня, значения сигмы полос каналов, цвета зубцов вилки и так далее. До сих пор эти поля заполнялись один раз при размещении объекта — либо значениями инструмента по умолчанию, либо значениями из памяти конкретного инструмента — и больше не изменялись. Предоставление доступа к ним для редактирования — задача не отрисовки, поскольку процедуры рисования уже считывают эти поля при каждой перерисовке, а пользовательского интерфейса: нужно передать значение из виджета в нужное поле нужного объекта.
При наивном подходе пришлось бы вручную создавать отдельную панель редактирования для каждого из сорока с лишним инструментов. Такой подход приводит к огромному объёму дублирования и превращает сопровождение в настоящий кошмар. Вместо этого мы используем подход, основанный на дескрипторах. Каждый инструмент регистрирует список дескрипторов свойств, которые определяют, какие свойства он предоставляет: свойство цвета заливки, свойство ширины линии и свойство списка уровней. Каждый дескриптор задаёт тип, метку, диапазон значений и строковый идентификатор. Лента считывает этот список и отображает соответствующий виджет для каждой записи. Затем один общий конвейер управляет работой всех инструментов. Добавление свойства к инструменту теперь сводится к регистрации в одной строке, а не к созданию новой панели.
Эта система состоит из четырёх частей. Слой дескрипторов определяет, какие свойства предоставляет инструмент. Слой виджетов определяет, как отображается и редактируется каждое свойство. Слой API получения и установки свойств движка сопоставляет идентификатор дескриптора с полем объекта. Наконец, механизм снимка и восстановления обеспечивает предварительный просмотр в реальном времени: изменения, внесённые с помощью ползунка, применяются немедленно, а при отмене восстанавливается состояние из снимка, сделанного при открытии ленты. Теперь, когда концептуальная схема определена, можно перейти к реализации, но сначала взгляните на её наглядное представление ниже.

Создание системы дескрипторов свойств
Модель дескрипторов свойств
Создание системы свойств начнём с объявления двух основополагающих элементов, на которых строится всё остальное: перечисления PROP_TYPE, задающего все типы редактируемых свойств, и структуры SToolProperty, описывающей отдельное свойство. Вместе они позволяют представлять свойства, доступные у инструмента, в виде обычных данных, а не кода, написанного вручную.
//+------------------------------------------------------------------+ //| ToolsPalette_Properties.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_PROPERTIES_MQH #define TOOLS_PALETTE_PROPERTIES_MQH //--- Pull in the Tools header so TOOL_TYPE and DrawnObject are visible #include "ToolsPalette_Tools.mqh" //+------------------------------------------------------------------+ //| Widget-type enum - drives which UI widget renders each property | //+------------------------------------------------------------------+ enum PROP_TYPE { PROP_COLOR, // color swatch + popup grid + opacity slider PROP_LINE_WIDTH, // dropdown of 1px/2px/3px/4px line previews PROP_LINE_STYLE, // dropdown of continuous/dashed/dotted PROP_FONT_SIZE, // dropdown of common font sizes PROP_TEXT, // single-line text input PROP_MULTITEXT, // multi-line text input (text-tab content) PROP_BOOL, // checkbox PROP_OPACITY, // slider 0..100 percent (used inside color picker) PROP_DROPDOWN_INT, // generic int dropdown with string options PROP_NUMERIC, // number input with optional spinners PROP_PRICE, // price input (for coordinate-tab rows) PROP_TIME, // time/bar input (for coordinate-tab rows) PROP_FLOAT, // bounded double with min/max/step/decimals PROP_COMPACT_ROW, // composite row: checkbox + value + color + width + style mini-cubes on one line PROP_LEVEL_LIST, // meta descriptor that expands at runtime into N compact rows + "Add level" row PROP_ACTION // sentinel for action-button ribbon icons (Settings, Remove) }; //--- Settings-window tab group names #define PROP_GROUP_STYLE "Style" #define PROP_GROUP_TEXT "Text" #define PROP_GROUP_COORDS "Coordinates" #define PROP_GROUP_VISIBILITY "Visibility" //+------------------------------------------------------------------+ //| SToolProperty - one descriptor entry per editable tool property | //+------------------------------------------------------------------+ struct SToolProperty { //--- Identity + display label + widget type + tab grouping string id; string label; PROP_TYPE type; string group; bool showInRibbon; bool showInSettings; string tooltip; //--- Default value (one slot per supported value type) color defaultColor; int defaultInt; double defaultDouble; string defaultString; bool defaultBool; //--- Dropdown options (used by PROP_DROPDOWN_INT and similar) string options[]; int optionInts[]; //--- Numeric bounds + step + decimal-places (used by PROP_FLOAT and PROP_LEVEL_LIST) double minValue; double maxValue; double stepValue; int decimals; //--- Sub-property IDs for PROP_COMPACT_ROW (the row's checkbox/value/color/width/style cubes) string subVisibleId; string subValueId; string subColorId; string subWidthId; string subStyleId; //--- Runtime-set fields used by PROP_LEVEL_LIST pseudo-row synthesis int levelIdx; bool isAddLevelRow; string levelListPrefix; };
Мы защищаем заголовочный файл от повторного включения с помощью макроса TOOLS_PALETTE_PROPERTIES_MQH и подключаем заголовочный файл Tools, чтобы сделать доступными тип TOOL_TYPE и структуры DrawnObject. Далее перечисление PROP_TYPE задаёт все типы виджетов, которые могут отображаться на ленте и в окне настроек: панель выбора цвета (PROP_COLOR), выпадающие списки ширины и стиля линии (PROP_LINE_WIDTH и PROP_LINE_STYLE), выпадающий список размера шрифта, одно- и многострочные поля ввода текста, флажок (PROP_BOOL), ползунок непрозрачности, универсальный выпадающий список целых чисел, поля ввода чисел, цен и времени, а также поле для значения с плавающей точкой в заданных пределах. Три записи являются особыми: PROP_COMPACT_ROW — это составной элемент, который объединяет флажок, шаговый регулятор и мини-кубики цвета, ширины и стиля в одной строке; PROP_LEVEL_LIST — это метадескриптор, который во время выполнения разворачивается в одну компактную строку для каждого уровня Фибоначчи или Ганна плюс строку "Добавить уровень"; а PROP_ACTION — это маркер для кнопок действий на ленте, таких как "Настройки" и "Удалить".
Мы также определяем четыре макроса с названиями групп свойств (PROP_GROUP_STYLE, PROP_GROUP_TEXT, PROP_GROUP_COORDS, PROP_GROUP_VISIBILITY), которые распределяют свойства по вкладкам в окне настроек. Мы задаём эти определения заранее, поскольку они понадобятся при интеграции окна настроек, которая завершит формирование структуры. Мы планируем использовать для этой панели настроек стандартное окно настроек инструментов веб-версии MQL5, хотя оно практически не отличается от окна в нативном терминале. Для наглядности см. пример ниже.

Далее рассмотрим структуру SToolProperty: каждый её экземпляр представляет собой дескриптор одного редактируемого свойства. Блок идентификации содержит строковый идентификатор (ключ, по которому API получения и установки движка находит соответствующее поле), отображаемую подпись, тип PROP_TYPE, группу для размещения на вкладке, два флага, определяющие, отображается ли свойство на ленте и в окне настроек, а также всплывающую подсказку. Поскольку свойство может хранить значение одного из нескольких типов, мы выделяем для него по одному полю для значения по умолчанию каждого типа — color, int, double, string и bool, — а код регистрации заполняет поле соответствующего типа. Массивы выпадающих списков содержат подписи вариантов и соответствующие им целочисленные значения для PROP_DROPDOWN_INT, а числовой блок — минимум, максимум, шаг и количество знаков после запятой для PROP_FLOAT и списка уровней.
Последние два блока поддерживают составные типы. Поля идентификаторов подсвойств связывают каждый мини-кубик компактной строки с соответствующим базовым свойством: флажку, значению, цвету, ширине и стилю линии в этой строке соответствует отдельное свойство движка, определяемое по идентификатору. А поля времени выполнения внизу — levelIdx, isAddLevelRow и levelListPrefix — остаются пустыми в статических дескрипторах и заполняются только тогда, когда PROP_LEVEL_LIST разворачивается в отдельные строки для каждого уровня во время рендеринга; именно так один дескриптор списка уровней превращается в N конкретных строк. После объявления модели дескрипторов мы можем перейти к вспомогательным функциям регистрации, которые формируют эти записи.
Вспомогательные функции регистрации
Мы добавляем три небольшие вспомогательные функции, которые используются в функциях регистрации отдельных инструментов. Две из них добавляют записи дескрипторов в список свойств, а третья определяет, какое свойство непрозрачности соответствует заданному свойству цвета.
//+------------------------------------------------------------------+ //| Map a color property ID to its sibling opacity property ID | //+------------------------------------------------------------------+ string ColorToOpacityProp(string colorPropId) { //--- Hand-rolled mapping for the 5 known top-level color properties if(colorPropId == "textColor") return "textOpacity"; if(colorPropId == "fillColor") return "fillOpacity"; if(colorPropId == "fillColor2") return "fillOpacity2"; if(colorPropId == "midColor") return "midOpacity"; if(colorPropId == "centerColor") return "centerOpacity"; //--- Per-level color IDs end with ":color"; rewrite the suffix to ":opacity" const int trailLen = StringLen(":color"); const int propLen = StringLen(colorPropId); if(propLen > trailLen && StringSubstr(colorPropId, propLen - trailLen, trailLen) == ":color") { return StringSubstr(colorPropId, 0, propLen - trailLen) + ":opacity"; } //--- Default fallback: every unknown color maps to the main line opacity return "lineOpacity"; } //+------------------------------------------------------------------+ //| Append a compact-row descriptor (checkbox + value + color cubes) | //+------------------------------------------------------------------+ void AddCompactRowDescriptor(SToolProperty &props[], string id, string label, string subVisibleId, string subValueId, string subColorId, string subWidthId, string subStyleId, string group = "Style", double minValue = 0.0, double maxValue = 100.0, double stepValue = 0.1, int decimals = 2) { //--- Grow the array by one + populate the new entry const int n = ArraySize(props); ArrayResize(props, n + 1); props[n].id = id; props[n].label = label; props[n].type = PROP_COMPACT_ROW; props[n].group = group; //--- Compact rows live only in the settings window, never in the ribbon props[n].showInRibbon = false; props[n].showInSettings = true; props[n].tooltip = ""; //--- Default-value slots (compact rows themselves don't carry a value, but populate for safety) props[n].defaultColor = clrBlack; props[n].defaultInt = 0; props[n].defaultDouble = 0.0; props[n].defaultString = ""; props[n].defaultBool = false; //--- Numeric stepper bounds for the row's value cube props[n].minValue = minValue; props[n].maxValue = maxValue; props[n].stepValue = stepValue; props[n].decimals = decimals; //--- Sub-property IDs that wire each mini-cube to its underlying engine property props[n].subVisibleId = subVisibleId; props[n].subValueId = subValueId; props[n].subColorId = subColorId; props[n].subWidthId = subWidthId; props[n].subStyleId = subStyleId; //--- Not a level pseudo-row (those get their levelIdx set at runtime) props[n].levelIdx = -1; props[n].isAddLevelRow = false; props[n].levelListPrefix = ""; } //+------------------------------------------------------------------+ //| Append a single SToolProperty entry to a property list | //+------------------------------------------------------------------+ void AddPropertyDescriptor(SToolProperty &props[], string id, string label, PROP_TYPE type, string group, bool showInRibbon, bool showInSettings, string tooltip = "") { //--- Grow the array by one + populate the new entry's identity fields int n = ArraySize(props); ArrayResize(props, n + 1); props[n].id = id; props[n].label = label; props[n].type = type; props[n].group = group; props[n].showInRibbon = showInRibbon; props[n].showInSettings = showInSettings; props[n].tooltip = tooltip; //--- Not a level pseudo-row (caller can override later for the level-list case) props[n].levelIdx = -1; props[n].isAddLevelRow = false; props[n].levelListPrefix = ""; }
Здесь функция ColorToOpacityProp нужна потому, что каждому цвету в системе соответствует свойство непрозрачности, которое редактируется на панели выбора цвета вместе с самим цветом: и выбор цвета заливки, и перетаскивание ползунка непрозрачности приводят к записи через API свойств, поэтому панели выбора цвета необходимо знать, какой идентификатор непрозрачности соответствует идентификатору цвета, для которого она была открыта. Для пяти цветов верхнего уровня (текст, заливка, вторая заливка, средняя линия, центр) сопоставление задаётся вручную. Для цветов отдельных уровней, идентификаторы которых имеют формат prefix:color, мы заменяем конечную часть :color на :opacity, чтобы идентификатор цвета уровня Фибоначчи преобразовывался в идентификатор непрозрачности этого же уровня. Для любого нераспознанного идентификатора используется свойство непрозрачности основной линии.
AddCompactRowDescriptor добавляет запись PROP_COMPACT_ROW — однострочный составной элемент, объединяющий флажок, шаговый регулятор и мини-кубы цвета, ширины и стиля. Функция увеличивает размер массива дескрипторов на единицу и заполняет новую запись: помечает её как предназначенную только для настроек (компактные строки никогда не отображаются на ленте), задаёт числовые границы шагового регулятора для куба значения и привязывает все пять идентификаторов подсвойств, чтобы каждый мини-куб знал, какое свойство движка он редактирует. Поля времени выполнения списка уровней здесь остаются пустыми, поскольку статическая компактная строка сама по себе не является псевдострокой отдельного уровня.
AddPropertyDescriptor — это универсальная функция добавления для всех несоставных свойств. Она увеличивает размер массива, заполняет блок идентификации на основе переданных аргументов — id, label, type, group, двух флагов видимости и всплывающей подсказки — и очищает поля времени выполнения списка уровней, которые вызывающий код может затем переопределить для списка уровней. Обе функции добавления следуют одному шаблону: сначала увеличивают размер массива на единицу, затем заполняют новую запись, поэтому функции регистрации на следующих этапах представляют собой простую последовательность вызовов AddPropertyDescriptor — по одному на каждое свойство, предоставляемое инструментом. Далее мы определим собственно логику регистрации этих инструментов.
Регистрация набора свойств инструмента
Теперь рассмотрим типичную функцию регистрации RegisterLineToolWithLabelProperties, которая объявляет полный набор свойств линейных инструментов с метками: линии тренда, луча, продлённой линии, горизонтальной и вертикальной линий, информационной линии и угла тренда. Для каждого семейства инструментов предусмотрена своя такая функция, и все они представляют собой простую последовательность вызовов AddPropertyDescriptor.
//+------------------------------------------------------------------+ //| Register standard property set for line tools WITH text label | //+------------------------------------------------------------------+ void RegisterLineToolWithLabelProperties(SToolProperty &props[]) { //--- Line color (ribbon + settings) AddPropertyDescriptor(props, "lineColor", "Line color", PROP_COLOR, PROP_GROUP_STYLE, true, true, "Line tool colors"); //--- Text color (ribbon + settings, lives in the Text tab) AddPropertyDescriptor(props, "textColor", "Text color", PROP_COLOR, PROP_GROUP_TEXT, true, true, "Line tool text colors"); //--- Line width + style (default 2 px, solid) AddPropertyDescriptor(props, "lineWidth", "Width", PROP_LINE_WIDTH, PROP_GROUP_STYLE, true, true, "Line tool widths"); props[ArraySize(props) - 1].defaultInt = 2; AddPropertyDescriptor(props, "lineStyle", "Style", PROP_LINE_STYLE, PROP_GROUP_STYLE, true, true, "Style"); props[ArraySize(props) - 1].defaultInt = 0; //--- Line opacity (settings only) AddPropertyDescriptor(props, "lineOpacity", "Line opacity", PROP_OPACITY, PROP_GROUP_STYLE, false, true, ""); props[ArraySize(props) - 1].defaultInt = 100; //--- Label text + per-text opacity + font size + bold + alignment AddPropertyDescriptor(props, "text", "Text", PROP_TEXT, PROP_GROUP_TEXT, false, true, ""); AddPropertyDescriptor(props, "textOpacity", "Text opacity", PROP_OPACITY, PROP_GROUP_TEXT, false, true, ""); props[ArraySize(props) - 1].defaultInt = 100; AddPropertyDescriptor(props, "fontSize", "Font size", PROP_FONT_SIZE, PROP_GROUP_TEXT, false, true, ""); props[ArraySize(props) - 1].defaultInt = 11; AddPropertyDescriptor(props, "bold", "Bold", PROP_BOOL, PROP_GROUP_TEXT, false, true, ""); props[ArraySize(props) - 1].defaultBool = false; //--- Vertical alignment (default Top = 0) AddPropertyDescriptor(props, "vAlign", "Vertical alignment", PROP_DROPDOWN_INT, PROP_GROUP_TEXT, false, true, ""); props[ArraySize(props) - 1].defaultInt = 0; //--- Horizontal alignment (default Center = 1) AddPropertyDescriptor(props, "hAlign", "Horizontal alignment", PROP_DROPDOWN_INT, PROP_GROUP_TEXT, false, true, ""); props[ArraySize(props) - 1].defaultInt = 1; }
Функция добавляет по одному дескриптору на каждое редактируемое свойство, предоставляемое линейными инструментами с метками. Цвет линии и цвет текста указаны первыми; для обоих установлен флажок, чтобы они отображались на ленте и в окне настроек, при этом цвет текста отнесен к вкладке "Текст". Далее задаются ширина и стиль линии, которые также отображаются на ленте, и сразу после каждого вызова мы обращаемся к только что добавленной записи через props[ArraySize(props) - 1], чтобы задать её целочисленное значение по умолчанию: для ширины — 2 пикселя, для стиля — 0 (сплошная линия). Такое обращение к последнему добавленному элементу — принятый здесь способ задания значения по умолчанию, поскольку AddPropertyDescriptor заполняет только блок идентификации, а ячейки значений оставляет без изменений.
Остальные свойства отображаются только в настройках: флаг отображения на ленте у них установлен в false, поэтому они появляются в окне настроек, но не на компактной ленте. Непрозрачность линии по умолчанию равна 100; далее следуют текст метки, отдельная непрозрачность текста (также 100), размер шрифта (по умолчанию 11), флажок полужирного начертания и раскрывающиеся списки вертикального и горизонтального выравнивания, завершающие вкладку "Текст". Раскрывающиеся списки выравнивания представлены записями типа PROP_DROPDOWN_INT, к которым слой виджетов позднее добавляет подписи и значения вариантов; по умолчанию вертикальное выравнивание — "По верхнему краю" (0), а горизонтальное — "По центру" (1).
Порядок этих вызовов имеет значение, поскольку именно в таком порядке окно настроек отображает строки. Все остальные функции регистрации в файле устроены так же: функции для замкнутых фигур, каналов, вил, инструментов Ганна и аннотаций добавляют соответствующие дескрипторы и аналогичным образом задают значения по умолчанию, поэтому мы не будем разбирать каждую из них отдельно. Действительно новый механизм появляется лишь в функции регистрации свойств инструмента Фибоначчи, которую мы рассмотрим далее.
Регистрация списка уровней Фибоначчи
Теперь мы переходим к механизму списка уровней, благодаря которому инструменты Фибоначчи и Ганна предоставляют редактируемый список уровней соотношений, а не фиксированный набор свойств. Мы определим вспомогательную функцию AddLevelListDescriptor для многократного использования, а затем рассмотрим, как инструмент "Коррекция Фибоначчи" регистрирует собственный список уровней.
//+------------------------------------------------------------------+ //| Append a PROP_LEVEL_LIST descriptor (helper for other Fib/Gann) | //+------------------------------------------------------------------+ void AddLevelListDescriptor(SToolProperty &props[], string id, string label, double minR, double maxR, double stepR, int dec) { //--- Grow + populate the new descriptor const int n = ArraySize(props); ArrayResize(props, n + 1); props[n].id = id; props[n].label = label; props[n].type = PROP_LEVEL_LIST; props[n].group = PROP_GROUP_STYLE; //--- Levels live only in the settings window props[n].showInRibbon = false; props[n].showInSettings = true; props[n].tooltip = ""; //--- Default-value slots props[n].defaultColor = clrBlack; props[n].defaultInt = 0; props[n].defaultDouble = 0.0; props[n].defaultString = ""; props[n].defaultBool = false; //--- Caller-supplied per-level ratio bounds + step + decimal places props[n].minValue = minR; props[n].maxValue = maxR; props[n].stepValue = stepR; props[n].decimals = dec; //--- No per-row sub-IDs (rows are synthesized at runtime from the level data) props[n].subVisibleId = ""; props[n].subValueId = ""; props[n].subColorId = ""; props[n].subWidthId = ""; props[n].subStyleId = ""; props[n].levelIdx = -1; props[n].isAddLevelRow = false; props[n].levelListPrefix = ""; } //+------------------------------------------------------------------+ //| Register property set for Fibonacci retracement (PROP_LEVEL_LIST)| //+------------------------------------------------------------------+ void RegisterFibonacciRetracementProperties(SToolProperty &props[]) { //--- Default level color (ribbon-only; cascades onto per-level colors when changed) AddPropertyDescriptor(props, "lineColor", "Default level color", PROP_COLOR, PROP_GROUP_STYLE, true, false, "Default color for new levels"); //--- Levels list descriptor - manually populated (predates AddLevelListDescriptor below) const int n = ArraySize(props); ArrayResize(props, n + 1); props[n].id = "fibo"; props[n].label = "Levels"; props[n].type = PROP_LEVEL_LIST; props[n].group = PROP_GROUP_STYLE; //--- Levels live only in the settings window, never in the ribbon props[n].showInRibbon = false; props[n].showInSettings = true; props[n].tooltip = ""; //--- Default-value slots props[n].defaultColor = clrBlack; props[n].defaultInt = 0; props[n].defaultDouble = 0.0; props[n].defaultString = ""; props[n].defaultBool = false; //--- Ratio bounds for each level's value cube: -10..10 with 0.01 step and 3 decimal places props[n].minValue = -10.0; props[n].maxValue = 10.0; props[n].stepValue = 0.01; props[n].decimals = 3; //--- The level-list itself has no per-row sub-IDs (rows are synthesized at runtime) props[n].subVisibleId = ""; props[n].subValueId = ""; props[n].subColorId = ""; props[n].subWidthId = ""; props[n].subStyleId = ""; props[n].levelIdx = -1; props[n].isAddLevelRow = false; props[n].levelListPrefix = ""; }
Мы используем функцию добавления AddLevelListDescriptor для добавления одной записи PROP_LEVEL_LIST. Мы увеличиваем размер массива на один элемент и заполняем новую запись аналогично другим функциям добавления: помечаем её как отображаемую только в настройках и сохраняем переданные вызывающим кодом ограничения для соотношений уровней — минимум, максимум, шаг и число знаков после запятой, которые кубик значения каждого уровня будет учитывать при редактировании соотношения. Здесь мы намеренно оставляем пустыми все пять полей идентификаторов подсвойств, поскольку, в отличие от статической компактной строки, строки отдельных уровней в списке ещё не существуют: мы формируем их во время выполнения на основе фактических данных об уровнях объекта, поэтому на этапе регистрации связывать ещё нечего. Нам нужно, чтобы эти уровни совпадали с уровнями в штатном интерфейсе терминала. См. ниже.

В функции RegisterFibonacciRetracementProperties мы сначала добавляем дескриптор lineColor с подписью "Цвет уровней по умолчанию". Мы помечаем его как видимый на ленте, но скрытый в настройках, и используем как каскадный элемент управления: когда пользователь меняет его значение на ленте, выбранный цвет применяется ко всем уровням. Затем мы добавляем сам дескриптор списка уровней. В данном случае мы заполняем его вручную, а не вызываем вспомогательную функцию, поскольку этот код регистрации появился раньше неё, но результат тот же: запись PROP_LEVEL_LIST с идентификатором fibo, видимая только в настройках, с диапазоном коэффициента от -10 до 10, шагом 0,01 и тремя знаками после запятой.
Отличие этого дескриптора от всех тех, которые мы зарегистрировали до сих пор, заключается в том, что он является метадескриптором — он описывает не одну строку, а целое семейство строк. Когда окно настроек отображает этот дескриптор, мы разворачиваем единственную запись fibo в набор компактных строк — по одной для каждого уровня, который в данный момент есть у объекта, — и добавляем в конце строку "Добавить уровень". При этом в каждой сформированной строке мы заполняем поля времени выполнения levelIdx и levelListPrefix, чтобы слой виджетов знал, какой уровень он редактирует. Это развёртывание мы обрабатываем в слоях виджетов и ленты, поэтому пока просто зарегистрируем один дескриптор и продолжим. "Веер Ганна" и "коробка Ганна" регистрируют свои списки уровней одинаковым образом с помощью функции AddLevelListDescriptor, а главный диспетчер направляет каждый тип инструмента к соответствующей ему функции регистрации. Далее в новом файле мы опишем логику получения и установки свойств объекта в движке рисования следующим образом.
Чтение свойства по строковому идентификатору
Теперь перейдём к коду движка, где дескрипторы фактически обеспечивают доступ к полям объекта. Определим функцию GetObjectProperty, отвечающую за чтение в API свойств, и рассмотрим её перегрузку для цвета. Перегрузки для типов int, bool, double и string, а также все функции установки используют ту же схему диспетчеризации по идентификатору, поэтому из этого файла нам достаточно одного фрагмента кода.
//+------------------------------------------------------------------+ //| ToolsPalette_Engine_Properties.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_PROPERTIES_MQH #define TOOLS_PALETTE_ENGINE_PROPERTIES_MQH //--- Pull in the Tools header so CDrawingEngine and DrawnObject are visible to the bodies below #include "ToolsPalette_Tools.mqh" //+------------------------------------------------------------------+ //| Read a color-typed property by string ID | //+------------------------------------------------------------------+ bool CDrawingEngine::GetObjectProperty(int objId, string propId, color &outValue) { //--- Resolve the object's array index by ID; bail on unknown ID int idx = FindObjectIndexById(objId); if(idx < 0) return false; //--- Primary stroke/fill color of the object if(propId == "lineColor") { outValue = m_drawnObjects[idx].objColor; return true; } //--- Text color (for label-bearing tools) if(propId == "textColor") { outValue = m_drawnObjects[idx].textColor; return true; } //--- Fill color (for shapes with a fill) if(propId == "fillColor") { outValue = m_drawnObjects[idx].fillColor; return true; } //--- Channel midline color if(propId == "midColor") { outValue = m_drawnObjects[idx].midColor; return true; } //--- Secondary fill color (e.g., the second std-dev band fill) if(propId == "fillColor2") { outValue = m_drawnObjects[idx].fillColor2; return true; } //--- Regression centerline color if(propId == "centerColor") { outValue = m_drawnObjects[idx].centerColor; return true; } //--- Pitchfork per-part-group color getters if(propId == "medianColor") { outValue = m_drawnObjects[idx].medianColor; return true; } if(propId == "outerColor") { outValue = m_drawnObjects[idx].outerColor; return true; } if(propId == "innerColor") { outValue = m_drawnObjects[idx].innerColor; return true; } //--- Per-level color for ANY PROP_LEVEL_LIST tool (fibo/fibex/fibch/fibtz/fibfan/fibarc/gannfan/gannbox) { string pfx; int li; string fld; if(ParseLevelPropId(propId, pfx, li, fld) && fld == "color") { //--- Dispatch by prefix to the matching tool's level-color array if(pfx == "fibo") { if(li < ArraySize(m_drawnObjects[idx].fiboLevelColor)) { outValue = m_drawnObjects[idx].fiboLevelColor[li]; return true; } } else if(pfx == "fibex") { if(li < ArraySize(m_drawnObjects[idx].fibexLevelColor)) { outValue = m_drawnObjects[idx].fibexLevelColor[li]; return true; } } else if(pfx == "fibch") { if(li < ArraySize(m_drawnObjects[idx].fibchLevelColor)) { outValue = m_drawnObjects[idx].fibchLevelColor[li]; return true; } } else if(pfx == "fibtz") { if(li < ArraySize(m_drawnObjects[idx].fibtzLevelColor)) { outValue = m_drawnObjects[idx].fibtzLevelColor[li]; return true; } } else if(pfx == "fibfan") { if(li < ArraySize(m_drawnObjects[idx].fibfanLevelColor)) { outValue = m_drawnObjects[idx].fibfanLevelColor[li]; return true; } } else if(pfx == "fibarc") { if(li < ArraySize(m_drawnObjects[idx].fibarcLevelColor)) { outValue = m_drawnObjects[idx].fibarcLevelColor[li]; return true; } } else if(pfx == "gannfan") { if(li < ArraySize(m_drawnObjects[idx].gannfanLevelColor)) { outValue = m_drawnObjects[idx].gannfanLevelColor[li]; return true; } } else if(pfx == "gannbox") { if(li < ArraySize(m_drawnObjects[idx].gannboxLevelColor)) { outValue = m_drawnObjects[idx].gannboxLevelColor[li]; return true; } } //--- Unknown prefix or out-of-range level index return false; } } //--- Unrecognized property ID for the color type return false; }
Сначала мы определяем индекс объекта в массиве по его идентификатору с помощью функции FindObjectIndexById, прекращая обработку, если идентификатор неизвестен. Затем мы сравниваем входящую строку propId с идентификаторами всех цветовых свойств, доступных у объекта, и записываем значение соответствующего поля в выходной параметр. Сначала мы обрабатываем цвета верхнего уровня: по идентификатору lineColor считываем основной цвет обводки объекта, textColor — цвет надписи, fillColor и fillColor2 — два цвета заливки, midColor — цвет средней линии канала, а centerColor — цвет центральной линии регрессии. Затем мы обрабатываем три цвета зубцов вил (medianColor, outerColor, innerColor) в отдельных строках, поскольку речь идет о простом считывании полей.
Особый интерес представляет ветвь обработки цветов отдельных уровней, в которую мы попадаем для любого инструмента со списком уровней. Мы вызываем функцию ParseLevelPropId, чтобы разбить идентификатор цвета уровня на префикс, индекс уровня и имя поля. Если имя поля — color, по префиксу выбираем массив цветов уровней соответствующего инструмента: для fibo считываем значение из fiboLevelColor, для gannfan — из gannfanLevelColor и так далее для всех восьми инструментов со списками уровней. Перед чтением мы проверяем, находится ли индекс уровня в пределах массива, поэтому обработка устаревшего идентификатора, указывающего за конец сократившегося списка уровней, корректно завершается отказом, а не чтением за границами массива. Если идентификатор не распознан, функция возвращает false, сообщая вызывающему коду, что свойство неприменимо к этому объекту.
Остальные объекты повторяют эту схему. Мы предоставляем перегрузку метода GetObjectProperty для каждого типа значения и соответствующий метод SetObjectProperty для каждого типа, причём методы установки принимают тот же идентификатор и дополнительный флаг preview, а также записывают значение в поле вместо его чтения. Поскольку во всех этих случаях используется только что рассмотренная схема диспетчеризации по идентификатору, перейдем к виджетам, которые инициируют эти вызовы.
Отображение виджетов редактирования свойств
Вспомогательные функции рисования шахматного фона
В начале файла виджетов разместим две небольшие вспомогательные функции рисования, которые создают шахматный фон под редактируемым цветом. Это необходимо, поскольку образец полупрозрачного цвета должен располагаться на шахматном фоне, чтобы прозрачность была визуально различима: на однотонном фоне красный цвет с непрозрачностью 40 % выглядел бы как непрозрачный бледно-розовый, а не как полупрозрачный цвет. Для наглядности ниже показано, как шахматный фон выглядит в интерфейсе.

Для шахматного узора можно использовать любые цвета.
//+------------------------------------------------------------------+ //| ToolsPalette_PropertyWidgets.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_PROPERTY_WIDGETS_MQH #define TOOLS_PALETTE_PROPERTY_WIDGETS_MQH //--- Pull in the Sidebar header (transitively pulls Primitives + Tools) #include "ToolsPalette_Sidebar.mqh" //+------------------------------------------------------------------+ //| Paint a transparency-checker pattern clipped to a pill shape | //+------------------------------------------------------------------+ void WidgetCheckerFillPill(CCanvas &canvas, int l, int t, int r, int b, int checkerSize) { //--- Bail on degenerate rectangles const int h = b - t; if(h <= 0 || r <= l) return; //--- Pill = rect with semicircular ends - radius is half the height const int radius = h / 2; //--- Two checker colors (light + lighter gray) const uint checkerA = ColorToARGB(C'200,200,200', 255); const uint checkerB = ColorToARGB(C'232,232,232', 255); const int yMid = (t + b) / 2; //--- Walk every row, compute the per-row x-inset that keeps us inside the pill for(int y = t; y < b; y++) { //--- Distance from the pill's vertical centerline - rows beyond `radius` are outside const int dyFromMid = MathAbs(y - yMid); if(dyFromMid >= radius) continue; //--- Half-width of the pill at this y (from circle equation x = sqrt(r^2 - dy^2)) const double rr = (double)radius; const double extent = MathSqrt(rr * rr - (double)dyFromMid * (double)dyFromMid); const int rowInset = (int)(rr - extent); const int xStart = l + rowInset; const int xEnd = r - rowInset; //--- Paint each column with the alternating checker pattern for(int x = xStart; x < xEnd; x++) { const bool dark = (((x - l) / checkerSize) + ((y - t) / checkerSize)) % 2 == 0; canvas.PixelSet(x, y, dark ? checkerA : checkerB); } } } //+------------------------------------------------------------------+ //| Paint a transparency-checker pattern inside a plain rectangle | //+------------------------------------------------------------------+ void WidgetCheckerFillRect(CCanvas &canvas, int l, int t, int r, int b, int checkerSize) { //--- Bail on degenerate rectangles if(r <= l || b <= t) return; //--- Two checker colors (light + lighter gray) const uint checkerA = ColorToARGB(C'200,200,200', 255); const uint checkerB = ColorToARGB(C'232,232,232', 255); //--- Walk every pixel; xor the cell index to pick the alternating color for(int y = t; y < b; y++) { for(int x = l; x < r; x++) { const bool dark = (((x - l) / checkerSize) + ((y - t) / checkerSize)) % 2 == 0; canvas.PixelSet(x, y, dark ? checkerA : checkerB); } } }
Мы защищаем заголовочный файл от повторного включения макросом TOOLS_PALETTE_PROPERTY_WIDGETS_MQH и подключаем заголовочный файл Sidebar, который косвенно подключает примитивы и слой Tools, поверх которого рисуются виджеты.
В WidgetCheckerFillPill мы рисуем шахматный фон, обрезанный по контуру капсулы. После исключения вырожденных прямоугольников мы рассматриваем фигуру как прямоугольник с полукруглыми окончаниями, радиус которых равен половине высоты. Мы последовательно перебираем строки и вычисляем расстояние каждой строки от вертикальной центральной линии. Строки, расстояние до которых превышает радиус, лежат за пределами полукруглых окончаний и пропускаются. Для остальных строк мы используем уравнение окружности, чтобы вычислить половину ширины и соответственно задать отступы по краям строки. В пределах обрезанного участка каждой строки мы выбираем цвет клетки, складывая индексы столбца и строки, а затем проверяя четность суммы, что и дает привычную чередующуюся двухцветную сетку. Мы используем два светло-серых оттенка, чтобы узор оставался ненавязчивым под любым наложенным поверх него цветом.
Более простой вариант реализован в WidgetCheckerFillRect: эта функция заполняет обычный прямоугольник без скругления углов. Мы перебираем все пиксели прямоугольника и выбираем цвет клетки с помощью той же проверки четности суммы индексов клетки. Мы используем прямоугольный вариант там, где образец цвета или область предварительного просмотра имеет прямые углы, а вариант в форме капсулы — там, где у элемента управления закругленные концы. Далее мы рассмотрим образец цвета в панели выбора цвета и конвейер рендеринга.
Палитра панели выбора цвета
Начнём создание панели выбора цвета — самого многофункционального виджета ленты — с определения констант компоновки, задающих её геометрию, и набора предустановленных цветов.
//--- Color picker layout constants (grid + spacing + opacity strip + label box) #define COLORPICKER_GRID_COLS 10 #define COLORPICKER_GRID_ROWS 8 #define COLORPICKER_SWATCH_SIZE 18 #define COLORPICKER_SWATCH_GAP 5 #define COLORPICKER_SWATCH_RADIUS 4 #define COLORPICKER_PAD_X 11 #define COLORPICKER_PAD_Y_TOP 11 #define COLORPICKER_PAD_Y_BOTTOM 11 #define COLORPICKER_GRID_TO_DIVIDER 10 #define COLORPICKER_DIVIDER_TO_OPACITY 10 #define COLORPICKER_OPACITY_LABEL_H 14 #define COLORPICKER_OPACITY_LABEL_GAP 6 #define COLORPICKER_OPACITY_STRIP_H 10 #define COLORPICKER_OPACITY_BOX_W 46 #define COLORPICKER_OPACITY_BOX_H 22 #define COLORPICKER_OPACITY_BOX_GAP 8 #define COLORPICKER_RING_OFFSET 2 #define COLORPICKER_RING_THICKNESS 2 #define COLORPICKER_WHITE_BORDER_COLOR_R 220 #define COLORPICKER_WHITE_BORDER_COLOR_G 220 #define COLORPICKER_WHITE_BORDER_COLOR_B 220 //+------------------------------------------------------------------+ //| Color picker preset palette (80 swatches arranged as 10x8 grid) | //+------------------------------------------------------------------+ color GetColorPickerSwatch(int idx) { //--- 80-entry preset palette organized by tonal row static color s_palette[80] = { //--- Row 0: grayscale (white to black) C'255,255,255', C'232,232,232', C'209,209,209', C'186,186,186', C'163,163,163', C'140,140,140', C'117,117,117', C'94,94,94', C'47,47,47', C'0,0,0', //--- Row 1: lightest pastels C'255,205,210', C'255,224,178', C'255,249,196', C'200,230,201', C'178,235,242', C'179,229,252', C'197,202,233', C'209,196,233', C'225,190,231', C'248,187,208', //--- Row 2: soft pastels C'255,154,162', C'255,196,148', C'255,236,139', C'165,214,167', C'128,222,234', C'129,212,250', C'159,168,218', C'179,157,219', C'206,147,216', C'244,143,177', //--- Row 3: pastel-vivid C'255,138,128', C'255,167, 38', C'255,213, 0', C'129,199,132', C' 77,208,225', C' 79,195,247', C'121,134,203', C'149,117,205', C'186,104,200', C'240,98 ,146', //--- Row 4: clean mid C'244, 67, 54', C'255,152, 0', C'255,193, 7', C' 76,175, 80', C' 0,188,212', C' 33,150,243', C' 63, 81,181', C'103, 58,183', C'156, 39,176', C'233, 30, 99', //--- Row 5: deeper mid C'229, 57, 53', C'251,140, 0', C'251,177, 0', C' 56,142, 60', C' 0,151,167', C' 30,136,229', C' 57, 73,171', C' 94, 53,177', C'142, 36,170', C'216, 27, 96', //--- Row 6: deep saturated C'198, 40, 40', C'239,108, 0', C'245,127, 23', C' 46,125, 50', C' 0,121,107', C' 21,101,192', C' 48, 63,159', C' 81, 45,168', C'123, 31,162', C'194, 24, 91', //--- Row 7: darkest C'183, 28, 28', C'230, 81, 0', C'191, 54, 12', C' 27, 94, 32', C' 0, 96, 100', C' 13, 71,161', C' 26, 35,126', C' 49, 27,146', C' 74, 20,140', C'136, 14, 79' }; //--- Out-of-range index returns the sentinel clrNONE if(idx < 0 || idx >= 80) return clrNONE; return s_palette[idx]; } //+------------------------------------------------------------------+ //| Reverse lookup: find the palette index for a given color value | //+------------------------------------------------------------------+ int FindColorPickerSwatchIndex(color c) { //--- Linear scan through the 80-entry palette; return -1 if not present for(int i = 0; i < 80; i++) { if(GetColorPickerSwatch(i) == c) return i; } return -1; }
Начнём с блока констант #define, которые задают все размеры панели выбора цвета: десять столбцов и восемь строк образцов размером 18 пикселей с промежутками 5 пикселей и радиусом скругления углов 4 пикселя, а также внутренние отступы, отступы у разделителя, высоту полосы непрозрачности, размер поля непрозрачности, смещение и толщину кольца выделения. Мы храним эти именованные константы в одном месте, чтобы расчёты компоновки в процедурах отрисовки и проверки попадания оставались понятными, а изменение одной константы согласованно меняло компоновку всей панели выбора цвета.
Далее мы определяем функцию GetColorPickerSwatch, которая возвращает один из восьмидесяти предустановленных цветов по индексу из статического массива, организованного в виде сетки размером 10 на 8. В первой строке мы размещаем оттенки серого от белого до чёрного, а в семи строках ниже — цвета от самых светлых пастельных до самых тёмных насыщенных тонов. В каждом столбце сохраняется один цветовой тон, поэтому, двигаясь вниз по столбцу, можно выбрать более тёмный оттенок, а по горизонтали — другой цветовой тон. Если индекс выходит за пределы диапазона, мы возвращаем clrNONE, чтобы вызывающий код мог интерпретировать это значение как признак отсутствия записи.
Наконец, мы добавляем функцию FindColorPickerSwatchIndex, которая работает в обратном направлении: линейно просматривает палитру в поисках значения цвета и возвращает его индекс либо -1, если цвет не входит в набор предустановленных цветов. Мы вызываем эту функцию при открытии панели выбора цвета для существующего объекта: она определяет, какой образец соответствует текущему цвету объекта, чтобы мы могли выделить его кольцом. Результат -1 означает, что для объекта задан пользовательский цвет, которого нет в сетке предустановленных цветов. Мы выбрали именно эти цвета, чтобы обеспечить гибкость на случай, если в будущем возникнет необходимость расширить палитру. При необходимости можно добавить столбцы или строки. Мы разместили чёрный и белый цвета в верхней строке, поскольку они используются чаще всего. После отрисовки получим следующий результат.

Для отображения всплывающих окон со свойствами линии мы используем следующий подход.
Отображение всплывающих окон "Ширина линии" и "Стиль линии"
Мы отображаем всплывающие окна выбора ширины и стиля линии с помощью одной функции — RenderLinePopoverRows, поскольку оба раскрывающихся списка имеют одинаковую компоновку строк и отличаются лишь тем, какой параметр меняется от строки к строке.
//+------------------------------------------------------------------+ //| Render the rows of the line-width OR line-style popover | //+------------------------------------------------------------------+ void RenderLinePopoverRows(CCanvas &canvas, int originX, int originY, int bodyW, int activeOptionIdx, int hoveredIdx, int lineWidthOption, int lineStyleOption, color strokeColor, const ThemeColorSet &theme) { //--- 4 fixed rows (LINEPOPOVER_NUM_OPTIONS) - one per width or style for(int i = 0; i < LINEPOPOVER_NUM_OPTIONS; i++) { int rL, rT, rR, rB; GetLinePopoverRowRect(i, originX, originY, bodyW, rL, rT, rR, rB); //--- Active-row highlight (stronger than hover) if(i == activeOptionIdx) { const uint actArgb = ColorToARGB(theme.flyoutTextColor, 55); for(int yy = rT; yy < rB; yy++) for(int xx = rL; xx < rR; xx++) WidgetBlendPixel(canvas, xx, yy, actArgb); } else if(i == hoveredIdx) { //--- Hover-row highlight (more subtle) const uint hovArgb = ColorToARGB(theme.flyoutTextColor, 25); for(int yy = rT; yy < rB; yy++) for(int xx = rL; xx < rR; xx++) WidgetBlendPixel(canvas, xx, yy, hovArgb); } //--- Width and style preview: in width-popover, w varies (i+1) and s is fixed; in style-popover, s varies (i) and w is fixed const int w = (lineWidthOption >= 0) ? lineWidthOption : (i + 1); const int s = (lineStyleOption >= 0) ? lineStyleOption : i; //--- Stroke preview at the left of the row const int sL = rL + LINEPOPOVER_PAD_X; const int sR = sL + LINEPOPOVER_STROKE_W; StrokeLinePreview(canvas, sL, rT, sR, rB, w, s, ColorToARGB(strokeColor, 255)); //--- Label text: "Xpx" for width-popover, style name for style-popover, empty for the orthogonal axis string label = ""; if(lineWidthOption < 0) label = IntegerToString(i + 1) + "px"; else if(lineStyleOption < 0) label = GetLineStyleLabel(i); //--- Position the label to the right of the stroke preview with gap, vertically centered const int textX = sR + LINEPOPOVER_STROKE_LABEL_GAP; const int textY = (rT + rB) / 2 - 7; canvas.FontSet("Arial", -100); canvas.TextOut(textX, textY, label, ColorToARGB(theme.flyoutTextColor, 240)); } }
Сначала мы перебираем четыре фиксированные строки, получаем прямоугольник каждой строки с помощью функции GetLinePopoverRowRect и отрисовываем подсветку: более интенсивную, если строка соответствует текущему значению свойства объекта, и менее интенсивную, если на строку лишь наведён курсор. Затем мы определяем ширину и стиль линии для предварительного просмотра в этой строке: если вызывающий код задаёт фиксированное значение lineWidthOption, стиль меняется от строки к строке и равен i, а ширина остаётся неизменной — так получается всплывающее окно выбора стиля. Если же задано фиксированное значение lineStyleOption, ширина меняется и равна i + 1, а стиль остаётся неизменным — так получается всплывающее окно выбора ширины.
Далее с помощью функции StrokeLinePreview мы рисуем в левой части строки короткий образец линии с полученными значениями ширины и стиля, чтобы показать именно ту линию, которую предстоит выбрать. Наконец, мы формируем метку строки — Xpx для всплывающего окна с шириной или название стиля, полученное из функции GetLineStyleLabel, для всплывающего окна со стилем, а также пустую строку для той оси, значение которой не изменяется, — и рисуем её сразу справа от предварительного просмотра, выровняв по вертикали по центру строки. Для реализации ленты свойств мы размещаем её код в новом файле, чтобы упростить сопровождение.
Сборка ленты свойств
Объявление класса ленты
Саму ленту мы объявляем как класс CRibbon, производный от CSidebarRenderer, чтобы она входила в ту же цепочку наследования, что и боковая панель, и наследовала механизмы работы с холстом и темами.
//+------------------------------------------------------------------+ //| ToolsPalette_Ribbon.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_RIBBON_MQH #define TOOLS_PALETTE_RIBBON_MQH //--- Pull in the Sidebar (base class), property descriptor system, and widget renderers #include "ToolsPalette_Sidebar.mqh" #include "ToolsPalette_Properties.mqh" #include "ToolsPalette_PropertyWidgets.mqh" //+------------------------------------------------------------------+ //| CRibbon - quick-access property-editing ribbon for the selection | //+------------------------------------------------------------------+ class CRibbon : public CSidebarRenderer { protected: //--- Ribbon canvas + high-res supersample backing canvas string m_nameRibbon; CCanvas m_canvasRibbon; CCanvas m_canvasRibbonHighRes; //--- Ribbon dimensions (recomputed when content changes) int m_ribbonWidth; int m_ribbonHeight; int m_ribbonCornerRadius; int m_ribbonShadowPad; //--- Current ribbon position + last-known position cache (for restore after hide/show) int m_ribbonX; int m_ribbonY; int m_lastRibbonX; int m_lastRibbonY; bool m_lastRibbonValid; //--- Visibility + bound object ID (the drawn object the ribbon edits) bool m_isRibbonVisible; int m_ribbonOwnerObjectId; //--- Drag state (set while the user is moving the ribbon via the grip) bool m_isRibbonDragging; int m_ribbonDragOffsetX; int m_ribbonDragOffsetY; //--- Width of the drag-grip area on the left edge int m_ribbonGripWidth; //--- Icon row geometry (size, gap between icons, left/right padding inside the body) int m_ribbonIconSize; int m_ribbonIconGap; int m_ribbonIconRowPadX; //--- Hovered icon index (-1 when nothing is hovered) int m_hoveredRibbonIconIdx; //--- Filtered property descriptor list (subset of BuildPropertyListForTool that's ribbon-eligible) SToolProperty m_ribbonProperties[]; //--- Popover canvas + high-res backing canvas string m_namePopover; CCanvas m_canvasPopover; CCanvas m_canvasPopoverHighRes; //--- Popover visibility + which property's popover is open + screen-space rect bool m_isPopoverVisible; string m_activePopoverPropId; int m_popoverX; int m_popoverY; int m_popoverWidth; int m_popoverHeight; int m_popoverShadowPad; int m_popoverCornerRadius; //--- True when a parent owns the property-edit snapshot lifecycle (Settings window case) bool m_popoverSnapshotIsExternal; //--- Opacity slider drag state + current slider value bool m_isOpacityDragging; int m_opacityValuePct; //--- Hovered popover item index (swatch / row / row depending on popover type) int m_hoveredPopoverSwatchIdx; //--- Inline opacity-box editing state (text buffer + caret position + blink phase) bool m_isEditingBoxOpacity; string m_boxEditBuffer; int m_boxCaretPos; bool m_boxCaretOn; ulong m_boxBlinkTickAt; public: //--- Lifecycle - create/destroy the ribbon's chart-object canvases bool CreateRibbonCanvases(); void DestroyRibbonCanvases(); //--- Show/hide the ribbon bound to a specific drawn-object ID void ShowRibbonFor(int objId); void HideRibbon(); bool IsRibbonVisible() const { return m_isRibbonVisible; } //--- Hook for subclasses that route the Settings action button into a settings window virtual void OpenSettingsWindowForObject(int objId) { } //--- Force a full re-render of the ribbon canvas void RedrawRibbon(); //--- Mouse routing + grip hit-test (returns local coords via out-params) bool HitTestOverRibbon(int mouseX, int mouseY, int &lx, int &ly); bool HitTestOverRibbonGrip(int lx, int ly); bool RibbonMouseMove(int mouseX, int mouseY, uint mouseButtons); bool RibbonMouseDown(int mouseX, int mouseY); bool RibbonMouseUp(); //--- Popover lifecycle + show for a specific property id (optionally with flip anchor) bool CreatePopoverCanvas(); void DestroyPopoverCanvas(); void ShowPopoverForProperty(string propId, int anchorX, int anchorY, int flipBaseTop = -1); void HidePopover(); bool IsPopoverVisible() const { return m_isPopoverVisible; } void RedrawPopover(); bool HitTestOverPopover(int mouseX, int mouseY, int &lx, int &ly); bool PopoverMouseDown(int mouseX, int mouseY); bool PopoverMouseMove(int mouseX, int mouseY, uint mouseButtons); bool PopoverMouseUp(); //--- Popover keyboard handler (for the editable opacity box) + caret-blink tick bool PopoverKeyDown(uint keyCode); void RibbonTick(); //--- Selection-changed hook from CSidebarRenderer - show/hide ribbon based on the new selection virtual void OnSelectionChanged(int objId) { //--- Positive objId = a single drawn object was selected; otherwise hide if(objId >= 0) ShowRibbonFor(objId); else HideRibbon(); } //--- Hook for subclasses that need to know when the popover just closed (e.g., refocus a parent) virtual void OnPopoverClosed() { /* default no-op */ } protected: //--- Position calculation + clamp-to-chart-bounds + apply to the chart object void CalcRibbonDefaultPosition(int &outX, int &outY); void ClampRibbonToChart(); void ApplyRibbonPosition(); //--- Draw the 2x4 grip-dot pattern on the left edge void DrawGripDots(CCanvas &canvas, int hrScale); //--- Rebuild the filtered descriptor list + compute the ribbon's content-width void RefreshRibbonProperties(); int CalcRibbonContentWidth(); void DrawRibbonIcons(); int HitTestRibbonIcon(int lx, int ly); void GetRibbonIconBounds(int idx, int &outX, int &outY, int &outSize); int GetRibbonIconWidthForType(PROP_TYPE t); //--- Popover positioning + flip-when-clipped logic void ApplyPopoverPosition(); void ClampPopoverToChart(); void CalcPopoverPositionForAnchor(int anchorX, int anchorY, int popoverW, int popoverH, int &outX, int &outY, int flipBaseTop = -1); //--- Commit the opacity-box text buffer back to the live opacity property void CommitBoxEditToOpacity(); };
Сначала мы защищаем заголовочный файл от повторного включения и подключаем три файла: базовый класс боковой панели, систему дескрипторов свойств и средства отрисовки виджетов, — чтобы у ленты были и дескрипторы, определяющие, что показывать, и виджеты для отрисовки каждого элемента управления.
Затем мы добавляем ленте два холста: видимый и стоящий за ним холст высокого разрешения для суперсэмплинга, а также поля для хранения её размеров, текущего и последнего известного положения (чтобы восстановить его после скрытия и повторного показа), видимости и идентификатора нарисованного объекта, который она сейчас редактирует. Кроме того, мы храним состояние перетаскивания ленты за ручку, геометрию ряда значков, индекс значка под курсором и отфильтрованный список дескрипторов — подмножество дескрипторов, возвращаемых функцией BuildPropertyListForTool и подходящих для отображения в ленте.
Кроме того, мы определяем второй набор полей для всплывающего окна: его холсты, видимость, идентификатор активного свойства и прямоугольник на экране. Дополнительные поля хранят состояние перетаскивания ползунка непрозрачности, элемент под курсором и состояние редактирования непосредственно в поле непрозрачности (буфер, положение текстового курсора, состояние мигания). Это позволяет точно задавать степень непрозрачности, а не только регулировать её с помощью ползунка.
В открытой части класса мы объявляем методы управления жизненным циклом холста, методы показа и скрытия ленты с привязкой к идентификатору объекта, методы маршрутизации событий мыши в ленте, методы управления жизненным циклом всплывающего окна и его обработчики событий мыши и клавиатуры, а также метод RibbonTick, управляющий миганием текстового курсора. Мы переопределяем обработчик OnSelectionChanged — унаследованный от боковой панели — чтобы отображать ленту при положительном идентификаторе объекта и скрывать её в остальных случаях, что и приводит к появлению и исчезновению ленты при смене выбора.
Наконец, внутреннюю реализацию мы оставляем в защищённой части класса: расчёт положения и ограничение перемещения границами графика, рисование точек на ручке перетаскивания, перестроение списка дескрипторов и расчёт ширины содержимого, размещение значков и проверку попадания, позиционирование всплывающего окна с переносом на противоположную сторону при выходе за границы, а также запись значения из текстового поля непрозрачности в редактируемое свойство. При реализации ленты используется тот же подход, что и для боковой панели и выпадающих панелей инструментов, поскольку основная работа связана с отрисовкой и реестром. На этом реализация завершена. Осталось только протестировать новые функции после их интеграции в оболочку, и этому будет посвящен следующий раздел.
Визуализация
Мы компилируем программу, прикрепляем её к графику и поочерёдно выбираем объекты, чтобы убедиться, что лента отображает нужные элементы управления и позволяет изменять свойства объектов в реальном времени.

Во время тестирования лента появлялась рядом с каждым выбранным элементом и отображала только те свойства, которые относились к данному инструменту, а при нажатии на значок открывалось соответствующее всплывающее окно — сетка образцов для цветов или строки предварительного просмотра для ширины и стиля. При выборе цвета или перетаскивании ползунка непрозрачности объект на графике обновлялся в реальном времени; ввод точного значения в поле непрозрачности давал тот же результат, а перетаскивание ленты за ручку перемещало её, не меняя выделения под ней.
Заключение
Итак, мы добавили в слой рисования на холсте в MQL5 ленту редактирования свойств отдельных объектов. Её реализация основана на четырёх новых файлах: системе дескрипторов, определяющей, какие свойства предоставляет каждый инструмент; API получения и установки на стороне движка с предварительным просмотром в реальном времени на основе снимков; функциях отрисовки виджетов для панели выбора цвета, выпадающих списков и компактных строк; и самой плавающей ленте, которая привязывается к текущему выделению. Мы подключили её к циклу событий через цепочку наследования. При выборе объекта отображаются только те свойства, которые к нему относятся. При нажатии на значок открывается соответствующее всплывающее окно. Изменение значения приводит к обновлению объекта в режиме реального времени, а отмена — к восстановлению моментального снимка, сделанного при открытии ленты. Прочитав эту статью, вы сможете:
- Создать систему свойств на основе дескрипторов, в которой каждый инструмент регистрирует доступные свойства в виде простых данных, а единый универсальный конвейер обеспечивает их отображение и редактирование для всех инструментов.
- Реализовать на стороне движка API получения и установки значений по строковым идентификаторам свойств с механизмом снимка и восстановления, который обеспечивает предварительный просмотр в реальном времени при перетаскивании ползунка с возможностью отмены изменений.
- Создать плавающую ленту с возможностью перетаскивания, которая привязывается к текущему выделению, размещает значки для каждого свойства и открывает связанные с движком всплывающие окна выбора цвета, ширины и стиля.
В следующей части серии мы создадим полнофункциональное окно настроек, открываемое кнопкой "Настройки" на ленте. В нём будут вкладки "Стиль", "Текст", "Координаты" и "Видимость", редактируемые строки для каждого уровня, а также возможность прямого ввода координат и числовых значений для выбранного объекта. Следите за новостями.
Вложения
| Порядковый номер | Название | Тип | Описание |
|---|---|---|---|
| 1 | Tools Palette Part 8.zip | Архив | Готовый к распаковке архив, содержащий все 18 файлов проекта в одной папке. Распакуйте архив в папку данных терминала MetaTrader 5. Все файлы будут размещены в нужных местах внутри MQL5/Experts/ и готовы к компиляции. |
Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/22923
Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.
Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.