Знакомство с языком MQL5 (Часть 34): Освоение API и функции WebRequest в языке MQL5 (VIII)

Введение

И снова приветствуем вас в Части 34 серии "Знакомство с языком MQL5"! В предыдущей статье мы сосредоточились на основах отправки API-запросов из MetaTrader 5 в Google Generative AI. Мы рассмотрели структуру запросов, то, как принимаются ответы, и то, как работает функция WebRequest. На том этапе мы не взаимодействовали с графиком напрямую; вся связь с ИИ происходила в коде. 

В этой статье мы разработаем панель управления прямо на графике MetaTrader 5 – это практичный шаг вперед. Эта панель позволит пользователям вводить запрос, отправлять его на обработку ИИ и просматривать результат прямо в терминале. Поскольку в этой серии мы еще не разбирали графические панели в MQL5, мы рассмотрим базовые понятия, необходимые для их создания и управления ими. Однако мы не будем подробно рассматривать разработку графического интерфейса. Мы обсудим только те возможности панели, которые нужны для этого проекта, потому что статья по-прежнему в первую очередь посвящена API и функции WebRequest в языке MQL5.

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

Создание панелей управления в MQL5

В этой части мы не будем разбирать все аспекты графического интерфейса в MQL5. Цель этой статьи – не сделать вас экспертом по пользовательским интерфейсам; она по-прежнему сосредоточена на API и функции WebRequest. Однако, поскольку серия построена вокруг проектов, и раньше мы не использовали графические панели, важно изложить базовые идеи, которые понадобятся для выполнения этого проекта. Мы сосредоточимся только на тех элементах, которые нужны для простой и полезной панели управления, и не будем разбирать весь набор графических элементов управления в MQL5. Это означает: создать панель на графике, разместить базовые элементы – кнопки, поля ввода и текстовые метки – и понять, как все это связано с вашим кодом. Так вы не утонете в ненужных деталях – мы ограничимся только необходимым.

В MQL5 панель управления – это графический интерфейс, который появляется прямо на графике MetaTrader 5 и позволяет пользователю визуально взаимодействовать с советником. Панель управления позволяет отправлять команды, вводить текст и получать обратную связь в реальном времени, а не полагаться только на входные параметры. Инструмент становится более интерактивным и удобным, потому что каждое действие на панели генерирует события, на которые программа может реагировать. Панель управления служит связующим звеном между пользователем и API-логикой в этом проекте. В этой же панели вы можете ввести сообщение, отправить его кнопкой и сразу увидеть ответ. Не уходя от основной темы статьи, вы сможете развить эту идею в следующих проектах, изучив только необходимые элементы дизайна панели и работы с текстом.

Пример:

#include  <Controls\Dialog.mqh>
CAppDialog panel;

Пояснение:

Прежде чем мы сможем создать какую-либо панель управления в MetaTrader 5, нужно подключить библиотеку Dialog. Это делается добавлением include-файла библиотеки Dialog в нашу программу. Эта строка, по сути, говорит компилятору: зайди в каталог MQL5, затем в папку Include, открой Controls и подключи файл Dialog. В этом файле содержатся готовые классы и функции для создания диалоговых элементов интерфейса на графике – панелей, окон и контейнеров. Без этого файла программа не распознала бы классы диалогов, и создать панель управления было бы невозможно.

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

Аналогия:

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

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

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

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

Пример:

#include  <Controls\Dialog.mqh>
CAppDialog panel;

int panel_x = 32;
int panel_y = 82;
int panel_w = 600;
int panel_h = 200;

ulong chart_ID = ChartID();
string panel_name = "Google Generative AI";

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   panel.Create(chart_ID,panel_name,0,panel_x,panel_y,panel_w,panel_h);
   panel.Run();
//---
   return(INIT_SUCCEEDED);
  }

Вывод:

Пояснение:

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

Чтобы понять, как и где должна появиться панель, терминалу MetaTrader 5 нужны несколько параметров. Один из ключевых – ID графика. Это значение указывает, к какому именно графику на платформе нужно привязать панель. Если явно указать ID графика, панель появится на нужном графике, ведь советник технически может работать сразу с несколькими графиками. Еще один важный параметр – имя панели: оно выступает ее уникальным идентификатором. MetaTrader 5 использует это имя, чтобы идентифицировать панель, управлять ею и отличать ее от других графических элементов на графике. Понятное и осмысленное имя также помогает держать код аккуратным и упрощает поддержку.

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

Ширина и высота задают размер панели. Эти значения определяют, сколько места будет отведено под поля ввода, кнопки и метки. Чтобы размеры было проще менять, их хранят в отдельных переменных – так код остается аккуратным. Переменные размеров определяют масштаб панели, поэтому позже можно изменить компоновку, не затрагивая логику ее создания. За размещение отвечают переменные позиции. После создания панель нужно запустить. Запуск панели позволяет ей начать отслеживать действия пользователя: ввод текста, нажатия кнопок и срабатывание событий. Без этого шага панель была бы видна, но не реагировала бы на действия пользователя.

Аналогия:

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

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

panel.Run() – это как "включить" умный плакат, чтобы заработали кнопки, формы ввода, прокрутка текста и прочие элементы. Если панель не запущена, она не будет реагировать на взаимодействия – как обычный плакат, приклеенный к стене. Если запустить программу, вы увидите: панель исчезает с графика каждый раз, когда вы компилируете советник или меняете таймфрейм. В некоторых ситуациях график может даже закрыться. Это происходит потому, что при перекомпиляции или изменении графика MetaTrader 5 перезагружает советник и автоматически удаляет все объекты и элементы управления, созданные предыдущим экземпляром. Все потому, что по умолчанию панель привязана к жизненному циклу советника. Если явно не обработать деинициализацию, панель фактически удаляется вместе с советником. 

Решение – вызвать panel.Destroy() и передать в нее причину деинициализации в обработчике события OnDeinit. Это предотвращает сбои и гарантирует, что панель будет корректно полностью очищаться каждый раз, когда советник приостанавливается или перезагружается. MetaTrader 5 сможет безопасно удалить панель, если передать причину в метод деструктора. Так график остается стабильным, и не возникает непредвиденного поведения.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   panel.Destroy(reason);
  }

Добавление пользовательского ввода на панель

Напомню: в этом проекте пользователь вводит запрос, который затем напрямую передается с панели в ИИ. В этой части я покажу, как создать в панели поле ввода, чтобы пользователь мог набрать свое сообщение. Так панель сможет сохранять введенный текст, а ваш код на MQL5 сможет использовать его для взаимодействия с ИИ. Поскольку статья по-прежнему посвящена API-запросам и возможностям WebRequest, мы не будем разбирать все тонкости полей ввода в MQL5. Вместо этого мы сосредоточимся только на том, что нужно, чтобы собрать ввод пользователя и встроить его в панель.

Пример:

#include  <Controls\Dialog.mqh>
#include  <Controls\Edit.mqh>

CAppDialog panel;
CEdit input_box;

int panel_x = 32;
int panel_y = 82;
int panel_w = 600;
int panel_h = 200;

ulong chart_ID = ChartID();
string panel_name = "Google Generative AI";
string input_box_name = "INPUT BOX";
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   panel.Create(chart_ID,panel_name,0,panel_x,panel_y,panel_w,panel_h);

   input_box.Create(chart_ID,input_box_name,0,5,55,0,0);
   input_box.Width(500);
   input_box.Height(30);
   panel.Add(input_box);

   panel.Run();

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   panel.Destroy(reason);
  }

Вывод:

Пояснение:

Первая строка говорит вашему коду на MQL5 подключить файл с определениями редактируемых текстовых полей для панели (путь: Include → Controls). Без кода из этого файла программа не знала бы, как работать с полями ввода. Это можно сравнить с тем, что вы даете приложению инструкции, как создавать и управлять полями ввода текста.

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

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

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

