От новичка до эксперта: Утилита для управления параметрами

MetaTrader 5 — Индикаторы | 14 ноября 2025, 08:58

311

Clemence Benjamin

Содержание:

Введение

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

Такая деталь бесценна для трейдера — например, то, что на старшем таймфрейме выглядит как простая тень свечи, при рассмотрении на младшем таймфрейме может выявить четкие паттерны, уровни поддержки и сопротивления или даже блоки ордеров. Понимание этой внутренней структуры рынка позволяет трейдерам лучше предвидеть будущее поведение цен и совершенствовать свои стратегии. На приведенном ниже рисунке 1, период A свечи H1 слева показывает уровень сопротивления в пределах ее бычьей тени — область отклонения, которая позже была протестирована и соблюдена периодом B справа. Это взаимодействие показывает, как прошлые зоны тени могут служить значимыми опорными точками для будущих ценовых реакций.

Analysis H1 and M1 timeframes

Рис. 1. Анализ периода H1 в M1 с помощью индикатора Marker Periods Synchronizer

Однако одной из проблем, которая часто возникает при разработке сложных инструментов, является отсутствие интуитивно понятных и легкодоступных элементов управления. Традиционно мы использовали вкладку Inputs ("Входные данные") советника или индикатора для настройки параметров — процесс, который может быстро стать утомительным при настройке нескольких значений или экспериментах с визуальными настройками.

В этом проекте мы решили эту проблему, создав утилиту управления в режиме реального времени - советника (EA), который преобразует статические входные параметры в интерактивные элементы управления на графике. Эта “утилита управления индикатором Market Period Synchronizer”) расширяет более раннюю концепцию индикатора, превращая его в динамическую информационную панель с расширенными функциями, обеспечивающую мгновенную обратную связь и более эффективный аналитический рабочий процесс.

Основные преимущества новой утилиты

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

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

Market Periods Synchronizer Control Utility

Рис. 2. Скриншот функций управления параметрами.

Реализация

Мы внедрим модульный советник, который преобразует статические входные данные в информационную панель на графике. Советник (1) считывает бары HTF (время, открытие, закрытие), (2) рисует фоновые визуальные элементы HTF (вертикальные линии, опциональные заливки тела, горизонтальные линии открытия/закрытия) и (3) отображает элементы управления во время выполнения с помощью полупрозрачного холста и объектов графика (кнопок, надписей, вертикальных ползунков, всплывающие и выпадающие списки). Пользовательский интерфейс обновляет переменные состояния во время выполнения (изменяемые копии входных данных), а функция RefreshLines() повторно использует эти значения для немедленного обновления объектов диаграммы. В дизайне приоритет отдается ясности (контейнер пользовательского интерфейса + метки), быстродействию (при перетаскивании ползунка обновления происходят немедленно) и невмешательству (HTF-объекты создаются с OBJPROP_BACK=true, поэтому пользовательский интерфейс остается интерактивным).

Основные рекомендации по реализации, которые читатели не должны пропустить:

Входные данные обрабатываются только как значения по умолчанию — информационная панель изменяет копии во время выполнения (с префиксом g_), поэтому взаимодействия с пользовательским интерфейсом сохраняются во время работы советника.
Ползунки расположены вертикально и снабжены двумя кнопками диаграммы: дорожкой (визуальной) и кнопкой (выбираемой) — при перетаскивании регулятора базовое значение обновляется в режиме реального времени.
Фигуры HTF рисуются в фоновом режиме (OBJPROP_BACK = true), чтобы избежать кражи событий мыши из пользовательского интерфейса.
Функция OnTick() проверяет только изменения времени (через iTime), чтобы избежать ненужных перерисовок.

1) Заголовок, включенные файлы (includes) и вводимые пользователем данные — цель и поведение

Начинаем с включения Canvas.mqh и объявления всех входных параметров. Строка #include <Canvas/Canvas.mqh> открывает небольшой вспомогательный класс пользовательского интерфейса (CCanvas), который мы используем для рисования полупрозрачного фонового растрового изображения для нашей информационной панели. Мы делаем это потому, что сами по себе объекты диаграммы (кнопки / метки) выглядят громоздко на разных темах диаграмм; холст представляет собой единый согласованный контейнер, который мы можем стилизовать один раз и использовать повторно. Обратите внимание, что файл Canvas.mqh должен присутствовать в поле include path — в противном случае советник не сможет скомпилироваться. Мы также используем #property strict, чтобы компилятор применял современные правила ввода типов и сигнатур MQL.

Блок ввода намеренно разделен на три практичные категории, чтобы пользователи сразу понимали, где искать и как инструмент соотносится с концепциями торговли. Первая категория — основные таймфреймы и визуальные эффекты — содержит таймфрейм, определяющий основные выделяемые бары (например, H1), глубину ретроспективного анализа (сколько баров HTF мы рисуем), цвет и ширину по умолчанию для основных вертикальных разделителей, а также интервал обновления в секундах. Эти настройки определяют основную структуру: основные бары - это фрейм, внутри которого все остальное (заливки, горизонтали открытия/закрытия и второстепенные линии) контекстуализировано. Ретроспективный анализ особенно важен, поскольку определяет, сколько объектов с большим периодом мы можем создать; большой ретроспективный анализ может привести к созданию большого количества объектов и замедлению работы графиков, поэтому мы рекомендуем разумные значения по умолчанию (200) и максимумы в рабочей сборке.

Вторая категория относится к маркерам открытия/закрытия и заливкам тела. Мы включили переключатели и цвета для горизонтальных маркеров открытия и закрытия (полезно видеть, где каждый HTF-бар открывался и закрывался относительно младшего таймфрейма), ширину и стиль линий для этих горизонталей, смещение в текущих TF-барах для управления протяженностью горизонтали, а также логические типы данных и цвета для заливки тела (бык/медведь). Они необязательны, но эффективны: заливки позволяют быстро увидеть бычьи и медвежьи тренды на барах HTF, в то время как строки открытия/закрытия помогают увидеть, где внутрибарная структура могла создать поддержку/сопротивление внутри тела бара HTF или теней свечей. В коде мы сохраняем их как входные значения по умолчанию (неизменяемые) и копируем в переменные времени выполнения, чтобы информационная панель могла переключать их в режиме реального времени.

Третья категория охватывает второстепенные периоды. Мы предоставляем две опции TF (Minor1, Minor2), каждый из которых имеет переключатель, выбор таймфрейма, цвет и ширину. Цель состоит в том, чтобы позволить нам визуализировать промежуточную структуру внутри HTF: например, на основном H1, второстепенном M15 может отображаться внутреннее деление. Советник рисует второстепенные вертикали только тогда, когда второстепенное время строго совпадает с двумя последовательными значениями основных периодов times (или находится в пределах текущего основного бара) — такое поведение повторяет исходную логику индикатора. Включив два отдельных второстепенных слоя, мы можем одновременно видеть погруженную структуру (например, H1 основной, M30 второстепенный, M15 микровторостепенный).

