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
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso