Торговые инструменты MQL5 (Часть 38): Добавление окна настроек с вкладками для редактирования свойств объектов
Введение
В предыдущей статье (часть 37) мы добавили плавающую ленту для быстрого редактирования свойств. Лента позволяет быстро вносить типичные изменения, но предоставляет доступ лишь к отдельным свойствам. Чтобы работать со всем спектром настроек, нам нужен более функциональный редактор с вкладками. В этой статье рассказывается об этом обновлении.
Мы добавляем окно настроек с вкладками, размещая его реализацию в двух новых файлах. Окно открывается кнопкой "Настройки" на ленте и привязывается к выбранному объекту. В окне доступны четыре вкладки — "Стиль", "Текст", "Координаты" и "Видимость", — работающие на основе той же системы дескрипторов, что и лента. Кроме того, окно поддерживает прокрутку, разворачивает списки уровней в отдельные строки для каждого уровня, позволяет вводить точные значения цены и времени для опорных точек, а также при необходимости повторно использует всплывающие панели ленты для выбора цвета, ширины и стиля.
Эта статья предназначена для разработчиков на языке MetaQuotes Language 5 (MQL5) среднего и продвинутого уровня, хорошо знакомых с цепочкой наследования и системой дескрипторов свойств, созданными в предыдущих частях. Мы рассмотрим следующие темы:
- От ленты быстрого доступа к полноценному окну настроек
- Компоновка и отрисовка окна настроек
- Реализация взаимодействия с окном настроек
- Визуализация
- Заключение
В итоге мы сможем выбрать любой объект, открыть окно его настроек и редактировать все свойства, доступные в инструменте, в одном месте — переключаться между вкладками, прокручивать строки, изменять коэффициенты и цвета для каждого уровня, вводить точные координаты, а также подтверждать или отменять все внесённые изменения при закрытии окна.
От ленты быстрого доступа к полноценному окну настроек
Лента и окно настроек решают одну и ту же задачу в разных масштабах, поэтому вместо создания второго редактора с нуля мы строим окно на основе всего, что уже реализовано для ленты. И лента, и окно читают один и тот же список дескрипторов для каждого инструмента, используют один и тот же 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. Мы следовали принятым в нём правилам. См. ниже.

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

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

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

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