Важный архитектурный момент и часто встречающиеся подводные камни: входные параметры в MQL являются константами времени компиляции для среды выполнения - они не могут быть переназначены советником во время работы. Поэтому, чтобы обеспечить по-настоящему интерактивную информационную панель, мы копируем каждый ввод в соответствующую переменную g_ (global mutable) во время OnInit. Наш пользовательский код обновляет переменные g_ (например, g_WidthMajor или g_ShowFill), а функция RefreshLines() считывает эти значения g_ для немедленного обновления объектов диаграммы. Такое разделение позволяет избежать путаницы и позволяет рассматривать вводимые данные как безопасные значения по умолчанию, обеспечивая при этом полный контроль во время выполнения. Это также означает, что если пользователь хочет сохранять настройки в разных сеансах, мы должны добавить явную логику сохранения/загрузки — будущее усовершенствование.

Наконец, мы активно используем соглашения об именовании и префиксы, чтобы программа могла детерминированно управлять объектами диаграмм, обновлять их и собирать мусор. Такие префиксы, как HTF_MAJ_, HTF_MIN1_ и MPS_UI_, позволяют нам находить, обновлять или удалять только созданные нами объекты, не затрагивая другие рисунки, которые пользователь может иметь на диаграмме. Это небольшая, но важная инженерная деталь: без согласованного присвоения имен легко случайно удалить или перезаписать несвязанные объекты. Мы также сохраняем внутренний массив tf_list[] (набор разрешенных таймфреймов), чтобы выпадающие списки и логика циклирования были согласованными и локализованными.

#include <Canvas/Canvas.mqh>   // Canvas helper library (expects Canvas.mqh to be present)

// --------------------------- USER INPUTS ---------------------------
// Major timeframe + lookback + default visuals
input ENUM_TIMEFRAMES InpHigherTF      = PERIOD_H1;   // Major higher timeframe
input int            InpLookback       = 200;         // Lookback (bars)
input color          InpColorMajor     = clrRed;      // Major line color
input int            InpWidthMajor     = 2;           // Major line width
input int            InpRefreshSec     = 5;           // Refresh interval (seconds)

// Opru/Close marker settings
input bool           InpShowOpenClose  = true;        // show opru/close markers
input color          InpColorOpen      = clrGreen;
input color          InpColorClose     = clrLime;
input int            InpWidthOC        = 1;
input ENUM_LINE_STYLE InpStyleOC       = STYLE_DASH;
input int            InpHorizOffsetBars= 3;

// Body fill for majors
input bool           InpShowFill       = true;
input color          InpFillBull       = clrLime;
input color          InpFillBear       = clrPink;

// Minor periods
input bool           InpShowMinor1     = false;
input ENUM_TIMEFRAMES InpMinor1TF     = PERIOD_M30;
input color          InpColorMin1      = clrOrange;
input int            InpWidthMin1      = 1;

input bool           InpShowMinor2     = false;
input ENUM_TIMEFRAMES InpMinor2TF     = PERIOD_M15;
input color          InpColorMin2      = clrYellow;
input int            InpWidthMin2      = 1;

2) Глобальные переменные и копии среды выполнения — зачем разделять входные данные и состояние среды выполнения?

Мы объявляем массивы и переменные g_ для изменяемого состояния среды выполнения, цветовых палитр, инфраструктуры слайдеров и строк имен пользовательского интерфейса. Это разделение является ключевым: Операции пользовательского интерфейса записывают в значения g_*; функция RefreshLines() считывает их. Мы также готовим массивы, содержащие метаданные слайдера, чтобы каждый слайдер можно было создавать / обновлять в общем виде.

// --------------------------- GLOBALS -------------------------------
enum SliderIndex { SLIDER_MAJ_WIDTH = 0, SLIDER_REFRESH = 1 };
const int SLIDER_COUNT = 2;
int Y_OFFSET = 50; // top offset for UI container

// runtime (mutable) copies of inputs (dashboard will change these)
ENUM_TIMEFRAMES g_HigherTF;
int             g_Lookback;
color           g_ColorMajor;
int             g_WidthMajor;
int             g_RefreshSec;
// ... (other g_ variables for toggles & minors)

// slider infrastructure (vertical sliders)
string g_slider_track_names[];
string g_slider_knob_names[];
int    g_slider_min[];
int    g_slider_max[];
int    g_slider_left_x[];
int    g_slider_top_y[];
int    g_vslider_height_px = 110;
int    g_vslider_width_px  = 14;
int    g_slider_knob_w     = 12;
bool   g_slider_drag = false;
int    g_current_slider = -1;

3) Вспомогательные утилиты TF helper—согласованные метки и циклирование

Функция TFToString() централизует маркировку таймфреймов для кнопок и названий объектов (поэтому выпадающие списки и метки всегда совпадают). Функция FindNextTFIndex() реализует простой цикл для перехода к следующему таймфрейму в tf_list— полезный для быстрого циклического переключения кнопок.

string TFToString(ENUM_TIMEFRAMES tf)
  {
   switch(tf)
     {
      case PERIOD_M1:  return "M1";
      case PERIOD_M5:  return "M5";
      case PERIOD_M15: return "M15";
      case PERIOD_M30: return "M30";
      case PERIOD_H1:  return "H1";
      case PERIOD_H4:  return "H4";
      case PERIOD_D1:  return "D1";
      case PERIOD_W1:  return "W1";
      case PERIOD_MN1: return "MN";
     }
   return IntegerToString((int)tf);
  }

int FindNextTFIndex(ENUM_TIMEFRAMES current)
  {
   int n = ArraySize(tf_list);
   for(int i=0;i<n;i++) if(tf_list[i] == current) return (i+1)%n;
   return 0;
  }

4) OnInit() — подготавливает состояние среды выполнения, имена пользовательского интерфейса, холст и начальную отрисовку

OnInit - это этап согласования: скопируйте входные значения в g_*, вычислите время последнего бара для обнаружения изменений, создайте строки имен пользовательского интерфейса, подготовьте массивы слайдеров, создайте фон холста, создайте виджеты пользовательского интерфейса (кнопки, метки, цветные кнопки), создайте вертикальные ползунки и метки, а затем запустите таймер. Обратите внимание, как мы вызываем функцию RefreshLines() в конце, чтобы диаграмма сразу же заполнялась объектами HTF.

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

