MQL5'te Grafiksel Paneller Oluşturmak Artık Daha Kolay

Giriş

MQL5, geliştiricilere kodlama sürecini kolaylaştırmak ve zamandan ve emekten tasarruf ederek görevleri etkili bir şekilde yerine getirmek için kullanılabilecek birçok yararlı araç sağlar. Bu yararlı araçlara bir örnek olarak, MQL5'te kodlarını sıfırdan oluşturmadan birçok uygulamayı kodlamak için kullanılabilecek birçok sınıfımız vardır. Örneğin grafiksel paneller ve iletişim kutuları için. Bu makalede, bu sınıfları nasıl kullanabileceğimizi ve onlarla nasıl uygulama oluşturabileceğimizi öğreneceğiz ve aynı uygulamayı oluşturmanın iki farklı yöntemini sunacağız.

Ayrıca makale, sıfırdan bir uygulama oluşturarak yeni başlayan geliştiricilerin programlama becerilerini geliştirmeleri için iyi bir pratik materyal olarak hizmet edebilir. Ek olarak, makale yatırımcıların işlerini kolaylaştıracak araçlar geliştirmeleri için basit bir rehber olarak da düşünülebilir. Acemi bir MQL5 geliştiricisiyseniz, bu makaleyi MetaTrader 5 terminalinde grafiksel paneller oluşturmak için bir kılavuz olarak kullanabilirsiniz.

Aşağıdaki konu başlıkları üzerinden ilerleyeceğiz:

• Grafiksel panel tanımı
• Panel ve iletişim kutusu sınıfları
• Basit grafiksel panel uygulaması
• Sınıflar olmadan grafiksel panel
• Sınıfları kullanan grafiksel panel
• Sonuç

Bu makalenin konusunu daha iyi anlamak için MQL5'te Nesne Yönelimli Programlama konusuna aşina olmanızı tavsiye ederim. Bu amaçla “MQL5’te Nesne Yönelimli Programlama (Object-Oriented Programming, OOP)” başlıklı makalemi okuyabilirsiniz.

Sorumluluk reddi: Sağlanan tüm bilgiler ‘olduğu gibi’ yalnızca bilgilendirme amaçlıdır, alım-satım tavsiyesi değildir. Bu bilgiler herhangi bir sonucu garanti etmemektedir. Bu materyalleri herhangi bir işlem hesabında kullanırsanız, ortaya çıkabilecek tüm riskler size ait olacaktır.

Grafiksel panel tanımı

Bu bölümde, grafiksel panelin ne anlama geldiğini ve alım-satım dünyasında bizim için nasıl faydalı olabileceğini öğreneceğiz. Bir panel basitçe, işlem açma ve yönetme, hesap veya işlem günü bilgileri sağlama vb. gibi yararlı işlevler veya bilgiler içeren bir grafiksel arayüz olabilir. Bu paneller, herhangi bir eylemin gerçekleştirilmesinde veya gerekli bilgilerin elde edilmesinde zaman kazandırır. Bu sayede alım-satıma ve piyasa analizine daha fazla odaklanabiliriz.

Panel üzerinde ihtiyaç duyulan nesnelere, görevlere veya kullanıcı ile panel arasındaki etkileşimin niteliğine bağlı olarak özel bir panel oluşturabiliriz. Bu nesnelerden bazılarını aşağıdaki gibi belirtebiliriz:

• Sayılar,
• Metinler,
• Şekiller,
• Renkler,
• Düğmeler,
• vb.

Bu tür panelleri kendimiz nasıl oluşturabiliriz diye soracak olursanız, iki yöntem olduğunu söyleyebilirim. İlk yöntem, her şeyi sıfırdan kodlayacağımız zor yöntemdir. Bu çok zaman ve çaba gerektirir, ancak bir geliştiriciyseniz, programlama becerilerinizi geliştireceği için nasıl yapılacağını bilmeniz değerli olacaktır. İkinci yöntem ise çok fazla zaman ve çaba harcamadan işinizi hızlı ve verimli bir şekilde halletmek için hazır sınıfları kullanmaktır. Makalenin geri kalanında, paneller oluşturmak için kullanılabilecek sınıflar hakkında daha fazla bilgi edineceğiz. Buna ek olarak, her iki yöntemi de kullanarak basit bir uygulama oluşturacağız. Bu, sınıfların kullanışlılığını teyit edecektir.

Panel ve iletişim kutusu sınıfları

Bu bölümde, bir grafiksel paneli kolayca oluşturmamıza yardımcı olacak sınıflara bakacağız. Panel ve iletişim kutusu sınıflarına başvuracağız. Bunlar hakkında daha ayrıntılı bilgiyi MQL5 dokümantasyonunda bulabilirsiniz. Bu makalede bunlardan sadece bazılarını ele alacağız.

