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

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

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

Введение

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

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

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

  1. От ленты быстрого доступа к полноценному окну настроек
  2. Компоновка и отрисовка окна настроек
  3. Реализация взаимодействия с окном настроек
  4. Визуализация
  5. Заключение

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


От ленты быстрого доступа к полноценному окну настроек

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

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

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

ПЛАН РАЗРАБОТКИ ОКНА НАСТРОЕК

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


Компоновка и отрисовка окна настроек

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

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

//+------------------------------------------------------------------+
//|                                        ToolsPalette_Settings.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_SETTINGS_MQH
#define TOOLS_PALETTE_SETTINGS_MQH

#include "ToolsPalette_Ribbon.mqh"

//+------------------------------------------------------------------+
//| CSettingsWindow - Settings dialog inheriting from CRibbon        |
//+------------------------------------------------------------------+
class CSettingsWindow : public CRibbon
  {
protected:
   //--- Settings chart-object name + display canvas
   string          m_nameSettings;
   CCanvas         m_canvasSettings;
   //--- Visibility flag + current top-left position + content dimensions
   bool            m_isSettingsVisible;
   int             m_settingsX;
   int             m_settingsY;
   int             m_settingsWidth;
   int             m_settingsHeight;
   //--- Shadow halo padding + body corner radius (matches popover styling)
   int             m_settingsShadowPad;
   int             m_settingsCornerRadius;

   //--- Saved position cache (so reopening restores the user's last placement)
   int             m_savedSettingsX;
   int             m_savedSettingsY;

   //--- The drawn-object ID this Settings window is bound to (the tool being edited)
   int             m_settingsOwnerObjectId;

   //--- Tab strip state (parallel arrays: group id + display label)
   string          m_tabGroups[];
   string          m_tabLabels[];
   int             m_activeTabIdx;
   int             m_hoveredTabIdx;

   //--- Full descriptor list for the bound tool + per-tab row index mapping
   SToolProperty   m_settingsProperties[];
   int             m_activeTabRowIdxs[];
   int             m_hoveredRowIdx;
   //--- Synthesized descriptors for level-list rows (one per Fibo level, etc.)
   SToolProperty   m_synthRowDescriptors[];

   //--- Header + footer button hover states
   bool            m_hoveredCloseBtn;
   int             m_hoveredFooterBtn;
   //--- Text tab control hover (1=color, 2=fontSize, 3=bold, 5=text input, 6=vAlign, 7=hAlign)
   int             m_hoveredTextTabCtrl;

   //--- Text-area edit state (multi-line text input on the Text tab)
   bool            m_textAreaFocused;
   int             m_textAreaScrollPx;
   bool            m_textAreaCaretBlinkOn;
   uint            m_textAreaCaretBlinkLastMs;
   bool            m_textAreaThumbDragging;
   int             m_textAreaThumbGrabOffsetY;
   bool            m_hoveredTextAreaScrollbar;
   bool            m_textAreaAutoScrollPending;
   //--- Cached text-area content rectangle + layout metrics (updated each redraw)
   int             m_taContentL, m_taContentT, m_taContentR, m_taContentB;
   int             m_taTotalContentH;
   int             m_taLineH;
   int             m_taMaxScrollPx;

   //--- Body scrollbar state (the main content scrollbar on the Style/etc tabs)
   int             m_bodyContentH;
   int             m_bodyViewportH;
   int             m_bodyScrollPx;
   int             m_bodyMaxScrollPx;
   bool            m_bodyThumbDragging;
   int             m_bodyThumbGrabOffsetY;
   bool            m_hoveredBodyScrollbar;
   bool            m_textAreaAutoScrollPending_body;   // alias unused — kept for layout parity

   //--- Coordinate-edit state (Coordinates tab inline price/time edit)
   int             m_coordEditPointIdx;
   int             m_coordEditField;
   string          m_coordEditBuffer;
   int             m_coordEditCaretPos;
   int             m_coordSelectionAnchor;
   bool            m_coordEditCaretBlinkOn;
   uint            m_coordEditCaretBlinkLastMs;
   //--- Hover state for the coords tab (row + field + stepper direction)
   int             m_coordHoveredRow;
   int             m_coordHoveredField;
   int             m_coordHoveredStepper;

   //--- Float-edit state (numeric chip edit on Style/Visibility tabs)
   string          m_floatEditPropId;
   string          m_floatEditBuffer;
   int             m_floatEditCaretPos;
   int             m_floatSelectionAnchor;
   bool            m_floatEditCaretBlinkOn;
   uint            m_floatEditCaretBlinkLastMs;
   int             m_floatEditDecimals;
   double          m_floatEditMinValue;
   double          m_floatEditMaxValue;

   //--- Compact row hover state (sub-widgets inside a compact row: checkbox/value/color/width/style)
   int             m_compactHoveredRow;
   int             m_compactHoveredStepper;
   int             m_compactHoveredSubRow;
   int             m_compactHoveredSubButton;

   //--- Drag state (window-move via header)
   bool            m_isDraggingSettings;
   int             m_dragGrabOffsetX;
   int             m_dragGrabOffsetY;

   //--- Layout constants (heights/widths/paddings)
   int             m_settingsHeaderH;
   int             m_settingsTabBarH;
   int             m_settingsTabContainerH;
   int             m_settingsRowH;
   int             m_settingsFooterH;
   int             m_settingsPadX;
   int             m_settingsRowGap;
   int             m_settingsChipW;
   int             m_settingsChipH;

protected:
   //--- Window initialization helpers
   bool            InitSettingsWindow();
   void            InitSettingsDefaults();

public:
   //--- Show/hide/redraw the window
   void            ShowSettingsForObject(int objectId);
   void            HideSettings();
   bool            IsSettingsVisible() const { return m_isSettingsVisible; }
   //--- True when ANY drag is in progress (window, body thumb, or text-area thumb)
   bool            IsDraggingSettings() const
                     { return m_isDraggingSettings
                           || m_textAreaThumbDragging
                           || m_bodyThumbDragging; }
   void            RedrawSettings();
   //--- Override CRibbon's hook so clicking the Settings ribbon icon opens this window
   virtual void    OpenSettingsWindowForObject(int objId) override
                     { ShowSettingsForObject(objId); }

   //--- Override CRibbon hook so the Settings window repaints when a popover closes
   virtual void    OnPopoverClosed() override
     {
      if(m_isSettingsVisible) RedrawSettings();
     }

   //--- Mouse routing (called by Shell.mqh dispatcher; impls live in Settings_Interact.mqh)
   bool            SettingsMouseDown(int mouseX, int mouseY);
   bool            SettingsMouseMove(int mouseX, int mouseY, uint mouseButtons);
   bool            SettingsMouseUp();
   //--- Hit-test against the window's body rect (emits local coords via out-params)
   bool            HitTestOverSettings(int mouseX, int mouseY, int &outLx, int &outLy);

protected:
   //--- Rebuild the tab list + per-tab row mapping for the bound object
   void            RefreshTabsForObject();
   void            RefreshActiveTabRows();

   //--- Quick lookup: true if a property id is registered for the bound tool
   bool            HasRegisteredProperty(const string propId)
     {
      const int n = ArraySize(m_settingsProperties);
      for(int i = 0; i < n; i++)
         if(m_settingsProperties[i].id == propId) return true;
      return false;
     }

   //--- Resolve a row slot to its descriptor (real or synthesized via the levellist expansion)
   SToolProperty   ResolveActiveRowDescriptor(int rowSlot);
   //--- Recompute window size based on active tab content
   void            RecalcSettingsSize();
   //--- Push current XY to the chart object (offset by shadow padding)
   void            ApplySettingsPosition();

   //--- Layout rect helpers (return component bounds in window-local coords)
   void            GetTabContainerRect(int &outL, int &outT, int &outR, int &outB);
   void            GetTabRect(int tabIdx, int &outL, int &outT, int &outR, int &outB);
   void            GetRowRect(int rowSlot, int &outL, int &outT, int &outR, int &outB);
   void            GetRowChipRect(int rowSlot, int &outL, int &outT, int &outR, int &outB);

   //--- Compact-row sub-widget rect helpers (used by both render + hit-test)
   bool            GetCompactValueButtonRect(int rowSlot,
                                               int &outL, int &outT,
                                               int &outR, int &outB);
   bool            GetCompactStepperRect(int rowSlot, int dir,
                                          int &outL, int &outT,
                                          int &outR, int &outB);

   //--- Body scrollbar rendering + thumb hit-rect calculation
   void            DrawBodyScrollbar();
   bool            GetBodyThumbRect(int &outL, int &outT, int &outR, int &outB,
                                      bool settingsRelativeOnly);
   //--- Header close-X + footer buttons (Cancel/Ok/Apply Defaults) rect helpers
   void            GetCloseButtonRect(int &outL, int &outT, int &outR, int &outB);
   void            GetFooterButtonRect(int btnIdx, int &outL, int &outT, int &outR, int &outB);

   //--- Hit-tests for each interactive region
   int             HitTestTab(int lx, int ly);
   int             HitTestRow(int lx, int ly);
   int             HitTestFooterButton(int lx, int ly);
   bool            HitTestCloseButton(int lx, int ly);
   bool            HitTestHeaderDragArea(int lx, int ly);

   //--- Major draw routines (split out for readability)
   void            DrawSettingsHeader();
   void            DrawSettingsTabStrip();
   void            DrawSettingsRows();
   void            DrawTextTabRows();
   //--- Text-tab control hit-test + per-control rect helpers
   int             HitTestTextTabControl(int lx, int ly);
   void            GetTextTabColorRect(int &outL, int &outT, int &outR, int &outB);
   void            GetTextTabFontSizeRect(int &outL, int &outT, int &outR, int &outB);
   void            GetTextTabBoldRect(int &outL, int &outT, int &outR, int &outB);
   void            GetTextTabTextInputRect(int &outL, int &outT, int &outR, int &outB);
   void            GetTextTabVAlignRect(int &outL, int &outT, int &outR, int &outB);
   void            GetTextTabHAlignRect(int &outL, int &outT, int &outR, int &outB);
   void            DrawSettingsFooter();
   //--- Per-row chip renderer (dispatch by descriptor type)
   void            RenderRowChip(int rowSlot, const SToolProperty &prop);

   //--- Text-area lifecycle (focus loss + buffer-change notifier)
   void            UnfocusTextArea();
   //--- Coordinates tab rendering + hit-tests + edit-mode helpers
   void            DrawCoordsTabRows();
   void            GetCoordRowRect(int rowIdx, int &outL, int &outT, int &outR, int &outB);
   void            GetCoordPriceButtonRect(int rowIdx, int &outL, int &outT, int &outR, int &outB);
   void            GetCoordTimeButtonRect(int rowIdx, int &outL, int &outT, int &outR, int &outB);
   void            GetCoordStepperRect(int rowIdx, int field, int dir,
                                         int &outL, int &outT, int &outR, int &outB);
   bool            HitTestCoordsTab(int lx, int ly,
                                      int &outRow, int &outField, int &outStepper);
   //--- Coordinate-edit lifecycle (start/commit/cancel/step) + value formatting helpers
   void            StartCoordEdit(int pointIdx, int field);
   void            CommitCoordEdit();
   void            CancelCoordEdit();
   void            ApplyCoordStep(int pointIdx, int field, int dir);
   void            PositionCoordCaretFromClickX(int lx);
   string          FormatPriceForDisplay(double price);
   string          FormatBarForDisplay(datetime time);

public:
   //--- Keyboard handlers for the two inline edit modes (impls in Settings_Interact.mqh)
   bool            HandleCoordKey(uint vk);
   bool            IsEditingCoord() const { return m_coordEditPointIdx >= 0; }
   void            BeginFloatEdit(string propId, int decimals,
                                    double minValue, double maxValue);
   void            CommitFloatEdit();
   void            CancelFloatEdit();
   bool            IsEditingFloat() const { return StringLen(m_floatEditPropId) > 0; }
   bool            HandleFloatKey(uint vk);
   void            PositionFloatCaretFromClickX(int lx, int textStartX);
   //--- Open a sub-popover anchored to a sub-widget inside the Settings body
   void            OpenSettingsSubPopover(string propId, int anchorX, int anchorY,
                                            int flipBaseTop = -1);
   //--- Text-area integration with the engine's label-edit state
   void            NotifyTextAreaBufferChanged();
   bool            IsTextAreaFocused() const { return m_textAreaFocused; }
   bool            HitTestOverTextArea(int mouseX, int mouseY);
   bool            HitTestOverSettingsBody(int mouseX, int mouseY);
   int             SettingsBodyMaxScroll() const { return m_bodyMaxScrollPx; }
   //--- Wheel scroll handlers (chart wheel events route here when over the body / text area)
   void            ScrollSettingsBodyByWheel(int wheelDelta);
   void            ScrollTextAreaByWheel(int wheelDelta);
   //--- Caret-blink tick (called from the Shell's OnTimer)
   void            SettingsTick();
   bool            GetTextAreaThumbRect(int &outL, int &outT, int &outR, int &outB,
                                          bool settingsRelativeOnly);

protected:
   //--- Footer Ok/Cancel action handlers
   void            CommitSettingsChanges();
   void            DiscardSettingsChanges();
  };

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

Мы храним данные свойств в трех массивах: полном списке дескрипторов привязанного инструмента, массиве соответствий индексов строк для каждой вкладки, определяющем, какие дескрипторы относятся к активной вкладке, и списке синтезированных дескрипторов для строк списка уровней, которые мы формируем во время выполнения, — по одному дескриптору на каждый уровень Фибоначчи или Ганна. Мы отслеживаем состояние наведения отдельно для кнопки закрытия в заголовке, кнопок нижней панели и элементов управления вкладки "Текст", поскольку каждый из этих элементов подсвечивается под курсором независимо от остальных.

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

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

Отображение окна для объекта

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

//+------------------------------------------------------------------+
//| Bind the window to an object, build its layout, and show it      |
//+------------------------------------------------------------------+
void CSettingsWindow::ShowSettingsForObject(int objectId)
  {
   //--- Bail on invalid object id
   if(objectId <= 0) return;
   m_settingsOwnerObjectId = objectId;

   //--- Resolve the drawn-object index + tool type
   const int idx = FindObjectIndexById(objectId);
   if(idx < 0) return;
   const TOOL_TYPE tool = m_drawnObjects[idx].toolType;
   //--- Rebuild the full property descriptor list for this tool
   ArrayResize(m_settingsProperties, 0);
   BuildPropertyListForTool(tool, m_settingsProperties);

   //--- Take a property snapshot (Cancel later will RestoreProperties from this)
   SnapshotProperties(objectId);

   //--- Build tab list + row mapping + recompute window size
   RefreshTabsForObject();
   m_activeTabIdx = 0;
   RefreshActiveTabRows();
   RecalcSettingsSize();

   //--- Position: restore saved if any (clamped to chart), otherwise center
   const int chartW = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
   const int chartH = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
   if(m_savedSettingsX >= 0 && m_savedSettingsY >= 0)
     {
      //--- Restore previous position + clamp to chart bounds
      m_settingsX = m_savedSettingsX;
      m_settingsY = m_savedSettingsY;
      if(m_settingsX + m_settingsWidth  > chartW) m_settingsX = chartW - m_settingsWidth;
      if(m_settingsY + m_settingsHeight > chartH) m_settingsY = chartH - m_settingsHeight;
      if(m_settingsX < 0) m_settingsX = 0;
      if(m_settingsY < 0) m_settingsY = 0;
     }
   else
     {
      //--- First open: center the window in the chart
      m_settingsX = (chartW - m_settingsWidth)  / 2;
      m_settingsY = (chartH - m_settingsHeight) / 2;
     }
   ApplySettingsPosition();

   //--- Hide the ribbon while Settings is open (HideSettings restores it on close)
   HideRibbon();

   //--- Flip visibility + attach the chart object + render
   m_isSettingsVisible = true;
   ObjectSetInteger(0, m_nameSettings, OBJPROP_TIMEFRAMES, OBJ_ALL_PERIODS);
   RedrawSettings();
   ChartRedraw();
  }

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

Далее мы создаем моментальный снимок свойств с помощью функции SnapshotProperties. Именно это позволяет отменить все изменения в окне: каждое последующее изменение сразу отображается на объекте, а при закрытии с отменой изменений мы восстанавливаем объект из этого моментального снимка. Считайте это запасным вариантом. Затем мы формируем список вкладок и сопоставление строк для каждой вкладки с помощью RefreshTabsForObject, делаем первую вкладку активной, заполняем её строки с помощью RefreshActiveTabRows и подстраиваем размер окна под это содержимое с помощью RecalcSettingsSize.

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

Наконец, мы скрываем ленту, чтобы два редактора не перекрывали друг друга (при закрытии окна она снова появляется), переключаем флаг видимости, включаем отображение объекта окна на графике на всех таймфреймах, чтобы он не исчезал при их переключении, и выполняем отрисовку окна с помощью RedrawSettings, после чего вызываем ChartRedraw. Теперь, когда окно отображается на экране, мы перейдём к тому, как оно формирует вкладки и сопоставляет каждый дескриптор со строкой, но сначала определим логику отмены и фиксации изменений.

//+------------------------------------------------------------------+
//| Ok handler - commit any pending edits + discard snapshot + close |
//+------------------------------------------------------------------+
void CSettingsWindow::CommitSettingsChanges()
  {
   //--- Force-commit any inline edits before closing
   if(m_textAreaFocused) UnfocusTextArea();
   if(m_coordEditPointIdx >= 0) CommitCoordEdit();
   //--- Drop the snapshot (commits the live preview values to the engine)
   DiscardSnapshot();
   HideSettings();
  }

//+------------------------------------------------------------------+
//| Cancel handler - restore from snapshot + close                   |
//+------------------------------------------------------------------+
void CSettingsWindow::DiscardSettingsChanges()
  {
   //--- Cancel any in-progress text edit
   if(m_textAreaFocused)
     {
      if(m_isEditingLabel) CancelLabel();
      m_textAreaFocused      = false;
      m_textAreaCaretBlinkOn = false;
     }
   //--- Cancel any in-progress coordinate edit
   if(m_coordEditPointIdx >= 0) CancelCoordEdit();
   //--- Restore the snapshot values to undo all live preview edits
   RestoreProperties();
   //--- Redraw all drawn objects so the chart shows the restored values
   RedrawAllObjects();
   HideSettings();
  }

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

Противоположный случай мы обрабатываем в методе DiscardSettingsChanges. Здесь мы отменяем все незавершённые правки, а не фиксируем их: если метка находится в режиме редактирования, отменяем правку и снимаем фокус с текстового поля; аналогичным образом отменяем правку координат. Затем мы вызываем функцию RestoreProperties, чтобы скопировать значения из моментального снимка обратно в объект, что одним движением отменяет все изменения, внесенные в режиме предварительного просмотра, а затем вызываем RedrawAllObjects, чтобы график перерисовался с восстановленными значениями, прежде чем закрыть окно с помощью HideSettings.

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

Создание вкладок и сопоставление строк

Здесь мы преобразуем список дескрипторов в видимую структуру окна с помощью трёх методов. RefreshTabsForObject формирует список вкладок, RefreshActiveTabRows заполняет активную вкладку строками, а ResolveActiveRowDescriptor по позиции строки определяет дескриптор, управляющий этой строкой.

//+------------------------------------------------------------------+
//| Rebuild the tab list (one tab per distinct group) for the object |
//+------------------------------------------------------------------+
void CSettingsWindow::RefreshTabsForObject()
  {
   //--- Reset tab arrays
   ArrayResize(m_tabGroups, 0);
   ArrayResize(m_tabLabels, 0);
   const int n = ArraySize(m_settingsProperties);
   //--- Walk every settings-eligible non-action property and collect distinct group ids
   for(int i = 0; i < n; i++)
     {
      if(m_settingsProperties[i].type == PROP_ACTION) continue;
      if(!m_settingsProperties[i].showInSettings) continue;
      const string g = m_settingsProperties[i].group;
      //--- Skip if this group is already in the tab list
      bool found = false;
      const int t = ArraySize(m_tabGroups);
      for(int k = 0; k < t; k++)
         if(m_tabGroups[k] == g) { found = true; break; }
      if(found) continue;
      //--- Append the group + map it to a display label
      const int sz = t + 1;
      ArrayResize(m_tabGroups, sz);
      ArrayResize(m_tabLabels, sz);
      m_tabGroups[sz - 1] = g;
      string lbl = g;
      if(g == PROP_GROUP_STYLE)           lbl = "Style";
      else if(g == PROP_GROUP_TEXT)       lbl = "Text";
      else if(g == PROP_GROUP_COORDS)     lbl = "Coordinates";
      else if(g == PROP_GROUP_VISIBILITY) lbl = "Visibility";
      m_tabLabels[sz - 1] = lbl;
     }

   //--- Auto-inject the Coordinates tab when the object has points (even if no coord-group properties are registered)
   const int pointCount = GetObjectPointCount(m_settingsOwnerObjectId);
   if(pointCount > 0)
     {
      bool hasCoordTab = false;
      const int tCount = ArraySize(m_tabGroups);
      for(int k = 0; k < tCount; k++)
         if(m_tabGroups[k] == PROP_GROUP_COORDS) { hasCoordTab = true; break; }
      if(!hasCoordTab)
        {
         //--- Coords tab missing - append it now
         const int sz = tCount + 1;
         ArrayResize(m_tabGroups, sz);
         ArrayResize(m_tabLabels, sz);
         m_tabGroups[sz - 1] = PROP_GROUP_COORDS;
         m_tabLabels[sz - 1] = "Coordinates";
        }
     }
  }

//+------------------------------------------------------------------+
//| Build the row-index list for the currently active tab            |
//+------------------------------------------------------------------+
void CSettingsWindow::RefreshActiveTabRows()
  {
   //--- Reset row mappings + clear hover state for stale rows
   ArrayResize(m_activeTabRowIdxs, 0);
   ArrayResize(m_synthRowDescriptors, 0);
   m_hoveredRowIdx          = -1;
   m_compactHoveredRow      = -1;
   m_compactHoveredStepper  = 0;
   m_compactHoveredSubRow      = -1;
   m_compactHoveredSubButton   = 0;
   //--- Bail on invalid active tab index
   if(m_activeTabIdx < 0 || m_activeTabIdx >= ArraySize(m_tabGroups)) return;
   const string activeGroup = m_tabGroups[m_activeTabIdx];
   const int n = ArraySize(m_settingsProperties);
   //--- Walk every property and add the ones in the active group to the row list
   for(int i = 0; i < n; i++)
     {
      const SToolProperty p = m_settingsProperties[i];
      if(p.type == PROP_ACTION) continue;
      if(!p.showInSettings) continue;
      if(p.group != activeGroup) continue;
      //--- PROP_LEVEL_LIST expands into one synthesized compact row per level
      if(p.type == PROP_LEVEL_LIST)
        {
         //--- Query the actual level count from the engine
         int levelCount = 0;
         GetObjectProperty(m_settingsOwnerObjectId, p.id + ":count", levelCount);
         for(int li = 0; li < levelCount; li++)
           {
            //--- Build a synthesized PROP_COMPACT_ROW descriptor for this level
            const string idxs = IntegerToString(li);
            SToolProperty row;
            row.id              = p.id + ":" + idxs;
            row.label           = "";
            row.type            = PROP_COMPACT_ROW;
            row.group           = p.group;
            row.showInRibbon    = false;
            row.showInSettings  = true;
            row.tooltip         = "";
            row.defaultColor    = clrBlack;
            row.defaultInt      = 0;
            row.defaultDouble   = 0.0;
            row.defaultString   = "";
            row.defaultBool     = false;
            row.minValue        = p.minValue;
            row.maxValue        = p.maxValue;
            row.stepValue       = p.stepValue;
            row.decimals        = p.decimals;
            //--- Sub-widget ids follow the convention: "<list>:<idx>:<field>"
            row.subVisibleId    = p.id + ":" + idxs + ":visible";
            row.subValueId      = p.id + ":" + idxs + ":ratio";
            row.subColorId      = p.id + ":" + idxs + ":color";
            row.subWidthId      = p.id + ":" + idxs + ":width";
            row.subStyleId      = p.id + ":" + idxs + ":style";
            row.levelIdx        = li;
            row.isAddLevelRow   = false;
            row.levelListPrefix = p.id;
            //--- Append to the synth array + reference it from the row list via negative encoding
            const int sySz = ArraySize(m_synthRowDescriptors);
            ArrayResize(m_synthRowDescriptors, sySz + 1);
            m_synthRowDescriptors[sySz] = row;
            const int rsz = ArraySize(m_activeTabRowIdxs);
            ArrayResize(m_activeTabRowIdxs, rsz + 1);
            //--- Negative-encoded: -(idx + 1) -> resolved by ResolveActiveRowDescriptor
            m_activeTabRowIdxs[rsz] = -(sySz + 1);
           }
         continue;
        }
      //--- Filter to the 6 renderable types (others are not row-eligible)
      if(p.type != PROP_COLOR && p.type != PROP_LINE_WIDTH
         && p.type != PROP_LINE_STYLE && p.type != PROP_COMPACT_ROW
         && p.type != PROP_BOOL && p.type != PROP_FLOAT)
         continue;
      //--- Append the real-descriptor index to the row list
      const int sz = ArraySize(m_activeTabRowIdxs);
      ArrayResize(m_activeTabRowIdxs, sz + 1);
      m_activeTabRowIdxs[sz] = i;
     }
  }

