Agora é mais fácil criar painéis gráficos no MQL5
Introdução
O MQL5 oferece aos desenvolvedores uma variedade de ferramentas úteis que facilitam a escrita de código. Em particular, o MQL5 contém um grande número de bibliotecas ou classes que podem ser usadas para escrever vários aplicativos, como painéis e bibliotecas, sem criar seu código do zero. Neste artigo, aprenderemos como podemos usar essas classes para criar aplicativos, bem como apresentaremos dois métodos diferentes de criação do mesmo aplicativo.
O artigo pode servir como um excelente material prático para melhorar as habilidades de programação de um desenvolvedor iniciante através da criação de um aplicativo do zero. Além disso, o artigo pode ser visto como um guia simples para o desenvolvimento de ferramentas que facilitam o trabalho dos traders. Se você é um desenvolvedor iniciante em MQL5, ele pode ser usado como um guia para criar painéis gráficos no terminal MetaTrader 5.
O artigo aborda o seguintes tópicos:
Eu recomendo que você se familiarize com o tópico de programação orientada a objetos em MQL5 para entender melhor o tópico deste artigo. Em particular, você pode ler meu artigo "Programação Orientada a Objetos (POO) em MQL5".
Identificação gráfica de painéis
Nesta seção, aprenderemos o que é um painel gráfico e como ele pode ser útil para nós na indústria de negociação. Um painel pode ser apenas uma interface gráfica com funções ou informações úteis, como um painel para abrir e gerenciar negociações, fornecer informações sobre a conta ou o dia de negociação, entre outras coisas. Tais painéis economizam tempo ao executar ações ou obter informações necessárias, permitindo-nos concentrar mais na negociação e análise de mercado.
Podemos criar um painel personalizado dependendo dos objetos e tarefas ou da natureza da interação entre o usuário e esse painel. Os objetos incluem, em particular:
- Números,
- Strings,
- Formas,
- Cores,
- Botões,
- Etc.
Existem dois métodos para criar e desenvolver esses painéis. Podemos escrever o código do zero, o que consome muito tempo e esforço, mas se você for um desenvolvedor, deve entender como fazê-lo, pois isso aprimora suas habilidades de programação. O segundo método é usar classes ou bibliotecas prontas para executar seu trabalho de maneira rápida e eficiente, economizando muito tempo e esforço. Neste artigo, aprenderemos mais sobre as classes que podem ser usadas para criar painéis. Além disso, criaremos um aplicativo simples usando ambos os métodos. Isso demonstrará o valor das classes.
Classes de painéis e diálogos
Vamos considerar as classes que nos ajudarão a criar facilmente um painel gráfico. Vamos nos referir às classes de painéis e diálogos. Informações mais detalhadas sobre elas podem ser encontradas na documentação do MQL5. Neste artigo, consideraremos apenas algumas delas.
Agora vamos definir as classes para a criação de painéis de controle e diálogos. Eles representam uma biblioteca com código pronto para a criação ou desenvolvimento de painéis interativos ou aplicativos, incluindo indicadores e Expert Advisors. Isso pode ser encontrado na pasta de dados do terminal > pasta Include > pasta Controls. Existem classes auxiliares, básicas, simples e complexas que podem ser usadas para diferentes operações. Exemplos dessas classes:
| Classe | Nome do arquivo (pasta Controls) | Descrição |
|---|---|---|
| CLabel | Label.mqh | Classe de controle simples para criar rótulos de texto simples e não editáveis |
| CButton | Button.mqh | Classe de controle simples para criar botões simples. |
| CEdit | Edit.mqh | Classe de controle simples que permite ao usuário inserir texto |
| CPanel | Panel.mqh | Classe de controle simples que permite combinar controles com outras funções semelhantes em um grupo |
| CCheckBox | CheckBox.mqh | Classe de controle complexo para exibir uma caixa de seleção (true/false) |
| CSpinEdit | SpinEdit.mqh | Classe de controle complexa que permite editar um valor inteiro. |
| CDialog | Dialog.mqh | Classe de controle simples que permite combinar controles com outras funções diferentes em um grupo |
Como vemos, podemos usar as classes para executar muitas tarefas que de outra forma levariam muito tempo e esforço. Na próxima seção, vamos comparar a criação de um aplicativo do zero e usando classes.
Painel gráfico simples
Vamos criar um simples painel de negociação para abrir ordens de compra e venda após definir o tamanho do lote. Primeiro, escreveremos o código do zero sem o uso de classes para treinar nossas habilidades de programação, e depois aplicaremos classes para ver o quanto isso é conveniente.
Painel gráfico sem classes
Os seguintes passos descrevem a criação de um painel de ordens simples para abrir ordens de compra e venda após a definição do tamanho do lote sem o uso de classes, exceto pela classe Trade:
Usaremos #include para incluir o arquivo Trade e criar um objeto trade, que será usado para as ordens abertas.
#include <Trade\Trade.mqh>
CTrade trade; Criaremos uma função lógica trade para definir a variável do tipo de ordem ENUM_ORDER_TYPE e a variável double do tamanho do lote. Esses são os parâmetros da função criada. Para o corpo da função:
- Criamos uma variável double para o preço.
- Estabeleceremos uma condição para determinar o tipo de preço (ask ou bid) com base no tipo de ordem, usando uma condição if:
- Se o tipo de ordem for compra (buy), o preço de abertura da ordem será Ask.
- Se o tipo de ordem for venda (sell), o preço de abertura será Bid.
- O resultado será a abertura de uma posição com o símbolo atual, tipo de ordem, tamanho do lote, tipo de preço, stop loss e take profit com valores zerados, e um comentário em branco.
bool openTrade(ENUM_ORDER_TYPE type, double vol) { double price; if(type==ORDER_TYPE_BUY) { price=SymbolInfoDouble(Symbol(),SYMBOL_ASK); } else price=SymbolInfoDouble(Symbol(),SYMBOL_BID); return trade.PositionOpen(Symbol(),type,vol,price,0,0,""); }
Definiremos a localização do painel escolhendo o canto superior esquerdo após criar a variável const ENUM_BASE_CORNER PanelLoc.
const ENUM_BASE_CORNER panelLoc=CORNER_LEFT_UPPER;
Definiremos xMargin e yMargin após a criação de variáveis inteiras constantes x e y.
const int xMargin=20; const int yMargin=20;
Definiremos o espaço entre os elementos para x e y após a criação de outra variável inteira constante.
const int xSpace=10; const int ySpace=10;
Definiremos o tamanho dos elementos, que são botões e texto, após a criação de quatro variáveis inteiras constantes btnWidth para a largura do botão, btnHeight para a altura do botão, txtWidth para a largura do texto e txtHeight para a altura do texto.
const int btnWidth=50; const int btnHeight=20; const int txtWidth=(btnWidth*2)+xSpace; const int txtHeight=20;
Definiremos a localização do texto e dos botões; temos text x, text y, buy button x, buy button y, sell button x e sell y. Declararemos variáveis inteiras constantes para todas e atribuiremos valores a cada uma delas.
const int txtX=3; const int txtY=yMargin+txtHeight; const int buyX=3; const int buyY=txtY+ySpace+btnHeight; const int sellX=buyX+xSpace+btnWidth; const int sellY=txtY+ySpace+btnHeight;
Atribuiremos nomes aos botões de compra e venda após a criação de variáveis constantes de string para eles.
const string txtName="txttVol"; const string buyName="buyBtn"; const string sellName="sellBtn";
Criaremos uma variável double para o tamanho do lote com um valor inicial.
double lotSize=0.01;
Na parte OnInit(), chamaremos a função createPanel(), que criaremos mais tarde.
createPanel();
Na parte OnDeinit, removeremos os objetos pelos seus nomes.
ObjectDelete(0,txtName); ObjectDelete(0,buyName); ObjectDelete(0,sellName);
Na área global, criaremos uma função que nos permitirá interagir com o painel, realizando os seguintes passos.
Usaremos a função OnChartEvent e seus parâmetros:
- const int id - para identificador de evento
- const long &lparam - para o parâmetro de evento long
- const double &dparam - para o parâmetro de evento double
- const string &sparam - para o parâmetro de evento string
Definiremos as condições para interação com o texto dos objetos (tamanho do lote), o botão de compra e venda.
//+------------------------------------------------------------------+ //| Interaction function | //+------------------------------------------------------------------+ void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) { //--- If the event id is equal to the end of text editing in the panel and the string type event is equal to the text name if(id==CHARTEVENT_OBJECT_ENDEDIT && sparam==txtName) { //--- lotTxt string variable will be equal to the returned property value by using the ObjectGetString function string lotTxt=ObjectGetString(0, txtName, OBJPROP_TEXT); //--- call setLot function that we will create later with the lotTxt value setLot(lotTxt); //Setting the property value by using the ObjectSetString ObjectSetString(0, txtName, OBJPROP_TEXT, string(lotSize)); //--- Use return return; } //--- If the event id is equal to the object click to check if we click the buy button else if(id==CHARTEVENT_OBJECT_CLICK) { //We will check if the string param is equal to buyname if(sparam==buyName) { //--- Setting the value of the property by using the ObjectSetInteger ObjectSetInteger(0, buyName, OBJPROP_STATE, false); //Calling the created openTrade to open a buy order. openTrade(ORDER_TYPE_BUY, lotSize); //--- Use return return; } //--- If the event id is equal to the object click to check if we click the sell button //--- We will check if the string param is equal to sellname else if(sparam==sellName) { //--- Setting the value of the property by using the ObjectSetInteger ObjectSetInteger(0, sellName, OBJPROP_STATE, false); //Calling the created openTrade to open a sell order openTrade(ORDER_TYPE_SELL, lotSize); //--- Use return return; } } }
Crie a função void createPanel que chamamos anteriormente na parte OnInit(), executando os seguintes passos:
- Excluímos os objetos txtName, buyName e SellName.
- Chamamos a função EditCreate.
- Chamamos a função ButtonCreate para o botão de compra.
- Chamamos a função ButtonCreate para o botão de venda.
//+------------------------------------------------------------------+ //|createPanel function | //+------------------------------------------------------------------+ void createPanel() { //--- Delete objects of txtName, buyName, and sellName ObjectDelete(0, txtName); ObjectDelete(0, buyName); ObjectDelete(0, sellName); //--- calling the EditCreate function EditCreate( // Parameters: 0, // const long (chart_ID): to specify the chart's ID, we will use (0). txtName, // const string (name): to specify the button name, we will use (txtName) 0, // const int (sub_window): to specify the subwindow index, we will use (0) for the main window txtX, // const int (x): to specify the X coordinate, we will use (txtX) txtY, // const int (y): to specify the Y coordinate, we will use (txtY) txtWidth, // const int (width):to specify the button width, we will use (txtWidth) txtHeight, // const int (height): to specify the button height, we will use (txtHeight) string(lotSize), // const string (text): to specify the text, we will use (lotSize) "Arial", // const string (font): to specify the font, we will use "Arial" 10, // const int (font_size): to specify the font size, we will use (10) ALIGN_LEFT, // const ENUM_ALIGN_MODE (align_mode): to specify the position of text, we will use (ALIGN_LEFT) false, // const bool (read_only=false): to specify the ability to edit, we will be (false) panelLoc, // const ENUM_BASE_CORNER (corner): to specify the chart corner for anchoring, we will call panelLoc function clrBlack, // const color (clr): to specify the text color, we will specify clrBlack clrWhite, // const color (back_clr): to specify the background color, we will specify clrWhite clrBlack, // const color (border_clr): to specify the border color, we will specify clrBlack false, // const bool (back=false): in the background, we will set false false, // const bool (selection=false): highlight to move, we will set false false, // const bool (hidden): hidden in the object list, we will set false 0); // const long (z_order=0): priority for a mouse click, we will use (0) //--- calling the ButtonCreate function for the buy ButtonCreate( // Parameters: 0, // const long (chart_ID): to specify the chart's ID, we will use (0) buyName, // const string (name): to specify the button name, we will use (buyName) for the buy button 0, // const int (sub_window): to specify the subwindow index, we will use (0) for the main window buyX, // const int (x): to specify the X coordinate, we will use (buyX) for buy buyY, // const int (y): to specify the Y coordinate, we will use (buyY) for buy btnWidth, // const int (width): to specify the button width, we will use (btnWidth) for buy btnHeight, // const int (height): to specify the button height, we will use (btnHeight) for buy panelLoc, // const ENUM_BASE_CORNER (corner): to specify the chart corner for anchoring, we will call panelLoc function for buy button "Buy", // const string (text): to specify the text, we will use ("Buy") for the buy button "Arial", // const string (font): to specify the font, we will use "Arial" 10, // const int (font_size): to specify the font size, we will use (10) clrBlack, // const color (clr): to specify the text color, we will specify clrBlack clrGreen, // const color (back_clr): to specify the background color, we will specify clrGreen for the buy button clrBlack, // const color (border_clr): to specify the border color, we will specify clrBlack false, // const bool (state): to specify if the object is pressed or released, we will specify false false, // const bool (back=false): in the background, we will set false false, // const bool (selection=false): highlight to move, we will set false false, // const bool (hidden): hidden in the object list, we will set false 0); // const long (z_order=0): priority for mouse click, we will use (0) for buy button //--- calling the ButtonCreate function for the sell ButtonCreate( //Parameters: 0, //const long (chart_ID): to specify the chart's ID, we will use (0) sellName, //const string (name): to specify the button name, we will use (sellName) for the sell button 0, //const int (sub_window): to specify the subwindow index, we will use (0) for the main window sellX, //const int (x): to specify the X coordinate, we will use (sellX) for sell sellY, //const int (y): to specify the Y coordinate, we will use (sellY) btnWidth, //const int (width): to specify the button width, we will use (btnWidth) for sell btnHeight, //const int (height): to specify the button height, we will use (btnHeight) for sell panelLoc, //const ENUM_BASE_CORNER (corner): to specify the chart corner for anchoring, we will call panelLoc function for sell button "Sell", //const string (text): to specify the text, we will use ("Sell") for the sell button "Arial", //const string (font): to specify the font, we will use "Arial" 10, //const int (font_size): to specify the font size, we will use (10) clrBlack, //const color (clr): to specify the text color, we will specify clrBlack clrRed, //const color (back_clr): to specify the background color, we will specify clrRed for the sell button clrBlack, //const color (border_clr): to specify the border color, we will specify clrBlack false, //const bool (state): to specify if the object is pressed or released, we will specify false false, //const bool (back=false): in the background, we will set false false, //const bool (selection=false): highlight to move, we will set false false, //const bool (hidden): hidden in the object list, we will set false 0); //const long (z_order=0): priority for mouse click, we will use (0) for sell button }
Criaremos a função void setLot com um parâmetro — lotTxt, que é usado para lotSize. O corpo da função é mostrado abaixo:
- Criamos uma variável double newLot e a atribuímos a lotTxt depois de convertê-la de string para double usando a função StringToDouble.
- Confirmamos se o valor de newLot é menor que 0. Imprimimos a mensagem "Invalid Volume Specified" (Volume inválido especificado) e, em seguida, usamos return.
- Retornamos o valor de newLot que corresponde a lotSize.
void setLot(string lotTxt) { double newLot=StringToDouble(lotTxt); if(newLot<0) { Print("Invaid Volume Specified"); return; } lotSize=newLot; }
A criação da função EditCreate consiste nos seguintes passos:
//+------------------------------------------------------------------+ //|EditCreate function | //+------------------------------------------------------------------+ bool EditCreate(const long chart_ID=0, const string name="Edit", const int sub_window=0, const int x=0, const int y=0, const int width=50, const int height=18, const string text="Text", const string font="Arial", const int font_size=10, const ENUM_ALIGN_MODE align=ALIGN_CENTER, const bool read_only=false, const ENUM_BASE_CORNER corner=CORNER_LEFT_UPPER, const color clr=clrBlack, const color back_clr=clrWhite, const color border_clr=clrNONE, const bool back=false, const bool selection=false, const bool hidden=true, const long z_order=0) { //--- Reset the error value by using ResetLastError() ResetLastError(); //--- Create an edit field if(!ObjectCreate(chart_ID, name, OBJ_EDIT, sub_window, 0, 0)) { Print(__FUNCTION__, ": failed to create \"Edit\" object! Error code = ", GetLastError()); return(false); } //--- Setting the object coordinates x and y by using the ObjectSetInteger ObjectSetInteger(chart_ID, name, OBJPROP_XDISTANCE, x); ObjectSetInteger(chart_ID, name, OBJPROP_YDISTANCE, y); //--- Setting the object size by using the ObjectSetInteger function also ObjectSetInteger(chart_ID, name, OBJPROP_XSIZE, width); ObjectSetInteger(chart_ID, name, OBJPROP_YSIZE, height); //--- Setting the text by using ObjectSetString function ObjectSetString(chart_ID, name, OBJPROP_TEXT, text); //--- Setting the text font by using the ObjectSetString function also ObjectSetString(chart_ID, name, OBJPROP_FONT, font); //--- Setting the font size by using the ObjectSetInteger function ObjectSetInteger(chart_ID, name, OBJPROP_FONTSIZE, font_size); //--- Setting the type of text alignment in the object ObjectSetInteger(chart_ID, name, OBJPROP_ALIGN, align); //--- Setting the ability to edit, enable if it is (true) or cancel (false) if you need a read-only mode ObjectSetInteger(chart_ID, name, OBJPROP_READONLY, read_only); //--- Setting the chart's corner, relative to which object coordinates are defined to set the location of the object. ObjectSetInteger(chart_ID, name, OBJPROP_CORNER, corner); //--- Setting the text color ObjectSetInteger(chart_ID, name, OBJPROP_COLOR, clr); //--- Setting the background color ObjectSetInteger(chart_ID, name, OBJPROP_BGCOLOR, back_clr); //--- Setting the border color of the object ObjectSetInteger(chart_ID, name, OBJPROP_BORDER_COLOR, border_clr); //--- Displaying in the foreground by (false) or in the background by (true) ObjectSetInteger(chart_ID, name, OBJPROP_BACK, back); //--- Setting (true) to enable or (false) to disable the mode of moving the label by mouse ObjectSetInteger(chart_ID, name, OBJPROP_SELECTABLE, selection); ObjectSetInteger(chart_ID, name, OBJPROP_SELECTED, selection); //--- Setting (true) if you need hiding or (false) if you need the display of graphical object name in the object list ObjectSetInteger(chart_ID, name, OBJPROP_HIDDEN, hidden); //--- Setting the priority for receiving the event of a mouse click in the chart ObjectSetInteger(chart_ID, name, OBJPROP_ZORDER, z_order); //--- Returning (true) if successful execution return(true); }
Criaremos a função ButtonCreate de maneira semelhante aos parâmetros da função EditCreate com uma pequena diferença:
bool ButtonCreate(const long chart_ID=0, const string name="Button", const int sub_window=0, const int x=0, const int y=0, const int width=50, const int height=18, const ENUM_BASE_CORNER corner=CORNER_LEFT_UPPER, const string text="Button", const string font="Arial", const int font_size=10, const color clr=clrBlack, const color back_clr=C'236,233,216', const color border_clr=clrNONE, const bool state=false, const bool back=false, const bool selection=false, const bool hidden=true, const long z_order=0) { ResetLastError(); if(!ObjectCreate(chart_ID,name,OBJ_BUTTON,sub_window,0,0)) { Print(__FUNCTION__, ": failed to create the button! Error code = ",GetLastError()); return(false); } ObjectSetInteger(chart_ID,name,OBJPROP_XDISTANCE,x); ObjectSetInteger(chart_ID,name,OBJPROP_YDISTANCE,y); ObjectSetInteger(chart_ID,name,OBJPROP_XSIZE,width); ObjectSetInteger(chart_ID,name,OBJPROP_YSIZE,height); ObjectSetInteger(chart_ID,name,OBJPROP_CORNER,corner); ObjectSetString(chart_ID,name,OBJPROP_TEXT,text); ObjectSetString(chart_ID,name,OBJPROP_FONT,font); ObjectSetInteger(chart_ID,name,OBJPROP_FONTSIZE,font_size); ObjectSetInteger(chart_ID,name,OBJPROP_COLOR,clr); ObjectSetInteger(chart_ID,name,OBJPROP_BGCOLOR,back_clr); ObjectSetInteger(chart_ID,name,OBJPROP_BORDER_COLOR,border_clr); ObjectSetInteger(chart_ID,name,OBJPROP_BACK,back); ObjectSetInteger(chart_ID,name,OBJPROP_STATE,state); ObjectSetInteger(chart_ID,name,OBJPROP_SELECTABLE,selection); ObjectSetInteger(chart_ID,name,OBJPROP_SELECTED,selection); ObjectSetInteger(chart_ID,name,OBJPROP_HIDDEN,hidden); ObjectSetInteger(chart_ID,name,OBJPROP_ZORDER,z_order); return(true); }
Após a compilação e execução do código, o painel aparece da seguinte maneira:

Como podemos ver, no canto superior esquerdo temos um painel com o tamanho do lote e dois botões Buy e Sell e podemos especificar o tamanho do lote que precisamos e colocar um pedido pressionando o botão Buy ou Sell. Agora, para comparação, vamos criar o mesmo painel usando as classes Panels e Dialogs.
Painel gráfico usando classes
Execute os seguintes passos para criar o painel.
Inclua os arquivos ou classes necessárias: Dialog, Button, Edit e Trade. Como sabemos, isso pode ser feito com o comando #include.
#include <Controls\Dialog.mqh> #include <Controls\Button.mqh> #include <Controls\Edit.mqh> #include <Trade\Trade.mqh>
Usaremos a macrosubstituição #define, que é uma diretiva de pré-processador para atribuir nomes mnemônicos às constantes:
- PANEL_NAME "Order Panel"
- PANEL_WIDTH 116
- PANEL_HIEIGHT 100
- ROW_HEIGHT 20
- BUY_BTN_NAME "Buy BTN"
- SELL_BTN_NAME "Sell BTN"
- CLOSE_BTN_NAME "Close BTN"
- EDIT_NAME "Lot Size"
#define PANEL_NAME "Order Panel" #define PANEL_WIDTH 116 #define PANEL_HIEIGHT 100 #define ROW_HEIGHT 20 #define BUY_BTN_NAME "Buy BTN" #define SELL_BTN_NAME "Sell BTN" #define CLOSE_BTN_NAME "Close BTN" #define EDIT_NAME "Lot Size"
Criaremos objetos das classes
CAppDialog panel; CButton buyBtn; CButton sellBtn; CButton closeBtn; CEdit lotSize; CTrade trade;
Na parte OnInit(), precisamos criar um objeto de painel usando o objeto Panel.
- const long chart - definimos 0 para que o painel seja exibido no gráfico principal.
- const string name - definimos PANEL_NAME
- const int subwin - definimos 0
- const int x1 - definimos 10
- const int y1 - definimos 20
- const int x2 - usamos 10+PANEL_WIDTH+8
- const int y2 - usamos 20+PANEL_HIEIGHT
panel.Create(0,PANEL_NAME,0,10,20,10+PANEL_WIDTH+8,20+PANEL_HIEIGHT);
Criamos e configuraremos os botões de compra e venda:
- Criamos objetos usando object.Create.
- Configuramos a largura dos objetos de compra e venda usando object.Width.
- Definimos a altura dos objetos de compra e venda usando object.Height.
- Ajustamos a cor de fundo dos objetos usando object.ColorBackground.
- Definimos o texto dos objetos usando object.Text.
- Ajustamos a fonte dos objetos usando object.Font.
- Definimos o tamanho da fonte dos objetos usando object.FontSize.
- Ajustamos a cor dos objetos usando object.Color.
- Definimos a cor da borda dos objetos usando object.ColorBorder.
- Posicionamos os objetos na tela.
- Iniciamos a exibição da tela.
int OnInit() { //buy button panel.Create(0,PANEL_NAME,0,10,20,10+PANEL_WIDTH+8,20+PANEL_HIEIGHT); buyBtn.Create(0,BUY_BTN_NAME,0,3,40,0,0); buyBtn.Width(50); buyBtn.Height(ROW_HEIGHT); buyBtn.ColorBackground(clrGreen); buyBtn.Text("Buy"); buyBtn.Font("Arial"); buyBtn.FontSize(10); buyBtn.Color(clrBlack); buyBtn.ColorBorder(clrBlack); panel.Add(buyBtn); //sell button sellBtn.Create(0,SELL_BTN_NAME,0,63,40,0,0); sellBtn.Width(50); sellBtn.Height(ROW_HEIGHT); sellBtn.ColorBackground(clrRed); sellBtn.Text("Sell"); sellBtn.Font("Arial"); sellBtn.FontSize(10); sellBtn.Color(clrBlack); sellBtn.ColorBorder(clrBlack); panel.Add(sellBtn); //lotSize lotSize.Create(0,EDIT_NAME,0,4,10,0,0); lotSize.Width(108); lotSize.Height(ROW_HEIGHT); lotSize.Text("0.01"); lotSize.Font("Arial"); lotSize.FontSize(10); lotSize.ColorBackground(clrWhite); lotSize.Color(clrBlack); lotSize.ColorBorder(clrBlack); panel.Add(lotSize); //run the panel panel.Run(); return(INIT_SUCCEEDED); }
Na parte OnDeinit(const int Reason) usaremos Destroy como uma função de deinitialization, conforme mostrado abaixo.
void OnDeinit(const int reason) { panel.Destroy(); }
Incluiremos interação com o painel usando a função OnChartEvent e estabeleceremos condições para o comportamento dos botões de compra e venda:
- Criamos a função OnChartEvent.
- O corpo da função será o seguinte:
- Usamos object.ChartEvent com os parâmetros id para o evento, lparam para o tipo de evento long, dparam para o tipo double e sparam para o tipo string.
- Verificamos se o identificador corresponde ao clique no gráfico (Chart Click).
- Verificamos se sparam é igual aos nomes buyBtn ou SellBtn.
- Criamos uma variável double para o tamanho do lote e atribuiremos a ela o valor StringToDouble (tamanho do lote).
- Abrimos uma ordem de compra ou venda, dependendo do tipo de evento, usando o valor do tamanho do lote.
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) { panel.ChartEvent(id,lparam,dparam,sparam); if(id==CHARTEVENT_OBJECT_CLICK) { if(sparam==buyBtn.Name()) { double lot=StringToDouble(lotSize.Text()); trade.Buy(lot); } else if(sparam==sellBtn.Name()) { double lot=StringToDouble(lotSize.Text()); trade.Sell(lot); } } }
Após a compilação e execução do código, veremos o painel no gráfico:

No canto superior esquerdo, o painel com o tamanho do lote e os objetos de compra e venda são exibidos. Podemos editar o tamanho do lote e abrir ordens.
Após o trabalho realizado, vemos que criar um painel usando classes é mais simples e conveniente. Assim, as classes são muito úteis e nos economizam muito tempo. No entanto, se você é um programador iniciante, tente estudar e entender como elas são criadas. É um ótimo modo de melhorar suas habilidades de programação.
Você pode aperfeiçoar o aplicativo criado, adicionando mais funcionalidades.
Conclusão
As classes são uma ferramenta valiosa e útil em geral e, em particular, na criação de painéis que podem ser usados no MetaTrader 5. Elas permitem que os traders se concentrem mais na negociação. Aprendemos o que são painéis e exploramos seus tipos, bem como criamos um painel simples de duas maneiras, constatando o quanto o uso das classes Panels e Dialog acelera e facilita o trabalho.
Espero que o artigo seja útil para você, e que a informação apresentada seja fácil de entender e implementar. Também espero que você tenha adquirido mais conhecimento sobre o desenvolvimento de aplicações, incluindo painéis, que podem ser úteis para a sua negociação.
Para aprender mais sobre classes e objetos, recomendo que leia um dos meus artigos anteriores "Programação Orientada a Objetos (POO) em MQL5". Se você gostou do artigo e o achou útil, leia meus artigos anteriores para descobrir como desenvolver sistemas de negociação baseados em vários indicadores técnicos populares.
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/12903
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.
Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.
Muito obrigado por seu belo trabalho de código!
Mas não consegui fazê-lo funcionar na seção "Debugging with historic data". -- Será que perdi alguma caixa de seleção?
Encontre algo:
Você deve verificar o estado do botão em OnTick() porque OnChartEvent() não funciona para EAs no testador de estratégia.
https://www.mql5.com/en/forum/170896
Encontre algo:
Você deve verificar o estado do botão em OnTick() porque OnChartEvent() não funciona para EAs no testador de estratégia.
https://www.mql5.com/en/forum/170896
Obrigado por seu comentário.
O principal objetivo deste artigo é esclarecer como ficou fácil criar um painel simples usando classes.
code: "buyBtn.ToolTip ("Click open buy order")"
unsuccessful
code: "buyBtn.ToolTip ("Click open buy order")"
unsuccessful