Şimdi kontrol panelleri ve iletişim kutuları oluşturmak için kullanılan sınıfları tanıyalım. Göstergeler ve Uzman Danışmanlar da dahil olmak üzere etkileşimli paneller veya uygulamalar geliştirmek için hazır kodlara sahip kütüphanelerdir. Terminal veri klasörü > Include klasörü > Controls klasöründen bulunabilirler. Çeşitli işlemler için kullanılabilecek yardımcı, temel, basit ve karmaşık sınıflar vardır. Bu sınıflara örnek olarak şunlar verilebilir:

Sınıf	Dosya adı (Controls klasörü)	Açıklama
CLabel	Label.mqh	Basit düzenlenebilir olmayan metin etiketleri oluşturmak için basit bir kontrol sınıfı
CButton	Button.mqh	Basit düğmeler oluşturmak için basit bir kontrol sınıfı
CEdit	Edit.mqh	Kullanıcının metin girmesini sağlayan basit bir kontrol sınıfı
CPanel	Panel.mqh	Kontrolleri bir gruptaki diğer benzer işlevlerle birleştirmeye olanak tanıyan basit bir kontrol sınıfı
CCheckBox	CheckBox.mqh	Kullanıcının doğru veya yanlış olarak seçtiği bir onay kutusu görüntülemek için karmaşık bir kontrol sınıfı
CSpinEdit	SpinEdit.mqh	Artırma ve azaltma alanıyla birlikte bir tamsayı değerini düzenlemeyi sağlayan karmaşık bir kontrol sınıfı
CDialog	Dialog.mqh	Kontrolleri bir gruptaki diğer farklı işlevlerle birleştirmeye olanak tanıyan karmaşık bir kontrol sınıfı

Gördüğümüz gibi, aksi takdirde çok fazla zaman ve çaba gerektirecek birçok görevi gerçekleştirmek için sınıfları kullanabiliriz. Bir sonraki bölümde, sıfırdan bir uygulama oluşturmak ile sınıfları kullanarak bir uygulama oluşturmayı karşılaştıracağız.

Basit grafiksel panel uygulaması

Bu bölümde, lot büyüklüğünü belirledikten sonra alış ve satış emirleri açmak için kullanılabilecek basit bir alım-satım panelinin nasıl oluşturulacağını öğreneceğiz. Programlama becerilerimizi geliştirmek için önce sınıfları kullanmadan sıfırdan kod yazalım ve ardından ne kadar daha kullanışlı olduğunu görmek için sınıfları uygulayalım.

Sınıflar olmadan grafiksel panel

Aşağıdaki adımlarda, "Trade" sınıfı dışında herhangi bir sınıf kullanmadan, lot büyüklüğünü belirledikten sonra alış ve satış emirleri açmak için basit bir emir panelinin nasıl oluşturulacağı açıklanmaktadır:

#include yönergesini kullanarak Trade include dosyasını dahil edelim ve emirler açmak için kullanılacak trade adında bir nesne oluşturalım.

#include <Trade\Trade.mqh>
CTrade trade;

ENUM_ORDER_TYPE emir türü ve double lot büyüklüğü parametrelerine sahip bir boolean openTrade fonksiyonu oluşturalım. Fonksiyonun gövdesi şöyle olacaktır:

• double türünde price değişkeni oluştur
• if kullanarak emir türüne göre fiyat türünü (Ask veya Bid) belirlemek için koşullar belirle:
• Emir türü alış ise, emri açmak için kullanılacak fiyat Ask fiyatı olacaktır
• Emir türü satış ise, emri açmak için kullanılacak fiyat Bid fiyatı olacaktır
• Mevcut sembol, emir türü, lot büyüklüğü, fiyat türü, Zararı Durdur seviyesi (sıfır), Kar Al seviyesi (sıfır) ve yorum (boş) parametreleriyle bir pozisyon aç

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,"");
  }

const ENUM_BASE_CORNER panelLoc değişkenini oluşturduktan sonra sol üst köşeyi seçerek panelin konumunu ayarlayalım.

const ENUM_BASE_CORNER panelLoc=CORNER_LEFT_UPPER;

const int xMargin ve yMargin değişkenlerini oluşturduktan sonra x ve y kenar boşluğunu ayarlayalım.

const int xMargin=20;
const int yMargin=20;

Başka const int değişkenler oluşturduktan sonra elemanlar arasındaki x ve y boşluğu ayarlayalım.

const int xSpace=10;
const int ySpace=10;

Düğme genişliği için btnWidth, düğme yüksekliği için btnHeight, metin genişliği için txtWidth ve metin yüksekliği için txtHeight olmak üzere dört const int değişken oluşturduktan sonra düğme ve metin elemanlarının boyutlarını ayarlayalım.