//+------------------------------------------------------------------+
//| Resolve a row slot to its descriptor (real or synthesized)       |
//+------------------------------------------------------------------+
SToolProperty CSettingsWindow::ResolveActiveRowDescriptor(int rowSlot)
  {
   //--- Out-of-range -> default-constructed empty descriptor
   SToolProperty empty;
   if(rowSlot < 0 || rowSlot >= ArraySize(m_activeTabRowIdxs)) return empty;
   const int code = m_activeTabRowIdxs[rowSlot];
   //--- Non-negative code -> direct index into m_settingsProperties
   if(code >= 0)
     {
      if(code >= ArraySize(m_settingsProperties)) return empty;
      return m_settingsProperties[code];
     }
   //--- Negative code -> negative-encoded synth index (-(idx + 1))
   const int synthIdx = -(code + 1);
   if(synthIdx < 0 || synthIdx >= ArraySize(m_synthRowDescriptors)) return empty;
   return m_synthRowDescriptors[synthIdx];
  }

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

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

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

Определение размеров и положения окна

Мы пересчитываем размер окна при каждом изменении его содержимого с помощью функции RecalcSettingsSize и передаем его логическое положение объекту графика с помощью функции  ApplySettingsPosition.

//+------------------------------------------------------------------+
//| Recompute window size based on the active tab's content height   |
//+------------------------------------------------------------------+
void CSettingsWindow::RecalcSettingsSize()
  {
   //--- Resolve the active group; empty string if no tabs
   const string activeGroup = (m_activeTabIdx >= 0
                              && m_activeTabIdx < ArraySize(m_tabGroups))
                              ? m_tabGroups[m_activeTabIdx]
                              : "";

   //--- Compute the content height for the active tab
   int contentH = 0;
   if(activeGroup == PROP_GROUP_TEXT)
     {
      //--- Text tab has 3 fixed-height rows: row1 (color+font+bold) 32 + gap 8 + row2 (text area) 90 + gap 8 + row3 (alignments) 32
      contentH = 32 + 8 + 90 + 8 + 32;     // = 170
     }
   else if(activeGroup == PROP_GROUP_COORDS)
     {
      //--- Coords tab has one row per drawn-object point (or 1 fallback)
      const int pointCount = GetObjectPointCount(m_settingsOwnerObjectId);
      const int rows = MathMax(1, pointCount);
      const int rowH = 32;
      const int rowGap = 8;
      contentH = rows * rowH + (rows - 1) * rowGap;
     }
   else
     {
      //--- Default tab: row-per-descriptor with the standard row height + gap
      int rows = ArraySize(m_activeTabRowIdxs);
      if(rows < 1) rows = 1;
      contentH = rows * (m_settingsRowH + m_settingsRowGap);
     }

   //--- Window width is fixed; height is content + chrome, clamped to the chart
   m_settingsWidth = 360;

   const int idealH = m_settingsHeaderH
                    + m_settingsTabBarH
                    + contentH
                    + m_settingsFooterH;
   //--- Clamp to chart-cap (min 160 to avoid degenerate windows)
   const int chartH = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
   const int chartCap = MathMax(160, chartH - 16);
   const int actualH = (idealH < chartCap) ? idealH : chartCap;
   m_settingsHeight  = actualH;
   //--- Chrome = header + tab bar + footer; body viewport = actualH - chrome
   const int bodyChromeH = m_settingsHeaderH + m_settingsTabBarH
                          + m_settingsFooterH;
   m_bodyContentH    = contentH;
   m_bodyViewportH   = actualH - bodyChromeH;
   if(m_bodyViewportH < 0) m_bodyViewportH = 0;
   //--- Max scroll = content - viewport (or 0 if content fits)
   m_bodyMaxScrollPx = MathMax(0, m_bodyContentH - m_bodyViewportH);
   if(m_bodyScrollPx > m_bodyMaxScrollPx) m_bodyScrollPx = m_bodyMaxScrollPx;
   if(m_bodyScrollPx < 0)                  m_bodyScrollPx = 0;

   //--- Resize canvas only when the actual size changed (avoids unnecessary reallocations)
   const int canvasW = m_settingsWidth  + 2 * m_settingsShadowPad;
   const int canvasH = m_settingsHeight + 2 * m_settingsShadowPad;
   if(m_canvasSettings.Width() != canvasW || m_canvasSettings.Height() != canvasH)
      m_canvasSettings.Resize(canvasW, canvasH);
   //--- Also push the new size to the chart object so MT5 knows the new bounds
   ObjectSetInteger(0, m_nameSettings, OBJPROP_XSIZE, canvasW);
   ObjectSetInteger(0, m_nameSettings, OBJPROP_YSIZE, canvasH);
  }

//+------------------------------------------------------------------+
//| Push the window's logical (X, Y) to the chart object             |
//+------------------------------------------------------------------+
void CSettingsWindow::ApplySettingsPosition()
  {
   //--- Subtract the shadow halo so the chart-object top-left = our logical top-left minus halo
   ObjectSetInteger(0, m_nameSettings, OBJPROP_XDISTANCE,
                     m_settingsX - m_settingsShadowPad);
   ObjectSetInteger(0, m_nameSettings, OBJPROP_YDISTANCE,
                     m_settingsY - m_settingsShadowPad);
  }

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

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

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

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

Вспомогательные функции расчёта прямоугольников для компоновки

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

//+------------------------------------------------------------------+
//| Layout helpers - return per-component bounds in window-local px  |
//+------------------------------------------------------------------+
void CSettingsWindow::GetTabContainerRect(int &outL, int &outT, int &outR, int &outB)
  {
   //--- Container = window pad to window pad horizontally + centered vertically inside the tab bar
   outL = m_settingsPadX;
   outR = m_settingsWidth - m_settingsPadX;
   const int barT = m_settingsHeaderH;
   outT = barT + (m_settingsTabBarH - m_settingsTabContainerH) / 2;
   outB = outT + m_settingsTabContainerH;
  }

//+------------------------------------------------------------------+
//| Tab segment rect (n-th tab inside the container, equal width)    |
//+------------------------------------------------------------------+
void CSettingsWindow::GetTabRect(int tabIdx, int &outL, int &outT, int &outR, int &outB)
  {
   //--- Bail on empty or out-of-range tab index
   const int n = ArraySize(m_tabLabels);
   if(n <= 0 || tabIdx < 0 || tabIdx >= n)
     { outL = outT = outR = outB = 0; return; }
   //--- Divide the container into n equal-width segments
   int cL, cT, cR, cB;
   GetTabContainerRect(cL, cT, cR, cB);
   const int containerW = cR - cL;
   const int segW = containerW / n;
   //--- Last tab gets any leftover width so the strip extends fully to the right edge
   const bool isLast = (tabIdx == n - 1);
   outL = cL + tabIdx * segW;
   outR = isLast ? cR : (outL + segW);
   outT = cT;
   outB = cB;
  }

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

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

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

РЕАЛИЗАЦИЯ ОКНА НАСТРОЕК

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


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

Маршрутизация щелчков в окне

Теперь перейдём к файлу взаимодействия, в котором находятся тела методов CSettingsWindow, отвечающих за обработку ввода. Центральную роль играет SettingsMouseDown — маршрутизатор щелчков, через который проходит каждое нажатие внутри окна; в паре с ним работает SettingsMouseUp, завершающий активное перетаскивание.

//+------------------------------------------------------------------+
//|                              ToolsPalette_Settings_Interact.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_SETTINGS_INTERACT_MQH
#define TOOLS_PALETTE_SETTINGS_INTERACT_MQH

//--- Pull in the Settings window declaration (CSettingsWindow class)
#include "ToolsPalette_Settings.mqh"