int OnInit()
  {
   main_chart_id = ChartID();

   // copy inputs -> runtime
   g_HigherTF        = InpHigherTF;
   g_Lookback        = MathMax(10, InpLookback);
   g_ColorMajor      = InpColorMajor;
   g_WidthMajor      = MathMax(1, InpWidthMajor);
   g_RefreshSec      = MathMax(1, InpRefreshSec);
   // ... (copy the rest of Inp->g_ variables)

   // initialize last bar times
   g_last_major_time = iTime(_Symbol, g_HigherTF, 0);
   if(g_ShowMinor1) g_last_minor1_time = iTime(_Symbol, g_Minor1TF, 0);
   if(g_ShowMinor2) g_last_minor2_time = iTime(_Symbol, g_Minor2TF, 0);

   // UI prefix and object names
   UI_PREFIX = StringFormat("MPS_UI_%d_", main_chart_id);
   lbl_title = UI_PREFIX + "LBL_TITLE";
   btn_major_tf = UI_PREFIX + "BTN_MAJ_TF";
   // ... (initialize other UI name strings)

   // prepare slider arrays
   ArrayResize(g_slider_track_names, SLIDER_COUNT);
   ArrayResize(g_slider_knob_names,  SLIDER_COUNT);
   ArrayResize(g_slider_min,        SLIDER_COUNT);
   ArrayResize(g_slider_max,        SLIDER_COUNT);
   ArrayResize(g_slider_left_x,     SLIDER_COUNT);
   ArrayResize(g_slider_top_y,      SLIDER_COUNT);
   for(int i=0;i<SLIDER_COUNT;i++)
     {
      g_slider_track_names[i] = UI_PREFIX + StringFormat("SL_TRK_%d", i);
      g_slider_knob_names[i]  = UI_PREFIX + StringFormat("SL_KNB_%d", i);
     }

   // background area coords and create UI
   g_bg_y = Y_OFFSET - 6;
   g_bg_h = 250;
   CreateUIBackground();
   CreateLabel(lbl_title, 12, 4 + Y_OFFSET, "Market Period Synchronizer Control Utility", 12);
   ObjectSetInteger(main_chart_id, lbl_title, OBJPROP_COLOR, XRGB(230,230,230));

   // create many UI buttons/labels and sliders...
   CreateButton(btn_major_tf, 12, 34 + Y_OFFSET, 70, 24, TFToString(g_HigherTF));
   CreateLabel(lbl_major_tf, 92, 36 + Y_OFFSET, "Major TF");
   // ... more buttons and color swatches

   // Major width slider (vertical)
   g_slider_left_x[SLIDER_MAJ_WIDTH] = 190;
   g_slider_top_y[SLIDER_MAJ_WIDTH]  = slider_base_top;
   g_slider_min[SLIDER_MAJ_WIDTH] = 1; g_slider_max[SLIDER_MAJ_WIDTH] = 10;
   CreateVerticalSliderAt(SLIDER_MAJ_WIDTH, g_slider_left_x[SLIDER_MAJ_WIDTH], g_slider_top_y[SLIDER_MAJ_WIDTH],
                          g_slider_track_names[SLIDER_MAJ_WIDTH], g_slider_knob_names[SLIDER_MAJ_WIDTH],
                          g_WidthMajor, g_slider_min[SLIDER_MAJ_WIDTH], g_slider_max[SLIDER_MAJ_WIDTH], g_vslider_height_px);

   // start events & timer
   ChartSetInteger(main_chart_id, CHART_EVENT_MOUSE_MOVE, true);
   EventSetTimer(g_RefreshSec);

   // initial drawing of HTF objects
   RefreshLines();

   return INIT_SUCCEEDED;
  }

5) Создание фона холста —визуальная группировка и поведение при нажатии

CreateUIBackground() использует вспомогательную программу CCanvas для создания графическаяой метки, которая действует как темная полупрозрачная панель за элементами пользовательского интерфейса. Важное проектное решение: мы установили для холста OBJPROP_BACK = false и OBJPROP_SELECTABLE = false, чтобы холст был виден, но не перекрывал клики — кнопки, нарисованные н переднем плане, по-прежнему получали команды от мыши.

Полированная темная панель улучшает разборчивость инструментов и тем графиков.

void CreateUIBackground()
  {
   g_bg_name = UI_PREFIX + "BG";
   ObjectDelete(main_chart_id, g_bg_name);

   bool ok = g_bgCanvas.CreateBitmapLabel(main_chart_id, 0, g_bg_name, g_bg_x, g_bg_y, g_bg_w, g_bg_h, COLOR_FORMAT_ARGB_RAW);
   if(!ok) { PrintFormat("CreateUIBackground: CreateBitmapLabel failed err=%d", GetLastError()); return; }

   uint dark_grey = ARGB(180, 30, 30, 30);
   uint border_col = XRGB(80, 80, 80);
   uint top_strip  = ARGB(210, 24, 24, 24);

   g_bgCanvas.FillRectangle(0, 0, g_bg_w - 1, g_bg_h - 1, dark_grey);
   g_bgCanvas.Rectangle(0, 0, g_bg_w - 1, g_bg_h - 1, border_col);
   g_bgCanvas.FillRectangle(0, 0, g_bg_w - 1, 28, top_strip);

   g_bgCanvas.Update(true);

   ObjectSetInteger(main_chart_id, g_bg_name, OBJPROP_BACK, false);
   ObjectSetInteger(main_chart_id, g_bg_name, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(main_chart_id, g_bg_name, OBJPROP_HIDDEN, false);
  }

6) Помощники по созданию пользовательского интерфейса — согласованный стиль кнопок и меток

CreateButton, CreateLabel и CreateColorButton централизуют создание пользовательского интерфейса, поэтому компоновка и стиль остаются согласованными. Кнопки создаются как выбираемые и отображаются на переднем плане (OBJPROP_BACK=false), метки не являются выбираемыми. Это обеспечивает предсказуемую модель событий и согласованный внешний вид.