const int btnWidth=50;
const int btnHeight=20;
const int txtWidth=(btnWidth*2)+xSpace;
const int txtHeight=20;

Metin ve düğmelerin konumlarını ayarlayalım: metin x, metin y, alış düğmesi x, alış düğmesi y, satış düğmesi x ve satış düğmesi y. Hepsi için const int değişkenler bildirelim ve her birine değer atayalım.

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;

Metin, alış düğmesi ve satış düğmesi adları için const string değişkenler oluşturduktan sonra bunlara adlar atayalım.

const string txtName="txttVol";
const string buyName="buyBtn";
const string sellName="sellBtn";

Başlangıç değerine sahip double türünde bir lot büyüklüğü değişkeni oluşturalım.

double lotSize=0.01;

OnInit() kısmında, daha sonra oluşturacağımız createPanel() fonksiyonunu çağıralım.

   createPanel();

OnDeinit() kısmında, nesneleri adlarını kullanarak silelim.

   ObjectDelete(0,txtName);
   ObjectDelete(0,buyName);
   ObjectDelete(0,sellName);

Global kapsamda, aşağıdaki adımları izleyerek panel ile etkileşimi sağlayacak bir fonksiyon oluşturalım.

OnChartEvent() fonksiyonunu kullanalım. Parametreleri şunlardır:

• const int id - olay kimliği için
• const long &lparam - long türündeki olay parametresi için
• const double &dparam - double türündeki olay parametresi için
• const string &sparam - string türündeki olay parametresi için

Metin (lot büyüklüğü), alış düğmesi ve satış düğmesi elemanlarıyla etkileşim koşullarını ayarlayalım.

//+------------------------------------------------------------------+
//| 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;
              }
        }
  }

Daha önce OnInit() kısmında çağırdığımız void createPanel fonksiyonunu aşağıdaki adımları takip ederek oluşturalım:

• txtName, buyName ve SellName nesnelerini sil
• EditCreate fonksiyonunu çağır
• Alış düğmesi için ButtonCreate fonksiyonunu çağır
• Satış düğmesi için ButtonCreate fonksiyonunu çağır

//+------------------------------------------------------------------+
//|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
  }

lotSize için kullanılan lotTxt adlı tek parametreye sahip bir void setLot fonksiyonu oluşturalım. Fonksiyonun gövdesi şöyle olacaktır:

• double türünde newLot değişkeni oluştur ve StringToDouble fonksiyonunu kullanarak string'ten double'a dönüştürdükten sonra lotTxt değerini ata
• newLot değişkeninin 0'dan küçük olup olmadığını kontrol et ve eğer öyleyse, “Invalid Volume Specified” mesajını yazdır ve ardından return kullan
• lotSize değerini newLot olarak ayarla

void setLot(string lotTxt)
  {
   double newLot=StringToDouble(lotTxt);
   if(newLot<0)
     {
      Print("Invaid Volume Specified");
      return;
     }
   lotSize=newLot;
  }

Aşağıdaki adımları izleyerek EditCreate fonksiyonunu oluşturalım.

//+------------------------------------------------------------------+
//|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);
  }

ButtonCreate fonksiyonunu küçük farklılıklarla EditCreate fonksiyonuna benzer şekilde oluşturalım:

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);
  }

Kodu derledikten ve çalıştırdıktan sonra panel aşağıdaki gibi görünür:

Gördüğümüz gibi, sol üst köşede lot büyüklüğü ve Buy ve Sell şeklinde iki düğme içeren bir panelimiz var. İhtiyacımız olan lot büyüklüğünü belirleyebilir ve Buy veya Sell düğmesine tıklayarak bir emir yerleştirebiliriz. Şimdi karşılaştırma için panel ve iletişim kutusu sınıflarını kullanarak aynı paneli oluşturalım.

Sınıfları kullanan grafiksel panel

Paneli oluşturmak için aşağıdaki adımları takip edelim.

Bileşenlerini programımızda kullanmak için ihtiyaç duyduğumuz dosyaları veya sınıfları dahil edelim: Dialog, Button, Edit ve Trade. Bu, bildiğimiz gibi #include komutu kullanılarak yapılabilir.

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

Sabitlere anımsatıcı adlar atamak için bir önişlemci yönergesi olan #define makro ikamesini kullanalım.

• 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"

Sınıflardan aşağıdaki gibi nesneler oluşturalım.

CAppDialog panel;
CButton buyBtn;
CButton sellBtn;
CButton closeBtn;
CEdit lotSize;
CTrade trade;

OnInit() kısmında, oluşturduğumuz panel.Create nesnemizi kullanarak panel nesnemizi oluşturmamız gerekiyor. Parametreleri şunlardır:

• const long chart - paneli ana grafikte göstermek için 0 kullanacağız
• const string name - PANEL_NAME kullanacağız
• const int subwin - 0 kullanacağız
• const int x1 - 10 kullanacağız
• const int y1 - 20 kullanacağız
• const int x2 - 10+PANEL_WIDTH+8 kullanacağız
• const int y2 - 20+PANEL_HIEIGHT kullanacağız

panel.Create(0,PANEL_NAME,0,10,20,10+PANEL_WIDTH+8,20+PANEL_HIEIGHT);

Alış ve satış düğmelerini oluşturalım ve yapılandıralım:

• object.Create kullanarak nesneleri oluştur
• object.Width kullanarak alış ve satış düğmesi nesnelerinin genişliğini ayarla
• object.Height kullanarak alış ve satış düğmesi nesnelerinin yüksekliğini ayarla
• object.ColorBackground kullanarak nesnelerin arka plan rengini ayarla
• object.Text kullanarak nesnelerin metnini ayarla
• object.Font kullanarak nesnelerin yazı tipini ayarla
• object.FontSize kullanarak nesnelerin yazı tipi boyutunu ayarla
• object.Color kullanarak nesnelerin rengini ayarla
• object.ColorBorder kullanarak nesnelerin kenar rengini ayarla
• Nesnelerin nesnesini panel üzerine yerleştir
• Paneli başlat

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);
  }

OnDeinit(const int reason) kısmında, aşağıda gösterildiği gibi Destroy'u sonlandırma fonksiyonu olarak kullanıyoruz.

void OnDeinit(const int reason)
  {
   panel.Destroy();
  }

OnChartEvent() fonksiyonunu kullanarak panel ile etkileşimi sağlayalım ve alış ve satış düğmelerinin davranış koşullarını ayarlayalım:

• OnChartEvent() fonksiyonunu oluştur
• Fonksiyon gövdesi:
• Olay kimliği için id, long türündeki olay parametresi için lparam, double türündeki olay parametresi için dparam ve string türündeki olay parametresi için sparam parametreleri ile object.ChartEvent kullan
• Kimliğin grafikteki tıklamaya eşit olup olmadığını kontrol et
• sparam'ın buyBtn veya SellBtn adlarına eşit olup olmadığını kontrol et
• double türünde lot değişkeni oluştur ve ona StringToDouble (lot büyüklüğü) değerini ata
• Lot değerini kullanarak olay türüne göre bir alış veya satış emri aç

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);
           }
     }
  }

Kodu derleyip çalıştırdıktan sonra grafikte paneli göreceğiz:

Gördüğümüz gibi, sol üst köşede lot büyüklüğü, alış ve satış nesnelerini içeren bir panele sahibiz. Lot büyüklüğünü düzenleyebilir ve emir açabiliriz.

Aynı paneli iki farklı yöntemle oluşturduktan sonra, sınıfları kullanarak bir panel oluşturmanın daha kolay ve kullanışlı olduğunu görüyoruz. Yani, sınıflar çok yararlıdır ve bize çok zaman kazandırır. Ancak, yeni başlayan bir programcıysanız, sınıflar veya yerleşik fonksiyonlar gibi hazır materyallerin nasıl oluşturulduğunu öğrenmeye ve anlamaya çalışın. Bu, programlama becerilerinizi geliştirmek için çok iyi bir yoldur.

Oluşturacağınız panele daha fazla özellik ekleyerek onu geliştirebilirsiniz. Çünkü panel yukarıda tasarladığımız kadar basit veya çok karmaşık olabilir ve daha fazla araç ve işlevsellik içerebilir.

Sonuç

Sınıflar, genel olarak ve özellikle MetaTrader 5'te kullanılabilecek paneller oluştururken değerli ve kullanışlı bir araçtır. Bu, yatırımcıların alım-satıma daha fazla odaklanmasını sağlar. Panellerin ne olduğunu öğrendik, türlerini inceledik ve iki şekilde basit bir panel oluşturduk, panel ve iletişim kutusu sınıflarını kullanmanın işi nasıl hızlandırdığını ve basitleştirdiğini gördük.

Makaleyi faydalı bulduğunuzu ve sunulan bilgilerin anlaşılması ve uygulanması kolay olduğunu umuyorum. Ayrıca, alım-satımınız için yararlı olabilecek paneller dahil olmak üzere uygulama geliştirme hakkında daha fazla bilgi edindiğinizi umuyorum.

Sınıflar ve nesneler hakkında daha fazla bilgi edinmek istiyorsanız, “MQL5’te Nesne Yönelimli Programlama (Object-Oriented Programming, OOP)” başlıklı önceki makalemi okumanızı tavsiye ederim. Makaleyi beğendiyseniz ve faydalı bulduysanız, en popüler teknik göstergelere dayalı alım-satım sistemlerinin nasıl geliştirildiği konulu önceki makalelerimi okuyabilirsiniz.