//+------------------------------------------------------------------+
//| SettingsMouseDown - click router for the Settings window         |
//+------------------------------------------------------------------+
bool CSettingsWindow::SettingsMouseDown(int mouseX, int mouseY)
  {
   //--- Reject clicks outside the window (return false so the engine can route elsewhere)
   int lx, ly;
   if(!HitTestOverSettings(mouseX, mouseY, lx, ly)) return false;

   //--- Cache active-tab + Text-tab control hit (needed for the text-area unfocus rule below)
   const bool isTextTabActive = (m_activeTabIdx >= 0
                              && m_activeTabIdx < ArraySize(m_tabGroups)
                              && m_tabGroups[m_activeTabIdx] == PROP_GROUP_TEXT);
   const int  textCtrlClicked = isTextTabActive ? HitTestTextTabControl(lx, ly) : 0;
   //--- Click anywhere except the text-input itself unfocuses the text area
   if(m_textAreaFocused && textCtrlClicked != 5)
      UnfocusTextArea();

   //--- Cache Coords-tab active flag (needed for coord-edit commit rules below)
   const bool isCoordsTabActive = (m_activeTabIdx >= 0
                                && m_activeTabIdx < ArraySize(m_tabGroups)
                                && m_tabGroups[m_activeTabIdx] == PROP_GROUP_COORDS);
   //--- Commit any in-progress coord edit when clicking outside its row OR outside the Coords tab
   if(IsEditingCoord() && isCoordsTabActive)
     {
      //--- Allow re-clicking the same field's text area without committing (just repositions caret)
      int hitRow, hitField, hitStepper;
      const bool overCoords = HitTestCoordsTab(lx, ly, hitRow, hitField, hitStepper);
      const bool clickingSameField = overCoords
                                    && hitRow == m_coordEditPointIdx
                                    && hitField == m_coordEditField
                                    && hitStepper == 0;
      if(!clickingSameField) CommitCoordEdit();
     }
   else if(IsEditingCoord() && !isCoordsTabActive)
     {
      //--- Coord edit lives only on Coords tab; switching tabs commits it
      CommitCoordEdit();
     }
   //--- Commit any in-progress float edit when clicking outside its value button (steppers excluded)
   if(IsEditingFloat())
     {
      bool clickingSameField = false;
      const int rn = ArraySize(m_activeTabRowIdxs);
      //--- Scan rows to find the value button that matches the currently-edited prop id
      for(int rr = 0; rr < rn; rr++)
        {
         const SToolProperty pp = ResolveActiveRowDescriptor(rr);
         string thisValueId = "";
         if(pp.type == PROP_FLOAT)
            thisValueId = pp.id;
         else if(pp.type == PROP_COMPACT_ROW)
            thisValueId = pp.subValueId;
         if(thisValueId != m_floatEditPropId) continue;
         //--- Resolve the value-button + stepper rects for this row
         int bL, bT, bR, bB;
         if(!GetCompactValueButtonRect(rr, bL, bT, bR, bB)) break;
         int sUL, sUT, sUR, sUB; GetCompactStepperRect(rr, 0, sUL, sUT, sUR, sUB);
         int sDL, sDT, sDR, sDB; GetCompactStepperRect(rr, 1, sDL, sDT, sDR, sDB);
         //--- "Same field" = inside the button but NOT on the stepper chevrons
         const bool onUp   = (lx >= sUL && lx < sUR && ly >= sUT && ly < sUB);
         const bool onDown = (lx >= sDL && lx < sDR && ly >= sDT && ly < sDB);
         const bool inBtn  = (lx >= bL && lx < bR && ly >= bT && ly < bB);
         if(inBtn && !onUp && !onDown) clickingSameField = true;
         break;
        }
      if(!clickingSameField) CommitFloatEdit();
     }

   //--- Close-X click -> discard changes (Cancel-equivalent) + close window
   if(HitTestCloseButton(lx, ly))
     { DiscardSettingsChanges(); return true; }

   //--- Footer button dispatch (1=Cancel, 2=Ok, 3=Apply Defaults)
   const int btn = HitTestFooterButton(lx, ly);
   if(btn == 1) { DiscardSettingsChanges(); return true; }
   if(btn == 2) { CommitSettingsChanges();  return true; }
   if(btn == 3)
     {
      //--- Apply Defaults: cancel any in-progress edits + apply tool defaults + rebuild layout
      if(m_textAreaFocused)
        {
         if(m_isEditingLabel) CancelLabel();
         m_textAreaFocused      = false;
         m_textAreaCaretBlinkOn = false;
        }
      if(m_coordEditPointIdx >= 0) CancelCoordEdit();
      if(IsEditingFloat())          CancelFloatEdit();
      //--- Reset all properties to their type-specific defaults
      ApplyToolDefaults(m_settingsOwnerObjectId);
      RefreshActiveTabRows();
      RecalcSettingsSize();
      ApplySettingsPosition();
      RedrawSettings();
      ChartRedraw();
      return true;
     }

   //--- Tab click - switch active tab + rebuild row list + recompute size
   const int tabIdx = HitTestTab(lx, ly);
   if(tabIdx >= 0)
     {
      //--- Only repaint if the tab actually changed
      if(tabIdx != m_activeTabIdx)
        {
         m_activeTabIdx = tabIdx;
         RefreshActiveTabRows();
         //--- Reset body scroll when switching tabs (new content layout)
         m_bodyScrollPx = 0;
         RecalcSettingsSize();
         ApplySettingsPosition();
         RedrawSettings();
         ChartRedraw();
        }
      return true;
     }

   //--- Header drag-area click - begin window drag (offsets captured for the duration of the drag)
   if(HitTestHeaderDragArea(lx, ly))
     {
      m_isDraggingSettings = true;
      m_dragGrabOffsetX = lx;
      m_dragGrabOffsetY = ly;
      return true;
     }

   //--- OTHER OBJECTS FOLLOW THE SAME STRUCTURE

   }


//+------------------------------------------------------------------+
//| SettingsMouseUp - end any active drag (window or scrollbar)      |
//+------------------------------------------------------------------+
bool CSettingsWindow::SettingsMouseUp()
  {
   //--- "Consumed" tracking - true if any drag was active
   bool consumed = false;
   //--- End each of the three possible drags + flag consumed
   if(m_isDraggingSettings)    { m_isDraggingSettings    = false; consumed = true; }
   if(m_textAreaThumbDragging) { m_textAreaThumbDragging = false; consumed = true; }
   if(m_bodyThumbDragging)     { m_bodyThumbDragging     = false; consumed = true; }
   //--- Repaint once if a drag ended (so the thumb returns to its idle color)
   if(consumed) { RedrawSettings(); ChartRedraw(); }
   return consumed;
  }

В начале SettingsMouseDown мы отклоняем щелчки за пределами окна, возвращая false, чтобы движок мог направить их другим обработчикам. Прежде чем обрабатывать элемент, по которому щёлкнули, мы завершаем уже начатое редактирование. Щелчок в любом месте, кроме самого поля ввода текста, снимает фокус с текстового поля. Изменения координат фиксируются при щелчке за пределами соответствующего поля или при переходе с вкладки "Координаты" на другую вкладку, однако повторный щелчок по тому же полю лишь перемещает текстовый курсор, не фиксируя изменений. Редактирование числа завершается фиксацией изменений по тому же принципу: мы просматриваем строки, чтобы найти кнопку значения, соответствующую редактируемому свойству, и считаем, что щелчок остаётся в пределах того же поля, только если он приходится на эту кнопку, но не на стрелки её степпера (элемента пошагового изменения значения со стрелками вверх и вниз).

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

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

Подход к заданию координат в MT5

В терминале используются шкала дат и шкала цен. Вы можете изменить дату, выбрав её из выпадающего списка, но в веб-версии можно изменить только цену. См. ниже.

Вкладка "Координаты", веб-версия MQL5

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

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

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

//--- Coords tab row geometry (heights / button widths / stepper widths)
#define COORDS_ROW_H         32
#define COORDS_ROW_GAP        8
#define COORDS_LABEL_W       100
#define COORDS_BTN_GAP        6
#define COORDS_BTN_H         24
#define COORDS_STEPPER_W     16

//+------------------------------------------------------------------+
//| Coords row rect (offset by body scroll, padded by window pad-X)  |
//+------------------------------------------------------------------+
void CSettingsWindow::GetCoordRowRect(int rowIdx, int &outL, int &outT, int &outR, int &outB)
  {
   //--- Rows start below header+tabs, indexed by rowIdx, offset by scroll
   const int rowsTop = m_settingsHeaderH + m_settingsTabBarH;
   outL = m_settingsPadX;
   outR = m_settingsWidth - m_settingsPadX;
   outT = rowsTop + rowIdx * (COORDS_ROW_H + COORDS_ROW_GAP) - m_bodyScrollPx;
   outB = outT + COORDS_ROW_H;
  }

//+------------------------------------------------------------------+
//| Price button rect (left half of the two-button cluster on a row) |
//+------------------------------------------------------------------+
void CSettingsWindow::GetCoordPriceButtonRect(int rowIdx, int &outL, int &outT, int &outR, int &outB)
  {
   //--- Row bounds + label-W carve-out at the left + 2 equal buttons in remaining space
   int rL, rT, rR, rB;
   GetCoordRowRect(rowIdx, rL, rT, rR, rB);
   const int btnsL = rL + COORDS_LABEL_W;
   const int btnsR = rR;
   const int btnW  = (btnsR - btnsL - COORDS_BTN_GAP) / 2;
   //--- Price button = left button
   outL = btnsL; outR = outL + btnW;
   outT = rT + (COORDS_ROW_H - COORDS_BTN_H) / 2;
   outB = outT + COORDS_BTN_H;
  }