void CreateButton(string name,int x,int y,int w,int h,string text)
  {
   if(StringLen(name) == 0) return;
   ObjectDelete(main_chart_id, name);
   if(!ObjectCreate(main_chart_id, name, OBJ_BUTTON, 0, 0, 0))
     { PrintFormat("CreateButton: failed to create %s err=%d", name, GetLastError()); return; }
   ObjectSetInteger(main_chart_id, name, OBJPROP_BACK, false);     // draw in front
   ObjectSetInteger(main_chart_id, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(main_chart_id, name, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(main_chart_id, name, OBJPROP_YDISTANCE, y);
   ObjectSetInteger(main_chart_id, name, OBJPROP_XSIZE, w);
   ObjectSetInteger(main_chart_id, name, OBJPROP_YSIZE, h);
   ObjectSetString(main_chart_id, name, OBJPROP_TEXT, text);
   ObjectSetInteger(main_chart_id, name, OBJPROP_FONTSIZE, 10);
   ObjectSetInteger(main_chart_id, name, OBJPROP_SELECTABLE, true);
   ObjectSetInteger(main_chart_id, name, OBJPROP_HIDDEN, false);
  }

void CreateLabel(string name,int x,int y,string text, int fontsize=9)
  {
   if(StringLen(name) == 0) return;
   ObjectDelete(main_chart_id, name);
   if(!ObjectCreate(main_chart_id, name, OBJ_LABEL, 0, 0, 0))
     { PrintFormat("CreateLabel: failed to create %s err=%d", name, GetLastError()); return; }
   ObjectSetInteger(main_chart_id, name, OBJPROP_BACK, false);
   ObjectSetInteger(main_chart_id, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(main_chart_id, name, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(main_chart_id, name, OBJPROP_YDISTANCE, y);
   ObjectSetString(main_chart_id, name, OBJPROP_TEXT, text);
   ObjectSetInteger(main_chart_id, name, OBJPROP_FONTSIZE, fontsize);
   ObjectSetInteger(main_chart_id, name, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(main_chart_id, name, OBJPROP_HIDDEN, false);
  }

void CreateColorButton(string name, int x, int y, int w, int h, color col)
  {
   CreateButton(name, x, y, w, h, "");
   ObjectSetInteger(main_chart_id, name, OBJPROP_BGCOLOR, col);
   ObjectSetInteger(main_chart_id, name, OBJPROP_FONTSIZE, 8);
  }

7) Вертикальные ползунки — архитектура и перетаскивание в реальном времени

Вертикальные ползунки состоят из невыбираемой дорожки (визуальная) и выбираемой ручки (кнопки). Функция CreateVerticalSliderAt() вычисляет положение кнопки из диапазона значений, сохраняет метаданные ползунка в массивах и размещает кнопку. Логика перетаскивания (обрабатываемая в OnChartEvent) использует CHARTEVENT_MOUSE_MOVE для установки кнопки Y, вычисления отношения и сопоставления его обратно с диапазоном значений. Когда ползунок меняется, код обновляет соответствующие переменные g_ (например, g_WidthMajor, g_RefreshSec) и немедленно вызывает функцию RefreshLines().

Координата Y инвертируется для отображения значений — top = максимальное значение.

void CreateVerticalSliderAt(int id, int base_x, int base_y, string track_name, string knob_name, int current_value, int min_val, int max_val, int track_height)
  {
   // track
   ObjectDelete(main_chart_id, track_name);
   if(!ObjectCreate(main_chart_id, track_name, OBJ_BUTTON, 0, 0, 0))
     { PrintFormat("CreateVerticalSliderAt: failed track %s err=%d", track_name, GetLastError()); }
   ObjectSetInteger(main_chart_id, track_name, OBJPROP_BACK, false);
   ObjectSetInteger(main_chart_id, track_name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(main_chart_id, track_name, OBJPROP_XDISTANCE, base_x);
   ObjectSetInteger(main_chart_id, track_name, OBJPROP_YDISTANCE, base_y);
   ObjectSetInteger(main_chart_id, track_name, OBJPROP_XSIZE, g_vslider_width_px);
   ObjectSetInteger(main_chart_id, track_name, OBJPROP_YSIZE, track_height);
   ObjectSetString(main_chart_id, track_name, OBJPROP_TEXT, "");
   ObjectSetInteger(main_chart_id, track_name, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(main_chart_id, track_name, OBJPROP_HIDDEN, false);

   // knob
   ObjectDelete(main_chart_id, knob_name);
   if(!ObjectCreate(main_chart_id, knob_name, OBJ_BUTTON, 0, 0, 0))
     { PrintFormat("CreateVerticalSliderAt: failed knob %s err=%d", knob_name, GetLastError()); }
   ObjectSetInteger(main_chart_id, knob_name, OBJPROP_BACK, false);
   ObjectSetInteger(main_chart_id, knob_name, OBJPROP_CORNER, CORNER_LEFT_UPPER);

   double ratio = 0.0;
   if(max_val > min_val) ratio = double(current_value - min_val) / double(max_val - min_val);
   int knob_y = base_y + (int)MathRound((1.0 - ratio) * (track_height - g_slider_knob_w));
   int knob_x = base_x - (g_slider_knob_w/2) + (g_vslider_width_px/2);

   ObjectSetInteger(main_chart_id, knob_name, OBJPROP_XDISTANCE, knob_x);
   ObjectSetInteger(main_chart_id, knob_name, OBJPROP_YDISTANCE, knob_y);
   ObjectSetInteger(main_chart_id, knob_name, OBJPROP_XSIZE, g_slider_knob_w);
   ObjectSetInteger(main_chart_id, knob_name, OBJPROP_YSIZE, g_slider_knob_w);
   ObjectSetString(main_chart_id, knob_name, OBJPROP_TEXT, "");
   ObjectSetInteger(main_chart_id, knob_name, OBJPROP_SELECTABLE, true);
   ObjectSetInteger(main_chart_id, knob_name, OBJPROP_HIDDEN, false);
   ObjectSetInteger(main_chart_id, knob_name, OBJPROP_FONTSIZE, 1);

   // store slider params
   g_slider_min[id] = min_val;
   g_slider_max[id] = max_val;
   g_slider_left_x[id] = base_x;
   g_slider_top_y[id] = base_y;
  }

8) Обновление метки ползунка — синхронизация пользовательского интерфейса

Функция UpdateLabelsAfterSliderChange() обновляет текстовые метки под ползунками при каждом изменении значения, сохраняя согласованность визуальной информации.

void UpdateLabelsAfterSliderChange()
  {
   if(ObjectFind(main_chart_id, lbl_major_width) >= 0)
      ObjectSetString(main_chart_id, lbl_major_width, OBJPROP_TEXT, StringFormat("Maj W:%d", g_WidthMajor));
      

   if(ObjectFind(main_chart_id, lbl_refresh_label) >= 0)
      ObjectSetString(main_chart_id, lbl_refresh_label, OBJPROP_TEXT, StringFormat("Refresh:%ds", g_RefreshSec));
      
  }

9) Логика выпадающего списка TF — небольшие, надежные всплывающие списки

Функция ShowTFDropdownFor() создает набор маленьких кнопок непосредственно под запрошенной кнопкой TF (major / minor1 / minor2). HideTFDropdown() удаляет их. В выпадающем списке используется составной префикс, поэтому события выбора можно легко анализировать в OnChartEvent.

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

void ShowTFDropdownFor(int target)
  {
   if(g_tf_dropdown_visible && g_tf_dropdown_target == target) { HideTFDropdown(); return; }
   if(g_tf_dropdown_visible) HideTFDropdown();

   string target_btn = (target == 0 ? btn_major_tf : (target == 1 ? btn_minor1_tf : btn_minor2_tf));
   if(ObjectFind(main_chart_id, target_btn) < 0) return;

   int bx = (int)ObjectGetInteger(main_chart_id, target_btn, OBJPROP_XDISTANCE);
   int by = (int)ObjectGetInteger(main_chart_id, target_btn, OBJPROP_YDISTANCE);
   int bh = (int)ObjectGetInteger(main_chart_id, target_btn, OBJPROP_YSIZE);

   int base_x = bx;
   int base_y = by + bh + 4;
   int w = 60;
   int h = 20;
   for(int i=0;i<ArraySize(tf_list);i++)
     {
      string oname = TF_DROPDOWN_PREFIX + IntegerToString(target) + "_" + IntegerToString(i);
      CreateButton(oname, base_x, base_y + i*(h+2), w, h, TFToString(tf_list[i]));
     }
   g_tf_dropdown_visible = true;
   g_tf_dropdown_target = target;
  }

void HideTFDropdown()
  {
   if(!g_tf_dropdown_visible) return;
   for(int i=0; i<ArraySize(tf_list); i++)
     {
      string oname = TF_DROPDOWN_PREFIX + IntegerToString(g_tf_dropdown_target) + "_" + IntegerToString(i);
      ObjectDelete(main_chart_id, oname);
     }
   g_tf_dropdown_visible = false;
   g_tf_dropdown_target = -1;
  }

10) OnChartEvent()—модель события и обработка перетаскивания

Это и есть мозг взаимодействия. Она обрабатывает:

Запуск и остановка перетаскивания кнопки (с помощью щелчков по кнопке начинается перетаскивание; любой последующий щелчок по объекту завершает его).
Перемещение мыши при перетаскивании: вычисляет положение кнопки в пикселях, преобразовывает в числовое значение, обновляет переменную g_ и вызывает функцию RefreshLines() в случае изменения.
Щелчки по кнопкам: переключение, кнопки ретроспективного просмотра + /-, выбор цвета, отображение / скрытие выпадающего списка TF.
Выбор из выпадающего списка TF: анализирует название нажатой кнопки и применяет выбранный таймфрейм к major/minor соответственно, затем перерисовывает.
Выбор дизайна: остановка перетаскивания при любом щелчке по объекту - это простой кроссплатформенный паттерн, который позволяет избежать необходимости обнаруживать глобальные события нажатия кнопки мыши (которые не всегда доступны в виде выделенного события для диаграмм в MQL5).

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
  {
   // stop dragging if an object click happens
   if(id == CHARTEVENT_OBJECT_CLICK && g_slider_drag)
     {
      g_slider_drag = false;
      g_current_slider = -1;
      return;
     }

   // dragging motion: use mouse Y from dparam
   if(id == CHARTEVENT_MOUSE_MOVE && g_slider_drag && g_current_slider >= 0)
     {
      int my = (int)dparam;
      int s = g_current_slider;
      string track_name = g_slider_track_names[s];
      string knob_name  = g_slider_knob_names[s];

      int track_top = (int)ObjectGetInteger(main_chart_id, track_name, OBJPROP_YDISTANCE);
      int track_h   = (int)ObjectGetInteger(main_chart_id, track_name, OBJPROP_YSIZE);
      int track_bottom = track_top + track_h - g_slider_knob_w;

      int new_knob_y = my;
      if(new_knob_y < track_top) new_knob_y = track_top;
      if(new_knob_y > track_bottom) new_knob_y = track_bottom;

      ObjectSetInteger(main_chart_id, knob_name, OBJPROP_YDISTANCE, new_knob_y);

      double ratio = 1.0 - double(new_knob_y - track_top) / double(track_h - g_slider_knob_w);
      int new_val = g_slider_min[s] + (int)MathRound(ratio * (g_slider_max[s] - g_slider_min[s]));
      if(new_val < g_slider_min[s]) new_val = g_slider_min[s];
      if(new_val > g_slider_max[s]) new_val = g_slider_max[s];

      bool changed = false;
      if(s == SLIDER_MAJ_WIDTH)
        { if(g_WidthMajor != new_val) { g_WidthMajor = new_val; changed = true; } }
      else if(s == SLIDER_REFRESH)
        { if(g_RefreshSec != new_val) { g_RefreshSec = new_val; EventSetTimer(g_RefreshSec); changed = true; } }

      if(changed) { UpdateLabelsAfterSliderChange(); RefreshLines(); }
      return;
     }

   // TF dropdown option clicked
   if(StringFind(sparam, TF_DROPDOWN_PREFIX) == 0 && id == CHARTEVENT_OBJECT_CLICK)
     {
      string rest = StringSubstr(sparam, StringLen(TF_DROPDOWN_PREFIX));
      int sep = StringFind(rest, "_");
      if(sep >= 0)
        {
         int target = (int)StringToInteger(StringSubstr(rest, 0, sep));
         int idx    = (int)StringToInteger(StringSubstr(rest, sep+1));
         if(idx >= 0 && idx < ArraySize(tf_list))
           {
            ENUM_TIMEFRAMES chosen = tf_list[idx];
            if(target == 0) { g_HigherTF = chosen; g_last_major_time = iTime(_Symbol, g_HigherTF, 0); ObjectSetString(main_chart_id, btn_major_tf, OBJPROP_TEXT, TFToString(g_HigherTF)); }
            else if(target == 1) { g_Minor1TF = chosen; if(g_ShowMinor1) g_last_minor1_time = iTime(_Symbol, g_Minor1TF, 0); ObjectSetString(main_chart_id, btn_minor1_tf, OBJPROP_TEXT, TFToString(g_Minor1TF)); }
            else if(target == 2) { g_Minor2TF = chosen; if(g_ShowMinor2) g_last_minor2_time = iTime(_Symbol, g_Minor2TF, 0); ObjectSetString(main_chart_id, btn_minor2_tf, OBJPROP_TEXT, TFToString(g_Minor2TF)); }
            HideTFDropdown();
            RefreshLines();
           }
        }
      return;
     }

   // If dropdown visible and user clicked elsewhere => hide
   if(g_tf_dropdown_visible && id == CHARTEVENT_OBJECT_CLICK && StringFind(sparam, TF_DROPDOWN_PREFIX) != 0)
     {
      HideTFDropdown();
     }

   // Handle other button clicks & knob starts...
   if(id == CHARTEVENT_OBJECT_CLICK)
     {
      string obj = sparam;
      if(obj == btn_major_tf) { ShowTFDropdownFor(0); return; }
      if(obj == btn_lookback_minus) { g_Lookback = MathMax(10, g_Lookback - 10); ObjectSetString(main_chart_id, lbl_lookback, OBJPROP_TEXT, StringFormat("Lookback:%d", g_Lookback)); RefreshLines(); return; }
      if(obj == btn_lookback_plus)  { g_Lookback += 10; ObjectSetString(main_chart_id, lbl_lookback, OBJPROP_TEXT, StringFormat("Lookback:%d", g_Lookback)); RefreshLines(); return; }
      if(obj == btn_toggle_openclose) { g_ShowOpenClose = !g_ShowOpenClose; ObjectSetString(main_chart_id, btn_toggle_openclose, OBJPROP_TEXT, g_ShowOpenClose ? "Opru/Close: ON" : "Opru/Close: OFF"); RefreshLines(); return; }
      if(obj == btn_toggle_fill)      { g_ShowFill = !g_ShowFill; ObjectSetString(main_chart_id, btn_toggle_fill, OBJPROP_TEXT, g_ShowFill ? "Fill: ON" : "Fill: OFF"); RefreshLines(); return; }

      // major colors
      if(obj == btn_major_col1) { g_ColorMajor = major_colors[0]; RefreshLines(); return; }
      // ... other colors

      // minors toggles / tf dropdown
      if(obj == btn_minor1_toggle) { g_ShowMinor1 = !g_ShowMinor1; if(g_ShowMinor1) g_last_minor1_time = iTime(_Symbol, g_Minor1TF, 0); ObjectSetString(main_chart_id, btn_minor1_toggle, OBJPROP_TEXT, g_ShowMinor1 ? "Min1: ON" : "Min1: OFF"); RefreshLines(); return; }
      if(obj == btn_minor1_tf)     { ShowTFDropdownFor(1); return; }

      if(obj == btn_minor2_toggle) { g_ShowMinor2 = !g_ShowMinor2; if(g_ShowMinor2) g_last_minor2_time = iTime(_Symbol, g_Minor2TF, 0); ObjectSetString(main_chart_id, btn_minor2_toggle, OBJPROP_TEXT, g_ShowMinor2 ? "Min2: ON" : "Min2: OFF"); RefreshLines(); return; }
      if(obj == btn_minor2_tf)     { ShowTFDropdownFor(2); return; }

      if(obj == btn_clear_all) { DeleteAllHTFLines(); return; }

      // slider knob clicked -> begin dragging
      for(int s=0; s<SLIDER_COUNT; s++)
        { if(obj == g_slider_knob_names[s]) { g_current_slider = s; g_slider_drag = true; return; } }
     }
  }

11) OnTick() и OnTimer()—эффективные триггеры обновления

OnTick() проверяет последнее значение iTime для настроенных старшего и младшего таймфреймов и устанавливает значение need_refresh только при появлении нового бара — это предотвращает ненужный отток объектов. Функция OnTimer() просто вызывает RefreshLines() на интервале g_RefreshSec (который ползунок может изменять в режиме реального времени).

Быстрые, но не расточительные обновления; изменения, связанные с пользовательским интерфейсом (например, переключение заливки), немедленно вызовут функцию RefreshLines(), в то время как периодические проверки обрабатывают случаи появления новых баров HTF.

void OnTimer()
  {
   RefreshLines();
  }

void OnTick()
  {
   bool need_refresh = false;
   datetime curr;

   curr = iTime(_Symbol, g_HigherTF, 0);
   if(curr != g_last_major_time && curr != 0) { g_last_major_time = curr; need_refresh = true; }

   if(g_ShowMinor1)
     {
      curr = iTime(_Symbol, g_Minor1TF, 0);
      if(curr != g_last_minor1_time && curr != 0) { g_last_minor1_time = curr; need_refresh = true; }
     }

   if(g_ShowMinor2)
     {
      curr = iTime(_Symbol, g_Minor2TF, 0);
      if(curr != g_last_minor2_time && curr != 0) { g_last_minor2_time = curr; need_refresh = true; }
     }

   if(need_refresh) RefreshLines();
  }

12) RefreshLines()—отрисовка ядра и сбор мусора

Это основная подпрограмма. Она:

Копирует HTF времени, открытия и закрытия для запрошенного ретроспективного анализа.
Изменяет массивы в порядок возрастания для простого сравнения интервалов.
Для каждого основного времени создает или обновляет вертикальную линию, необязательный прямоугольник заливки, горизонтали открытия/закрытия и метки.
Для второстепенных объектов вызывается функция DrawMinorsBetweenIntervals(), которая рисует второстепенные вертикали только в том случае, если они строго находятся между последовательными основными объектами (плюс текущий интервал).
Создает keepNames[] со списком всех нужных HTF-объектов; в конце он перебирает все объекты диаграммы и удаляет все HTF-объекты, которых нет в keepNames[] (сборка мусора).

При каждом проходе мы обновляем свойства существующих объектов (цвет, ширину и т.д.), поэтому изменения пользовательского интерфейса вступают в силу немедленно, без необходимости удалять / пересоздавать все заново.

void RefreshLines()
  {
   datetime major_times[]; ArrayFree(major_times);
   double major_opens[]; ArrayFree(major_opens);
   double major_closes[]; ArrayFree(major_closes);

   int copiedMaj = CopyTime(_Symbol, g_HigherTF, 0, g_Lookback, major_times);
   if(copiedMaj <= 0) { PrintFormat("RefreshLines: CopyTime majors returned %d for %s", copiedMaj, TFToString(g_HigherTF)); return; }
   if(CopyOpen(_Symbol, g_HigherTF, 0, copiedMaj, major_opens) != copiedMaj) { Print("RefreshLines: CopyOpen failed"); return; }
   if(CopyClose(_Symbol, g_HigherTF, 0, copiedMaj, major_closes) != copiedMaj) { Print("RefreshLines: CopyClose failed"); return; }

   // reverse to ascending order (oldest first)
   int n = copiedMaj;
   datetime sorted_times[]; ArrayResize(sorted_times, n);
   double sorted_opens[]; ArrayResize(sorted_opens, n);
   double sorted_closes[]; ArrayResize(sorted_closes, n);
   for(int k = 0; k < n; k++)
     {
      sorted_times[k]  = major_times[n - 1 - k];
      sorted_opens[k]  = major_opens[n - 1 - k];
      sorted_closes[k] = major_closes[n - 1 - k];
     }

   string keepNames[]; ArrayResize(keepNames, 0);

   // create/update major objects
   for(int i = 0; i < n; ++i)
     {
      datetime t = sorted_times[i];
      double p_open = sorted_opens[i];
      double p_close = sorted_closes[i];

      // Major vertical
      string name = PREFIX_MAJ + TFToString(g_HigherTF) + "_" + IntegerToString((int)t);
      if(ObjectFind(0, name) == -1)
        {
         double dummy_price = 0.0;
         if(!ObjectCreate(0, name, OBJ_VLINE, 0, t, dummy_price))
            PrintFormat("Failed to create major %s error %d", name, GetLastError());
        }
      // update props each pass so UI changes apply immediately
      ObjectSetInteger(0, name, OBJPROP_COLOR, g_ColorMajor);
      ObjectSetInteger(0, name, OBJPROP_WIDTH, g_WidthMajor);
      ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, name, OBJPROP_HIDDEN, false);
      ObjectSetInteger(0, name, OBJPROP_BACK, true); // draw in background

      int sz = ArraySize(keepNames); ArrayResize(keepNames, sz + 1); keepNames[sz] = name;

      // Optional fill / open-close code follows (omitted for brevity)
     }

   if(n >= 2)
     {
      if(g_ShowMinor1) DrawMinorsBetweenIntervals(PREFIX_MIN1, g_Minor1TF, g_ColorMin1, g_WidthMin1, sorted_times, keepNames);
      if(g_ShowMinor2) DrawMinorsBetweenIntervals(PREFIX_MIN2, g_Minor2TF, g_ColorMin2, g_WidthMin2, sorted_times, keepNames);
     }

   // cleanup old HTF objects not in keepNames
   int total = ObjectsTotal(0);
   for(int idx = total - 1; idx >= 0; --idx)
     {
      string oname = ObjectName(0, idx);
      if(StringFind(oname, "HTF_") != -1)
        {
         bool found = false;
         for(int k=0;k<ArraySize(keepNames);k++) if(oname == keepNames[k]) { found = true; break; }
         if(!found) ObjectDelete(0, oname);
        }
     }
   UpdateLabelsAfterSliderChange();
   ChartRedraw(main_chart_id);
  }

