English
preview
Торговые инструменты MQL5 (Часть 37): Добавление ленты редактирования свойств отдельных объектов в слой рисования на холсте

Торговые инструменты MQL5 (Часть 37): Добавление ленты редактирования свойств отдельных объектов в слой рисования на холсте

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

Введение

В предыдущей статье (часть 36) мы добавили инструменты для создания фигур и аннотаций с возможностью редактирования меток непосредственно на объектах, благодаря чему теперь можно рисовать фигуры с заливкой, размещать маркеры аннотаций и вводить текст непосредственно на объектах графика. Однако после размещения объекта его внешний вид фиксируется. Цвета, непрозрачность, ширина линий, стили линий, шрифты и видимость отдельных уровней — всё это фиксируется при создании на основе настроек инструмента по умолчанию или сохранённых для него настроек; нет возможности выделить прямоугольник и изменить цвет его заливки, приглушить уровень Фибоначчи, изменить стиль центральной линии канала или утолщить линию тренда уже после создания объекта. На слое рисования можно создавать объекты, но нельзя их редактировать.

В этой части эта проблема устраняется с помощью плавающей ленты редактирования свойств. Мы добавляем четыре новых файла, которые образуют стек свойств, управляемый дескрипторами:

  • Система дескрипторов, определяющая, какие свойства предоставляет каждый инструмент
  • API получения и установки со стороны движка с динамическим предварительным просмотром на основе моментальных снимков
  • Рендереры виджетов для каждого элемента управления
  • Панель ленты, которая отображается рядом с текущим выделением и связывает виджеты с движком

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

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

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


От фиксированных стилей к свойствам, редактируемым пользователем

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

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

Эта система состоит из четырёх частей. Слой дескрипторов определяет, какие свойства предоставляет инструмент. Слой виджетов определяет, как отображается и редактируется каждое свойство. Слой 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, хотя оно практически не отличается от окна в нативном терминале. Для наглядности см. пример ниже.

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

Уровни Фибоначчи в MT5

В функции 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 — унаследованный от боковой панели — чтобы отображать ленту при положительном идентификаторе объекта и скрывать её в остальных случаях, что и приводит к появлению и исчезновению ленты при смене выбора.

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


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

Мы компилируем программу, прикрепляем её к графику и поочерёдно выбираем объекты, чтобы убедиться, что лента отображает нужные элементы управления и позволяет изменять свойства объектов в реальном времени.

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

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


Заключение

Итак, мы добавили в слой рисования на холсте в MQL5 ленту редактирования свойств отдельных объектов. Её реализация основана на четырёх новых файлах: системе дескрипторов, определяющей, какие свойства предоставляет каждый инструмент; API получения и установки на стороне движка с предварительным просмотром в реальном времени на основе снимков; функциях отрисовки виджетов для панели выбора цвета, выпадающих списков и компактных строк; и самой плавающей ленте, которая привязывается к текущему выделению. Мы подключили её к циклу событий через цепочку наследования. При выборе объекта отображаются только те свойства, которые к нему относятся. При нажатии на значок открывается соответствующее всплывающее окно. Изменение значения приводит к обновлению объекта в режиме реального времени, а отмена — к восстановлению моментального снимка, сделанного при открытии ленты. Прочитав эту статью, вы сможете:

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

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


Вложения

Порядковый номер
Название Тип Описание
1 Tools Palette Part 8.zip
Архив
Готовый к распаковке архив, содержащий все 18 файлов проекта в одной папке. Распакуйте архив в папку данных терминала MetaTrader 5. Все файлы будут размещены в нужных местах внутри MQL5/Experts/ и готовы к компиляции.

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

Прикрепленные файлы |
Особенности написания Пользовательских Индикаторов Особенности написания Пользовательских Индикаторов
Написание пользовательских индикаторов в торговой системе MetaTrader 4
Свечи FU/AFU/SFU: Определения, код и статистика Свечи FU/AFU/SFU: Определения, код и статистика
Как часто свечи со снятием ликвидности FU, AFU и SFU оказываются на подтверждённых экстремумах? Проверяем это постфактум на данных EURUSD, BTCUSD и EURGBP за 2020–2026 годы и сравниваем результаты с базой свечей, пробивших экстремум предыдущей. В статье представлены определения формаций, индикаторы FuCandles и SimpleZigZag, а также скрипт сбора данных на MQL5.
Особенности написания экспертов Особенности написания экспертов
Написание и тестирование экспертов в торговой системе MetaTrader 4.
Разрабатываем менеджер терминалов (Часть 5): Автоматизация установки Разрабатываем менеджер терминалов (Часть 5): Автоматизация установки
Добавляем в менеджер создание и настройку экземпляров MetaTrader 5 через браузер. Разбираем подготовку файлов, подключение к торговому счёту и сохранение параметров для повторного запуска. Показываем, как обновлять проект, собирать и распространять сервис сбора состояния терминалов на MQL5, чтобы управлять терминалами без подключения к удалённому рабочему столу.