//+------------------------------------------------------------------+
//| Time button rect (right half of the two-button cluster)          |
//+------------------------------------------------------------------+
void CSettingsWindow::GetCoordTimeButtonRect(int rowIdx, int &outL, int &outT, int &outR, int &outB)
  {
   //--- Same geometry, but right-aligned (right button of the pair)
   int rL, rT, rR, rB;
   GetCoordRowRect(rowIdx, rL, rT, rR, rB);
   const int btnsL = rL + COORDS_LABEL_W;
   const int btnsR = rR;
   const int btnW  = (btnsR - btnsL - COORDS_BTN_GAP) / 2;
   //--- Time button = right button (anchored to btnsR, extending left by btnW)
   outR = btnsR; outL = outR - btnW;
   outT = rT + (COORDS_ROW_H - COORDS_BTN_H) / 2;
   outB = outT + COORDS_BTN_H;
  }

//+------------------------------------------------------------------+
//| Coords stepper rect (up/down chevron inside price or time button)|
//+------------------------------------------------------------------+
void CSettingsWindow::GetCoordStepperRect(int rowIdx, int field, int dir,
                                            int &outL, int &outT, int &outR, int &outB)
  {
   //--- Resolve the parent button rect based on the field (1=price, 2=time)
   int bL, bT, bR, bB;
   if(field == 1) GetCoordPriceButtonRect(rowIdx, bL, bT, bR, bB);
   else           GetCoordTimeButtonRect(rowIdx,  bL, bT, bR, bB);
   //--- Stepper sits on the right edge of the button (same convention as compact-row stepper)
   outR = bR - 2;
   outL = outR - COORDS_STEPPER_W;
   const int halfH = (bB - bT) / 2;
   //--- dir=0 -> upper half (increment), dir=1 -> lower half (decrement)
   if(dir == 0) { outT = bT + 2; outB = bT + halfH; }
   else         { outT = bT + halfH; outB = bB - 2; }
  }

//+------------------------------------------------------------------+
//| Hit-test against Coords-tab rows + fields + steppers             |
//+------------------------------------------------------------------+
bool CSettingsWindow::HitTestCoordsTab(int lx, int ly,
                                         int &outRow, int &outField, int &outStepper)
  {
   //--- Initialize out-params to "no hit" sentinels
   outRow = -1; outField = 0; outStepper = 0;
   //--- Reject hits outside the body viewport
   const int viewportT = m_settingsHeaderH + m_settingsTabBarH;
   const int viewportB = viewportT + m_bodyViewportH;
   if(ly < viewportT || ly >= viewportB) return false;
   //--- Walk each point's row; bail when row found (returns true with field+stepper set)
   const int pointCount = GetObjectPointCount(m_settingsOwnerObjectId);
   for(int r = 0; r < pointCount; r++)
     {
      //--- Skip rows that don't contain ly
      int rL, rT, rR, rB;
      GetCoordRowRect(r, rL, rT, rR, rB);
      if(ly < rT || ly >= rB) continue;
      outRow = r;
      //--- Check both fields (1=price, 2=time) for stepper hits first (chevrons take priority)
      int sL, sT, sR, sB;
      for(int f = 1; f <= 2; f++)
        {
         //--- Up-stepper hit: stepper key 1 (price up) or 3 (time up)
         GetCoordStepperRect(r, f, 0, sL, sT, sR, sB);
         if(lx >= sL && lx < sR && ly >= sT && ly < sB)
           { outField = f; outStepper = (f == 1) ? 1 : 3; return true; }
         //--- Down-stepper hit: stepper key 2 (price down) or 4 (time down)
         GetCoordStepperRect(r, f, 1, sL, sT, sR, sB);
         if(lx >= sL && lx < sR && ly >= sT && ly < sB)
           { outField = f; outStepper = (f == 1) ? 2 : 4; return true; }
        }
      //--- Then check field hits (price text area)
      int pL, pT, pR, pB;
      GetCoordPriceButtonRect(r, pL, pT, pR, pB);
      if(lx >= pL && lx < pR && ly >= pT && ly < pB)
        { outField = 1; return true; }
      //--- Then time text area
      GetCoordTimeButtonRect(r, pL, pT, pR, pB);
      if(lx >= pL && lx < pR && ly >= pT && ly < pB)
        { outField = 2; return true; }
      //--- Row hit but no field hit (clicked the label) - still return true with field=0
      return true;
     }
   return false;
  }

Начинаем с блока констант, задающих высоту строки, ширину надписи, зазор между кнопками, высоту кнопок и ширину степпера. Затем размещаем каждую строку с помощью GetCoordRowRect: отсчитываем строки вниз от нижнего края панели вкладок и учитываем смещение прокрутки области содержимого. В GetCoordPriceButtonRect мы отводим слева в строке место под надпись, а оставшееся пространство делим на две равные кнопки, используя левую для цены. В GetCoordTimeButtonRect действуем аналогично, но привязываем кнопку времени к правому краю. Затем мы размещаем степперы увеличения и уменьшения с помощью GetCoordStepperRect. Эта функция определяет родительскую кнопку по указанному полю и располагает стрелки у её правого края: верхняя половина отвечает за увеличение, нижняя — за уменьшение. Тот же принцип используется для степпера компактной строки.

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

Жизненный цикл редактирования координат

Мы организуем редактирование цены и времени непосредственно в полях через небольшой жизненный цикл: StartCoordEdit открывает поле, CommitCoordEdit разбирает содержимое буфера и записывает значение обратно в объект, а CancelCoordEdit отбрасывает буфер, не изменяя объект. Для преобразования исходных значений в редактируемый текст используются две вспомогательные функции форматирования.

//+------------------------------------------------------------------+
//| Format a price for display (uses symbol digits for precision)    |
//+------------------------------------------------------------------+
string CSettingsWindow::FormatPriceForDisplay(double price)
  {
   //--- Use the symbol's tick-digit precision
   const int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   return DoubleToString(price, digits);
  }

//+------------------------------------------------------------------+
//| Format a time as a bar index (relative to current chart period)  |
//+------------------------------------------------------------------+
string CSettingsWindow::FormatBarForDisplay(datetime time)
  {
   //--- iBarShift returns -1 for times in the future; clamp to 0
   int bar = iBarShift(_Symbol, _Period, time, false);
   if(bar < 0) bar = 0;
   return IntegerToString(bar);
  }

//+------------------------------------------------------------------+
//| Start an inline edit on a coordinate field (price or time)       |
//+------------------------------------------------------------------+
void CSettingsWindow::StartCoordEdit(int pointIdx, int field)
  {
   //--- Commit any existing edit before starting a new one
   if(m_coordEditPointIdx >= 0) CommitCoordEdit();
   //--- Build the initial edit buffer from the current property value
   string buf = "";
   if(field == 1)
     {
      //--- Price field: read price + format with symbol digits
      double p = 0.0;
      if(GetObjectPointPrice(m_settingsOwnerObjectId, pointIdx, p))
         buf = FormatPriceForDisplay(p);
     }
   else if(field == 2)
     {
      //--- Time field: read time + format as a bar shift
      datetime t = 0;
      if(GetObjectPointTime(m_settingsOwnerObjectId, pointIdx, t))
         buf = FormatBarForDisplay(t);
     }
   //--- Initialize the edit state (caret at end of buffer; no selection)
   m_coordEditPointIdx = pointIdx;
   m_coordEditField    = field;
   m_coordEditBuffer   = buf;
   m_coordEditCaretPos = StringLen(buf);
   m_coordSelectionAnchor = -1;
   m_coordEditCaretBlinkOn     = true;
   m_coordEditCaretBlinkLastMs = (uint)GetTickCount();
   //--- Take over keyboard input from the chart while editing
   BeginKeyboardOverride();
  }