13) DrawMinorsBetweenIntervals()—точная логика размещения второстепенных объектов

Эта функция вычисляет, сколько второстепенных баров требуется запросить (на основе промежутка времени между первым основным и текущим), копирует значение times второстепенных объектов, меняет порядок возрастания и размещает вертикальные второстепенные линии только тогда, когда значение time второстепенного объекта находится строго между последовательными значениями основных объектов — это отражает поведение индикатора. Она также учитывает второстепенные значения, которые попадают в текущий основной интервал (после последнего основного времени).

Проектное пояснение: мы добавляем поле (+20) к approx_bars, чтобы обеспечить устойчивость к выравниванию; мы также, по крайней мере, запрашиваем бары g_Lookback.

void DrawMinorsBetweenIntervals(const string prefix,
                                const ENUM_TIMEFRAMES minorTF,
                                const color c,
                                const int width,
                                const datetime &major_times[],
                                string &keepNames[])
  {
   datetime current_minor_time = iTime(_Symbol, minorTF, 0);
   if(current_minor_time == 0) return;
   int time_span = (int)(current_minor_time - major_times[0]);
   int minor_sec = PeriodSeconds(minorTF);
   int approx_bars = (time_span / minor_sec) + 20;
   if(approx_bars < g_Lookback) approx_bars = g_Lookback;

   datetime minor_times[]; ArrayFree(minor_times);
   int copiedMin = CopyTime(_Symbol, minorTF, 0, approx_bars, minor_times);
   PrintFormat("DrawMinorsBetweenIntervals: TF=%s copiedMin=%d majors=%d", TFToString(minorTF), copiedMin, ArraySize(major_times));
   if(copiedMin <= 0) return;

   datetime sorted_minor_times[]; ArrayResize(sorted_minor_times, copiedMin);
   for(int k = 0; k < copiedMin; k++) sorted_minor_times[k] = minor_times[copiedMin - 1 - k];

   int num_maj = ArraySize(major_times);
   for(int m = 0; m < copiedMin; ++m)
     {
      datetime mt = sorted_minor_times[m];
      bool equals_major = false;
      for(int kk = 0; kk < num_maj; ++kk) if(major_times[kk] == mt) { equals_major = true; break; }
      if(equals_major) continue;

      bool placed = false;
      for(int j = 0; j < num_maj - 1; ++j)
        {
         if( major_times[j] < mt && mt < major_times[j+1] )
           {
            string name = prefix + TFToString(minorTF) + "_" + IntegerToString((int)mt);
            if(ObjectFind(0, name) == -1)
              {
               double dummy_price = 0.0;
               if(!ObjectCreate(0, name, OBJ_VLINE, 0, mt, dummy_price))
                 PrintFormat("Failed to create minor %s error %d", name, GetLastError());
               else
                 {
                  ObjectSetInteger(0, name, OBJPROP_COLOR, c);
                  ObjectSetInteger(0, name, OBJPROP_WIDTH, width);
                  ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_DOT);
                  ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
                  ObjectSetInteger(0, name, OBJPROP_HIDDEN, false);
                  ObjectSetInteger(0, name, OBJPROP_BACK, true);
                 }
              }
            int sz = ArraySize(keepNames); ArrayResize(keepNames, sz + 1); keepNames[sz] = name;
            placed = true;
            break;
           }
        }
      if(!placed && mt > major_times[num_maj - 1])
        {
         // create a minor in the ongoing major interval
         string name = prefix + TFToString(minorTF) + "_" + IntegerToString((int)mt);
         if(ObjectFind(0, name) == -1)
           {
            double dummy_price = 0.0;
            if(!ObjectCreate(0, name, OBJ_VLINE, 0, mt, dummy_price))
              PrintFormat("Failed to create minor (current) %s error %d", name, GetLastError());
            else
              {
               ObjectSetInteger(0, name, OBJPROP_COLOR, c);
               ObjectSetInteger(0, name, OBJPROP_WIDTH, width);
               ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_DOT);
               ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
               ObjectSetInteger(0, name, OBJPROP_HIDDEN, false);
               ObjectSetInteger(0, name, OBJPROP_BACK, true);
              }
           }
         int sz = ArraySize(keepNames); ArrayResize(keepNames, sz + 1); keepNames[sz] = name;
         placed = true;
        }
     }
   ChartRedraw(main_chart_id);
  }