Аналогия:

Считайте, что первая строка говорит приложению зайти в большую библиотеку, открыть полку "Include", найти раздел "Controls" и взять инструкции по созданию редактируемых контейнеров. Чтобы приложение понимало, что делать, этот "справочник" дает подробные инструкции по созданию и обработке полей ввода. Без этого руководства приложение не знало бы, как работать с текстовыми полями. Вторая строка – это как сказать библиотекарю, что вы хотите воспользоваться этим справочником, чтобы создать новый контейнер. Тип гарантирует, что контейнер будет вести себя как настоящее редактируемое поле, готовое принимать текст, а имя нужно, чтобы вы могли узнать его позже. Пока это лишь "пустой чертеж": он уже в памяти, но на экране его никто не видит.

А когда вы заводите отдельную строку для имени поля ввода, это похоже на маркировку контейнеров: чтобы сразу было ясно, где какой. Как если бы вы среди нескольких коробок сказали "вот эта – красная", так и здесь метка помогает программе находить нужный контейнер, когда требуется с ним работать. Финальное "размещение контейнера на полке" – это этап, на котором поле ввода реально создается. Теперь вы выбираете график, задаете имя, привязываете элемент к "основной полке" и настраиваете горизонтальное и вертикальное положение. Затем вы меняете размер, чтобы поля хватало под текст – даже если изначально оно было совсем небольшим. Это как "подогнать" контейнер под книги, чтобы они легко помещались внутрь.

Наконец, добавить поле ввода на панель – это как поставить подписанный контейнер на выделенную полку библиотечного стола. Формально оно уже "есть", но пользоваться им нельзя, пока вы не выполните этот шаг. Как только контейнер оказался на полке, в него уже можно класть книги; так и поле ввода после добавления на панель становится рабочим – пользователи могут вводить в него текст.

 

Добавление кнопок действий на панель

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

Пример:

#include  <Controls\Dialog.mqh>
#include <Controls\Edit.mqh>
#include <Controls\Button.mqh>

CAppDialog panel;
CEdit input_box;
CButton send_button;
string send_button_name = "SEND BUTTON";

int panel_x = 32;
int panel_y = 82;
int panel_w = 600;
int panel_h = 200;

ulong chart_ID = ChartID();
string panel_name = "Google Generative AI";
string input_box_name = "INPUT BOX";
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   panel.Create(chart_ID,panel_name,0,panel_x,panel_y,panel_w,panel_h);

   input_box.Create(chart_ID,input_box_name,0,5,55,0,0);
   input_box.Width(500);
   input_box.Height(30);
   panel.Add(input_box);

   send_button.Create(chart_ID,send_button_name,0,510,55,556,85);
   send_button.Text("Send");
   panel.Add(send_button);

   panel.Run();

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   panel.Destroy(reason);
  }

Вывод:

Пояснение:

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

Это объявление сообщает программе, что вы будете работать с кнопкой, и задает ей имя – чтобы потом менять внешний вид и реагировать на действия пользователя. Пока кнопка на графике не видна – сейчас это лишь "заготовка" элемента управления. Затем строкой задается имя кнопки. Это имя служит внутренним идентификатором и помогает MetaTrader 5 отличать кнопку от других элементов управления на той же панели или графике. Это не просто видимая надпись: имя позволяет платформе однозначно идентифицировать кнопку и обрабатывать ее на уровне внутренней логики.

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

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

Аналогия:

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

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

Создать кнопку – это как поставить подписанный контейнер на полку. То, к какой "полке" она относится, где именно будет стоять и сколько займет места, решаете вы. Благодаря такому продуманному позиционированию кнопка окажется ровно там, где нужно – рядом с полем ввода сообщения. Нажатие кнопки – это как поставить книгу или коробку в отведенное место на столе. Вы выбираете стол, место на столе и то, сколько пространства понадобится. Если кнопку расположить правильно, она окажется ровно там, где пользователю удобно с ней взаимодействовать.