//+------------------------------------------------------------------+
//| Commit the current coordinate edit (parse + push to the engine)  |
//+------------------------------------------------------------------+
void CSettingsWindow::CommitCoordEdit()
  {
   //--- No-op when not editing
   if(m_coordEditPointIdx < 0) return;
   //--- Cache edit state locally (cleared below)
   const int  pIdx  = m_coordEditPointIdx;
   const int  field = m_coordEditField;
   const string buf = m_coordEditBuffer;
   if(field == 1)
     {
      //--- Price field: trim + replace "," with "." (Euro-locale tolerance) + parse double + push
      string trimmed = buf;
      StringTrimLeft(trimmed); StringTrimRight(trimmed);
      StringReplace(trimmed, ",", ".");
      const double newPrice = StringToDouble(trimmed);
      //--- Only push when the buffer wasn't empty (preserves the original value on accidental clears)
      if(StringLen(trimmed) > 0)
         SetObjectPointPrice(m_settingsOwnerObjectId, pIdx, newPrice, false);
     }
   else if(field == 2)
     {
      //--- Time field: trim + parse int as bar shift + clamp >= 0 + convert to datetime via iTime
      string trimmed = buf;
      StringTrimLeft(trimmed); StringTrimRight(trimmed);
      const int newBar = (int)StringToInteger(trimmed);
      const int clamped = (newBar < 0) ? 0 : newBar;
      const datetime newTime = iTime(_Symbol, _Period, clamped);
      //--- Only push when iTime returned a valid timestamp (guards against unloaded history)
      if(newTime > 0)
         SetObjectPointTime(m_settingsOwnerObjectId, pIdx, newTime, false);
     }
   //--- Clear edit state + release keyboard override
   m_coordEditPointIdx = -1; m_coordEditField = 0;
   m_coordEditBuffer   = ""; m_coordEditCaretPos = 0;
   m_coordSelectionAnchor = -1;
   EndKeyboardOverride();
   //--- Repaint to remove the focus border + caret
   if(m_isSettingsVisible) RedrawSettings();
  }

//+------------------------------------------------------------------+
//| Cancel the current coordinate edit (drop buffer without saving)  |
//+------------------------------------------------------------------+
void CSettingsWindow::CancelCoordEdit()
  {
   //--- No-op when not editing
   if(m_coordEditPointIdx < 0) return;
   //--- Clear edit state without committing anything
   m_coordEditPointIdx = -1; m_coordEditField = 0;
   m_coordEditBuffer   = ""; m_coordEditCaretPos = 0;
   m_coordSelectionAnchor = -1;
   EndKeyboardOverride();
   if(m_isSettingsVisible) RedrawSettings();
  }

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

Мы открываем поле в StartCoordEdit: сначала фиксируем результат текущего редактирования, если оно выполняется, затем заполняем буфер редактирования текущим значением поля — отформатированной ценой для поля "Цена" или отформатированным индексом бара для поля "Время". Мы помещаем текстовый курсор в конец буфера без выделения, инициализируем состояние мигания и вызываем BeginKeyboardOverride для перехвата клавиатуры у графика, чтобы ввод текста не активировал сочетания клавиш самого графика.

Мы закрываем поле в CommitCoordEdit, сохраняя состояние редактирования локально и разбирая содержимое буфера в зависимости от типа поля. Для цены мы удаляем пробелы по краям, заменяем запятую точкой, чтобы десятичное число в европейском формате корректно распознавалось, преобразуем его в double и передаём в SetObjectPointPrice — но только если после удаления пробелов буфер не пуст, чтобы случайная очистка поля не меняла исходное значение. Для времени мы удаляем пробелы по краям, считываем индекс бара, ограничиваем его снизу нулём, преобразуем обратно во временную метку с помощью iTime и передаём её в SetObjectPointTime только в том случае, если она корректна: это защищает от ошибок при незагруженной истории. Затем мы сбрасываем состояние редактирования, завершаем перехват клавиатуры с помощью EndKeyboardOverride и выполняем перерисовку, чтобы убрать рамку фокуса и текстовый курсор.

Функция CancelCoordEdit служит для отмены редактирования: она сбрасывает то же состояние редактирования и завершает перехват клавиатуры без разбора или записи данных, оставляя координату объекта в точности такой, какой она была. Реализовав жизненный цикл редактирования координат, мы переходим к отрисовке вкладки "Координаты".

Отрисовка вкладки "Координаты"

Мы выполняем отрисовку всей вкладки "Координаты" в функции DrawCoordsTabRows, которая за один проход использует вспомогательные функции для прямоугольников, текущие значения координат и состояние редактирования. Каждой опорной точке соответствует одна строка с расположенными рядом полями цены и времени.

//+------------------------------------------------------------------+
//| DrawCoordsTabRows - full render for the Coordinates tab          |
//+------------------------------------------------------------------+
void CSettingsWindow::DrawCoordsTabRows()
  {
   //--- Canvas-space top-left + bound object id + point count + viewport bounds
   const int boxL = m_settingsShadowPad;
   const int boxT = m_settingsShadowPad;
   const int objId = m_settingsOwnerObjectId;
   const int pointCount = GetObjectPointCount(objId);
   const int viewportT = m_settingsHeaderH + m_settingsTabBarH;
   const int viewportB = viewportT + m_bodyViewportH;

   //--- One row per drawn-object point
   for(int r = 0; r < pointCount; r++)
     {
      //--- Skip rows fully above or below the viewport (scroll clipping)
      int rcL, rcT, rcR, rcB;
      GetCoordRowRect(r, rcL, rcT, rcR, rcB);
      if(rcB <= viewportT) continue;
      if(rcT >= viewportB) continue;

      //--- Read the live coordinate values for this point from the engine
      double price = 0.0;
      datetime t = 0;
      GetObjectPointPrice(objId, r, price);
      GetObjectPointTime(objId, r, t);

      //--- Label = "#1 (price, bar)" etc. (left-aligned at pad-X, vertically centered)
      int rL, rT, rR, rB;
      GetCoordRowRect(r, rL, rT, rR, rB);
      m_canvasSettings.FontSet("Arial", -100);
      const string lbl = "#" + IntegerToString(r + 1) + " (price, bar)";
      const int lLH = m_canvasSettings.TextHeight(lbl);
      m_canvasSettings.TextOut(boxL + rL,
                                 boxT + rT + (COORDS_ROW_H - lLH) / 2,
                                 lbl,
                                 ColorToARGB(m_themeColors.flyoutTextColor, 220));

      //--- 2 fields per row: 1=price, 2=time (rendered side-by-side)
      for(int field = 1; field <= 2; field++)
        {
         //--- Field button rect
         int bL, bT, bR, bB;
         if(field == 1) GetCoordPriceButtonRect(r, bL, bT, bR, bB);
         else           GetCoordTimeButtonRect(r,  bL, bT, bR, bB);

         //--- State flags: is this field being edited / is the mouse hovering it
         const bool isEditing = (m_coordEditPointIdx == r && m_coordEditField == field);
         const bool isHov     = (m_coordHoveredRow == r && m_coordHoveredField == field);

         //--- Border color = DodgerBlue focus when editing, separator otherwise
         const uint focusArgb  = ColorToARGB(clrDodgerBlue, 255);
         const uint normalArgb = ColorToARGB(m_themeColors.separatorColor, 255);
         const uint fillArgb   = ColorToARGB(m_themeColors.flyoutBackground, 255);
         //--- Paint button outline + fill
         WidgetStrokeRoundRect(m_canvasSettings,
                                 boxL + bL, boxT + bT, boxL + bR, boxT + bB,
                                 4, 1, isEditing ? focusArgb : normalArgb, fillArgb);
         //--- Editing state: paint a second inner border for emphasis
         if(isEditing)
            WidgetStrokeRoundRect(m_canvasSettings,
                                    boxL + bL + 1, boxT + bT + 1,
                                    boxL + bR - 1, boxT + bB - 1,
                                    3, 1, focusArgb, fillArgb);
         //--- Hover tint when not editing
         if(isHov && !isEditing)
           {
            const uint tintArgb = ColorToARGB(m_themeColors.flyoutTextColor, 28);
            FillNoteRoundRect(m_canvasSettings,
                                boxL + bL + 1, boxT + bT + 1,
                                boxL + bR - 1, boxT + bB - 1,
                                3, tintArgb);
           }

         //--- Display text = edit buffer if editing, formatted price/bar otherwise
         m_canvasSettings.FontSet("Arial", -100);
         string displayText;
         if(isEditing)       displayText = m_coordEditBuffer;
         else if(field == 1) displayText = FormatPriceForDisplay(price);
         else                displayText = FormatBarForDisplay(t);

         //--- Show steppers when hovered OR editing
         const bool showSteppers = (isHov || isEditing);
         //--- Text geometry (6 px left pad, vertically centered)
         const int textLH = m_canvasSettings.TextHeight(displayText);
         const int textY  = boxT + bT + (COORDS_BTN_H - textLH) / 2;
         const int textX  = boxL + bL + 6;

         //--- Render text selection highlight when there's an active selection range
         if(isEditing
            && m_coordSelectionAnchor >= 0
            && m_coordSelectionAnchor != m_coordEditCaretPos)
           {
            //--- Normalize selection bounds + measure pre/in widths
            const int selS = (m_coordSelectionAnchor < m_coordEditCaretPos) ? m_coordSelectionAnchor : m_coordEditCaretPos;
            const int selE = (m_coordSelectionAnchor > m_coordEditCaretPos) ? m_coordSelectionAnchor : m_coordEditCaretPos;
            const string preSel = StringSubstr(m_coordEditBuffer, 0, selS);
            const string inSel  = StringSubstr(m_coordEditBuffer, selS, selE - selS);
            const int preW = (StringLen(preSel) > 0) ? m_canvasSettings.TextWidth(preSel) : 0;
            const int selW = (StringLen(inSel) > 0)  ? m_canvasSettings.TextWidth(inSel)  : 0;
            //--- Paint the highlight at 90 alpha
            const uint selArgb = ColorToARGB(clrDodgerBlue, 90);
            for(int yy = boxT + bT + 3; yy < boxT + bB - 3; yy++)
               for(int xx = textX + preW; xx < textX + preW + selW; xx++)
                  WidgetBlendPixel(m_canvasSettings, xx, yy, selArgb);
           }

         //--- Draw the text on top of the (optional) highlight
         m_canvasSettings.TextOut(textX, textY, displayText,
                                    ColorToARGB(m_themeColors.flyoutTextColor, 230));

         //--- Caret: thin AA line at the caret column when editing + visible blink phase
         if(isEditing && m_coordEditCaretBlinkOn)
           {
            const string seg = StringSubstr(m_coordEditBuffer, 0, m_coordEditCaretPos);
            const int caretX = textX + m_canvasSettings.TextWidth(seg);
            const uint caretArgb = ColorToARGB(m_themeColors.flyoutTextColor, 255);
            WidgetThickLineAA(m_canvasSettings, caretX, boxT + bT + 4,
                                                 caretX, boxT + bB - 4, 1, caretArgb);
           }

         //--- Render steppers (up + down chevrons) when hovered or editing
         if(showSteppers)
           {
            //--- Two stepper directions: 0 = up, 1 = down
            for(int dir = 0; dir <= 1; dir++)
              {
               int sL, sT, sR, sB;
               GetCoordStepperRect(r, field, dir, sL, sT, sR, sB);
               //--- Stepper key naming: field 1 (price) = keys 1/2; field 2 (time) = keys 3/4
               const int stepperKey = (field == 1) ? ((dir == 0) ? 1 : 2) : ((dir == 0) ? 3 : 4);
               const bool stepHov = (m_coordHoveredRow == r && m_coordHoveredStepper == stepperKey);
               if(stepHov)
                 {
                  //--- Subtle hover background behind the stepper
                  const uint stepBgArgb = ColorToARGB(m_themeColors.flyoutTextColor, 45);
                  FillNoteRoundRect(m_canvasSettings,
                                      boxL + sL, boxT + sT, boxL + sR, boxT + sB,
                                      2, stepBgArgb);
                 }
               //--- Chevron glyph (up or down)
               const int cx = boxL + (sL + sR) / 2;
               const int cy = boxT + (sT + sB) / 2;
               const uint chevArgb = ColorToARGB(m_themeColors.flyoutTextColor, 230);
               if(dir == 0)
                 { WidgetThickLineAA(m_canvasSettings, cx-3,cy+1,cx,cy-1,2,chevArgb);
                   WidgetThickLineAA(m_canvasSettings, cx,cy-1,cx+3,cy+1,2,chevArgb); }
               else
                 { WidgetThickLineAA(m_canvasSettings, cx-3,cy-1,cx,cy+1,2,chevArgb);
                   WidgetThickLineAA(m_canvasSettings, cx,cy+1,cx+3,cy-1,2,chevArgb); }
              }
           }
        }
     }
   //--- Draw body scrollbar on top when content overflows
   if(m_bodyMaxScrollPx > 0)
      DrawBodyScrollbar();
  }

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

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

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

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

ОТРИСОВКА ВКЛАДКИ "КООРДИНАТЫ"

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


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

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

ТЕСТИРОВАНИЕ ПАЛИТРЫ ИНСТРУМЕНТОВ (GIF)

В ходе тестирования окно открывалось по центру графика и отображало только вкладки, применимые к выбранному инструменту; при переключении вкладок строки перестраивались, а размер окна подстраивался под содержимое. Изменения значений сразу отображались на графике: перетаскивание ползунка, ввод в чип числа в допустимом диапазоне, изменение коэффициента уровня Фибоначчи в компактной строке и ввод точной цены или индекса бара на вкладке "Координаты" немедленно обновляли объект. Если строки не помещались в области содержимого, её можно было прокручивать; окно можно было перетаскивать за заголовок, а закрытие кнопкой ОК сохраняло изменения, тогда как нажатие "Отмена" возвращало объект в состояние на момент открытия окна.


Заключение

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

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

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


Вложения

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

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

Прикрепленные файлы |
Архитектура машинного обучения в MetaTrader 5 (Часть 23): Предварительный отбор признаков Архитектура машинного обучения в MetaTrader 5 (Часть 23): Предварительный отбор признаков
Перестановочные тесты, предполагающие обменность наблюдений, приводят к неверной калибровке предварительного отбора признаков при перекрытии финансовых меток, в результате чего частота ложноположительных результатов на данных EURUSD возрастает в десять раз. В статье реализован откалиброванный конвейер с тремя этапами проверки: ADF+KPSS для проверки стационарности, энтропия на равномерной сетке с учетом доли наблюдений в модальном интервале и взаимная информация, скорректированная с помощью совместного перестановочного нулевого распределения и поправки Уэстфолла — Янга max-T. Отчет ScreeningReport содержит сводку результатов этапов проверки и эффективное число тестов, что позволяет надежно отфильтровать признаки перед обучением моделей.
Интерактивное управление зонами спроса и предложения на MQL5 (Часть V): Сохранение состояния зон между перезапусками терминала и советника Интерактивное управление зонами спроса и предложения на MQL5 (Часть V): Сохранение состояния зон между перезапусками терминала и советника
Мы представляем слой долговременного хранения с поддержкой версий, который сохраняет и восстанавливает логическое состояние механизма обработки зон между сеансами работы. Снимок состояния сохраняет состояние жизненного цикла, историю взаимодействий, оценки, цены из черного списка, а также геометрию и временные точки привязки прямоугольников, нарисованных пользователем; при запуске это состояние восстанавливается, а графические объекты согласуются с ним. Зоны, нарисованные пользователем, добавляются с минимальной оценкой, что позволяет включить их в общий жизненный цикл и торговый конвейер.
Разработка библиотеки для создания PDF-файлов на MQL5 (Часть 2): Почему PDF-файлы повреждаются Разработка библиотеки для создания PDF-файлов на MQL5 (Часть 2): Почему PDF-файлы повреждаются
Узнайте, как программа просмотра открывает PDF-файл в обратном порядке, почему записи xref должны иметь размер ровно 20 байт и как изменение двух символов приводит к искажению нескольких смещений. Мы воспроизводим три типичных сбоя, сравниваем результаты в PDFium и pypdf и выделяем четыре строгих проверки, которые должен пройти генератор. Входящий в комплект класс PdfValidate.mqh для MQL5 выполняет эти проверки и возвращает смещения и номера объектов, помогающие выявить проблемы и провести надежное тестирование, не ограничиваясь проверкой «файл открывается».
Машинное обучение в условиях ограничений (Часть 3): Снижение риска при приближении к цели по прибыли и правило новостного окна Машинное обучение в условиях ограничений (Часть 3): Снижение риска при приближении к цели по прибыли и правило новостного окна
Расчет размера позиции без учета близости к цели по прибыли или времени выхода важных новостных событий подвергает уже достигнутый результат риску отката и искажает моделируемую прибыль вблизи публикаций новостей на этапе торговли на финансируемом счете. Мы реализуем derisking_factor — кусочно-линейную функцию уменьшения размера позиции в зависимости от прогресса этапа с нижней границей, определяемой выполнением требования к минимальному числу торговых дней, — и news_window_factor — ступенчатую функцию, действие которой зависит от этапа и которая применяет сокращение учитываемой прибыли по правилу распределения вознаграждения при торговле на новостях FundedNext в настраиваемом окне вокруг связанных событий. Обе функции возвращают множители с ограниченным диапазоном значений, которые перемножаются с другими модификаторами модуля расчета размера позиции.