14) Удаление и очистка — DeleteAllHTFLines() и OnDeinit()

DeleteAllHTFLines() удаляет только HTF-объекты; OnDeinit() удаляет объекты пользовательского интерфейса и компоненты ползунков, скрывает выпадающие списки и уничтожает холст. Мы намеренно не удаляем объекты HTF по умолчанию при отключении (за исключением случаев, когда нажата кнопка Clear HTF (Очистить HTF)), чтобы пользователь мог сохранить отрисовки, если пожелает.

void DeleteAllHTFLines()
  {
   int total = ObjectsTotal(0);
   for(int idx = total - 1; idx >= 0; --idx)
     {
      string oname = ObjectName(0, idx);
      if(StringFind(oname, "HTF_") != -1)
         ObjectDelete(0, oname);
     }
  }

void OnDeinit(const int reason)
  {
   EventKillTimer();

   string names[] = {
     lbl_title, btn_major_tf, lbl_major_tf, btn_lookback_minus, lbl_lookback, btn_lookback_plus,
     btn_toggle_openclose, btn_toggle_fill, btn_major_col1, btn_major_col2, btn_major_col3, btn_major_col4,
     btn_minor1_toggle, btn_minor1_tf, btn_minor2_toggle, btn_minor2_tf,
     btn_clear_all, lbl_major_width, lbl_refresh_label
   };
   for(int i=0;i<ArraySize(names);i++) if(StringLen(names[i])>0) ObjectDelete(main_chart_id, names[i]);

   for(int s=0; s<SLIDER_COUNT; s++)
     {
      if(StringLen(g_slider_track_names[s])>0) ObjectDelete(main_chart_id, g_slider_track_names[s]);
      if(StringLen(g_slider_knob_names[s])>0)  ObjectDelete(main_chart_id, g_slider_knob_names[s]);
     }

   if(g_tf_dropdown_visible) HideTFDropdown();

   // destroy canvas
   g_bgCanvas.Destroy();
  }

Тестирование

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

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

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

Рис. 3. Тестирование элементов управления на живом графике

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

Заключение

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

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

Утилита управления Market Periods Synchronizer развивает эту философию еще больше, позволяя трейдерам наблюдать, как поведение младших таймфреймов влияет на структуру старших таймфреймов. Это придает глубину анализу на нескольких таймфреймах, позволяя пользователям изучать сердцебиение рынка в разных масштабах и лучше понимать, как незначительные колебания цен влияют на общую форму основных свечей. По сути, это поощряет более научный подход к интерпретации ценовых изменений - видеть не только то, что произошло, но и почему и как это сформировалось.

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

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

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

Основные уроки

Урок	Описание
1. Управление в режиме реального времени возможно.	Благодаря структурированной обработке событий и обновлениям объектов можно создавать интерфейсы, которые мгновенно реагируют на вводимые пользователем данные, обеспечивая немедленную обратную связь и визуальные обновления на графике.
2. CCanvas открывает возможности для визуального творчества	Класс Canvas предоставляет возможность создавать профессиональные и визуально привлекательные информационные панели. Он позволяет создавать фоновый рисунок, прозрачность и многослойность для улучшения взаимодействия с пользователем.
3. Оперативность пользовательского интерфейса зависит от управления объектами.	Надлежащая обработка создания, обновления и удаления объектов графика обеспечивает бесперебойную работу и предотвращает появление помех или задержек при обновлении в режиме реального времени.
4. Динамические параметры улучшают проведение экспериментов:	Позволяя трейдерам настраивать такие параметры, как таймфреймы, цвета и ширина, не открывая повторно окно свойств, вы повышаете эффективность экспериментов и анализа.
5. Синхронизация по нескольким таймфреймам добавляет глубины.	Объединение данных о старших и младших таймфреймах визуально помогает трейдерам понять внутреннюю структуру рынка, идентифицировать микродвижения и связать более мелкие тренды с более крупными образованиями.
6. Дизайн, основанный на событиях, занимает центральное место в интерактивных инструментах.	Построение интерактивных систем требует глубокого понимания процесса обработки событий на графике. Каждое действие пользователя должно быть сопоставлено с определенной реакцией программы для обеспечения интуитивного управления.
7. Лейеринг объектов повышает удобство использования.	Тщательно настраивая свойства фона и переднего плана, можно гарантировать, что интерфейс остается интерактивным, а объекты никогда не блокируют основные взаимодействия пользователя.
8. Модульный код повышает удобство обслуживания.	Разделение проекта на логические разделы, такие как создание пользовательского интерфейса, обработка событий и функции рисования, упрощает расширение, отладку и повторное использование системы в будущих проектах.
9. Инструменты визуализации для тестирования и отладки.	Визуальное тестирование в режиме реального времени выявило такие проблемы, как не обновляющиеся объекты и конфликты наложения, научив нас систематическим методам отладки с использованием журналов и отслеживания событий.
10. Оптимизация интервалов обновления и рисования.	Мы узнали, как настройка таймеров обновления и стратегий перерисовки может повысить производительность и оперативность реагирования, особенно при обновлении графиков в режиме реального времени.
11. Визуальная обратная связь повышает аналитическую достоверность.	Визуальная корректировка в режиме реального времени помогает трейдерам мгновенно увидеть причину и следствие, укрепляя уверенность в точности и интерпретации графических данных.
12. Эксперименты стимулируют инновации.	Этот проект доказывает, что изучение нетрадиционных подходов в MQL5 приводит к появлению новых инструментов и идей. Творческий подход в сочетании с техническим пониманием способствует прогрессу всего сообщества.