Отображение текста в панели управления

В этом разделе мы сосредоточимся на отображении текста в панели управления – в частности, ответа AI-сервера. Имейте в виду: в этом уроке мы лишь показываем, как выводить текст. Поскольку панели управления в MetaTrader 5 не распознают переносы строк вроде \n, обработку длинных ответов и прокрутку мы обсудим в следующей статье. Для отображения текста используется объект метки (label) на панели. Метка служит контейнером для ответа сервера. Когда вы впервые объявляете переменную метки, вы задаете ее имя, положение внутри панели, ширину, высоту и график, к которому она относится. После создания метки ответ сервера присваивается ее текстовому атрибуту, а затем метка добавляется на панель, чтобы ее было видно.

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

Пример:

#include  <Controls\Dialog.mqh>
#include <Controls\Edit.mqh>
#include <Controls\Button.mqh>
#include <Controls\Label.mqh>

CAppDialog panel;
CEdit input_box;
CButton send_button;
string send_button_name = "SEND BUTTON";

CLabel  response_display;
string response_text_name = "AI RESPONSE";

int panel_x = 32;
int panel_y = 82;
int panel_w = 600;
int panel_h = 200;

ulong chart_ID = ChartID();
string panel_name = "Google Generative AI";
string input_box_name = "INPUT BOX";

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   panel.Create(chart_ID,panel_name,0,panel_x,panel_y,panel_w,panel_h);

   input_box.Create(chart_ID,input_box_name,0,5,55,0,0);
   input_box.Width(500);
   input_box.Height(30);
   panel.Add(input_box);
   
   send_button.Create(chart_ID,send_button_name,0,510,55,556,85);
   send_button.Text("Send");
   panel.Add(send_button);
   
   response_display.Create(0, "PanelText", 0, 0, 0, 0, 0);
   response_display.Text("THIS WILL BE THE SERVER RESPONSE......");
   panel.Add(response_display);   
   
   panel.Run();

//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   panel.Destroy(reason);
  }

Вывод:

Пояснение:

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

Затем объявляется переменная CLabel – response_display, то есть конкретный объект-метка. Эта переменная выступает "заместителем" метки и сообщает программе: нужен текстовый контейнер, который сможет хранить и отображать содержимое. Метка пока не отображается на графике: на этом этапе это лишь объявление в коде, готовое к созданию и добавлению на панель. В аналогии с книжной полкой это как пустой подписанный контейнер в "кладовой", готовый отправиться на конкретную полку.

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

Затем содержимое метки задается через функцию Text(). Здесь будет показан ответ сервера – пока вместо него стоит текст-заполнитель. Этот шаг похож на то, как вы кладете в контейнер образец записки: взглянув на него, сразу понятно, что именно должно быть внутри. Наконец, когда вы прикрепляете метку к панели, она становится видимой и "оживает" в интерфейсе. До этого момента метка существует только в памяти, но на графике ее не видно, и использовать ее нельзя. Разместив ее на панели, вы делаете метку доступной – как если бы поставили подписанный контейнер на полку в библиотеке.

 

Заключение

В этой статье мы заложили основу для создания панелей управления в MetaTrader 5 и их связи с API-запросами. Вы разобрались в базовых принципах панелей, в том, чем они отличаются от обычных объектов графика, и как с помощью библиотеки Controls создавать их и управлять ими. Чтобы подготовить панель к взаимодействию с пользователем, мы также обсудили, как добавить ключевые элементы интерфейса: кнопки действий и поля ввода. Сейчас панель полностью собрана и работает, но пока не связана ни с какой серверной логикой или API. В следующей статье мы разберем обработку событий графика, фиксацию нажатий кнопок, отправку API-запросов и вывод ответа сервера прямо на панели.