Вложения

Имя файла	Версия	Описание
MarketPeriodsSynchronizer_EA.mq5	1.00	Этот советник предоставляет информационную панель в режиме реального времени для синхронизации и визуализации нескольких периодов таймфреймов непосредственно на графике. Он расширяет функциональность оригинального индикатора Market Periods Synchronizer за счет интеграции интерактивных элементов управления, ползунков и переключателей для мгновенной настройки параметров без повторного открытия входных настроек.

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

Прикрепленные файлы |

Загрузить ZIP

MarketPeriodsSynchronizer_EA.mq5 (88.57 KB)

Предупреждение: все права на данные материалы принадлежат MetaQuotes Ltd. Полная или частичная перепечатка запрещена.

Данная статья написана пользователем сайта и отражает его личную точку зрения. Компания MetaQuotes Ltd не несет ответственности за достоверность представленной информации, а также за возможные последствия использования описанных решений, стратегий или рекомендаций.

Другие статьи автора

Перейти к обсуждению на форуме трейдеров

Нейросети в трейдинге: Рекуррентное моделирование микродвижений рынка (Энкодер)

Эта статья погружает читателя в самую суть фреймворка EV-MGRFlowNet, показывая, как его архитектура раскрывается в прикладной реализации под задачи финансового прогнозирования. Мы шаг за шагом строим продуманную связку модулей, способную улавливать тонкие временные закономерности и переводить их в осмысленные рыночные сигналы.

Моделирование рынка (Часть 11): Сокеты (V)

Мы приступаем к реализации связи между Excel и MetaTrader 5, но сначала необходимо понять некоторые важные моменты, так вам не придется ломать голову, пытаясь понять, почему что-то работает или нет. И прежде, чем вы нахмуритесь, глядя на интеграцию Python и Excel, давайте посмотрим, как с помощью xlwings можно (в некоторой степени) управлять MetaTrader 5 через Excel. То, что мы покажем здесь, будет в основном сконцентрировано на образовательных задачах. Но не думайте, что мы можем делать только то, что будет рассмотрено здесь.

Автоматизация запуска терминала для выполнения сервисных задач

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

Разработка динамического советника на нескольких парах (Часть 4): Корректировка риска на основе волатильности

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