Özel Grafik Kontrolleri. Kısım 1: Basit Kontrol Oluşturma

Giriş

MQL5 dili geliştiricilere programlı olarak kontrol edilen çok çeşitli grafik nesneler sunar: bir düğme, bir metin etiketi, bir düzenleme alanı, bir bitmap etiketi (şekil 1), analiz için farklı grafik araçlar (şekil 2).

Şekil 1. Grafik nesneler: bir düğme, bir metin etiketi, bir düzenleme alanı, bir bitmap etiketi

Şekil 2. Analiz için bazı grafik nesneler: bir elips, Fibonacci Fanı, Fibonacci Genişlemesi

MetaTrader 5 istemci terminalinde toplamda kırkın üzerinde grafik nesne vardır. Tüm bu nesneler ayrı olarak kullanılabilir, ancak daha sık birbirine bağlı nesneler zincirinde kullanılırlar. Örneğin, bir düzenleme alanı (OBJ_EDIT) kullanıldığında, düzenleme alanının fonksiyonunu belirtmek için bununla birlikte bir bitmap etiketi (OBJ_LABEL) kullanılır.

Düzenleme alanı kullanırken, genellikle bir kullanıcı tarafından veri girişinin doğruluğunu kontrol etmeniz ve ondalık ayırıcı olarak hem nokta hem de virgül kullanma imkanı sağlamanız gerekir.

Verilerin programlı çıkışını kullanırken, verileri biçimlendirmeniz gerekir. Örneğin, gereksiz sıfırları silmelisiniz. Bu nedenle, düzenleme alanını, bitmap etiketini ve diğer bazı fonksiyonel özellikleri içeren tek bir nesneye sahip olmak daha kolay olacaktır.

Mevcut olarak, programlama dünyasında hemen hemen her uygulamada kullanılan belirli bir grafiksel kontrol seti vardır: bir form (tüm kontrol öğelerinin bulunduğu bir uygulama arayüzünün tabanı), bir çerçeve (tek bir fonksiyonel amacı olan öğe setlerini gruplandırmayı ve ayırmayı sağlar), bir düğme, bir düzenleme alanı, bir etiket, bir onay kutusu, radyo düğmeleri, dikey ve yatay kaydırma çubukları, bir liste, bir açılır liste, bir menü satırı, bir menü sekmesi (şek. 3). 

 
Şekil 3. En yaygın standart kontrollere sahip form

Yukarıda belirtilen öğelerin MQL5'te gösterilme şekli diğer programlama dillerine (bir düğme ve bir düzenleme alanı) benzer. Cephaneliğinizde başka yaygın kontrollere sahip olmak uygun olacaktır.

Çeşitli geliştirme ortamları, programcılara özel kontrollerin oluşturulması için özel araçlar sağlar. MQL5 böyle bir özellik sağlamaz. Ancak, MQL5 bir nesne yönelimli dil olduğundan , buna sahip olmak gerekmez. Her şey ayrı programlanmış nesneler şeklinde yapılabilir.

Özel kontrollerin oluşturulmasına ilişkin ilkeler ve metodoloji bu makalede daha ayrıntılı olarak ele alınacaktır. Temel olarak, programlamada yetenekli olan herkes, uygulamalarda tekrar tekrar kullanılabilecek gerekli kontrol setini oluşturabilir.

1. Bir Grafik Kontrol Nasıl Olmalıdır?

1.1. Genel Gereksinimler ve İlkeler

Yararlı olmak için, grafik kontrolleri uygulamaların geliştirilmesini kolaylaştırmalıdır. Bu nedenle, aşağıdaki gereksinimleri karşılamaları gerekir:

1. Geliştirme sırasında hızlı bir şekilde bir kontrol oluşturmak mümkün olmalıdır. Bu sorun, programlamaya nesne yönelimli yaklaşım kullanılarak çözülür. Bir grafik kontrolü programlanmış bir nesne olarak temsil edilir.
    
   
2. Bir kontrol esnek olmalıdır. Başka bir deyişle, özelliklerini değiştirmek mümkün olmalıdır: boyut, konum, renk vb.
    
   
3. Bir kontrolün kullanımı kolay olmalıdır - yalnızca amacı öğenin amacından ve yöntemlerin adlarından anlaşılabilir olan gerekli özelliklere ve yöntemlere sahip olmalıdır. Şimdi kontrollerin özelliklerini kategorilere ayıralım:
    
   
1. Kontrolsüz özellikler. Bu özellikler renk şemasını içerir. Bir uygulamada kullanılan tüm kontrollerin genel bir stili olmalıdır. Bu nedenle her kontrol için ayrı ayrı renk ayarı yorucu olacaktır.
   Buna ek olarak, bazı kontroller için bir renk aramak, zaman kaybetmek istemediğim kadar zor bir iştir. Örneğin, bir kaydırma çubuğu. Bazı web geliştiricileri bu ilginç görevle karşılaşmış olabilir.
    
   
2. Bir kontrolün oluşturulması aşamasında ayarlanan özellikler veya nadiren değiştirilen özellikler. Örneğin, bir kontrolün boyutu. Bir uygulamada kullanılan tüm kontrollerin dengeli ve kullanışlı konumu, arayüzü oluşturma aşamasında çözülen özel ve zor bir iştir.
   Bununla bağlantılı olarak, program çalışması sırasında kontrollerin boyutu genellikle değiştirilmez. Ancak, bazen bu tür özellikleri değiştirmeniz gerekebilir. Bu nedenle, programın çalışması sırasında bu özellikleri değiştirme olanağı sağlamalısınız.
    
   
3. Ana işlemsel özellikler. Sık sık programdan değiştirilen özellikler. Bir kontrolün amacını oluşturan özellikler. Bu özellikler iki kategoriye ayrılabilir:
    
   
1. Bir kontrolün görüntülenmesini otomatik olarak güncelleyen özellikler. Örneğin, bir düzenleme. Program tarafından bir değer ayarlandıktan sonra, değişiklikler ekranda görüntülenmelidir. Programlamada, tek bir kod satırı kullanılarak gerçekleştirilmelidir.
    
   
2. Görüntülemenin zorunlu olarak yenilenmesini gerektiren özellikler. Örneğin, bir liste. Listeler veri dizileriyle çalışmayı ima eder, bu yüzden listenin tek bir öğesiyle çalıştıktan sonra bir listenin yenilenmesi gerekmez. Burada, listenin tüm öğeleriyle çalışma bittiğinde zorunlu bir güncelleme yapmak daha iyidir. Bu yaklaşım uygulama performansını önemli ölçüde artırır.
    
   
4. Kontrolün hızlı ve basit bir şekilde gizlenmesi ve gösterilmesi olasılığı. Kontrolü görünür hale getirmek, görüntüleme özelliklerinin tekrarlanan ayarını gerektirmemelidir; nesne özelliklerine erişim, bu kontrolün grafik nesnelerinin görünürlüğünden bağımsız olmalıdır. Başka bir deyişle, programlanmış bir nesne, kontrolün tüm özelliklerini içermeli ve grafik nesnelerin özelliklerini kullanmamalıdır.
     
   
5. Kontrole karşılık gelen olayların çıkışına sahip olmak için, kontrole dahil edilen ayrı grafik nesnelerin etkinliklerin işlenmesi gerekir.
   

1.2. Bir Kontrolü ve Gerekli Yöntemleri Kullanma Şekli 

Yukarıda belirtilen gereksinimleri göz önünde bulundurarak, grafiksel bir arayüzün yanı sıra programlanmış bir nesnenin gerekli özellikleri ve yöntemleri setinin oluşturulması için aşağıdaki şemaya sahibiz:

1. Bir kontrolün başlatılması ve nadiren değiştirilen özelliklerin paralel ayarı. Bu yöntem Init() olarak adlandırılır; birkaç parametresi vardır. 1. zorunlu parametre - bir kontrolün adı. Bu parametre, kontrolde bulunan tüm grafik nesnelerinin adları için önek olarak kullanılacaktır. Ayrıca, kontrolün boyutunu ayarlayan parametreler ve diğer parametreler dahil edilebilir (kontrolün amacına bağlı olarak).
    
   
2. Kontroller bir grafikte sabit bir konuma sahip olabileceği gibi, taşınma olasılığı da gerektirebilir. Bu yüzden koordinatları belirlemek için ayrı yöntemler kullanacağız: SetPosLeft() - X koordinatını ayarlama, SetPosTop() - Y koordinatını ayarlama. Bu yöntemlerin her birinin bir parametresi olmalıdır. Çoğu zaman her iki koordinatı da değiştirmek gerekir, bu nedenle SetPos() yönteminin hem X hem de Y koordinatlarını aynı anda değiştiren iki parametresi olması iyidir.
   Kontrolün konumunu hesaplamak için, başka bir kontrolün boyutu ve konumu hakkında bilgi almanız gerekebilir. Bu amaçla aşağıdaki yöntemleri kullanacağız: Width() - genişlik, Height() - yükseklik, Left() - X koordinatı, Top() - Y koordinatı. İşlemin bu aşamasında, kontrolün koordinatları hesaplanır ve bunları ayarlama yöntemleri çağrılır.
    
   
3. Oluşturulduktan hemen sonra veya uygulamanın başka bir çalışma aşamasında, kontrolü görünür hale getirmemiz gerekir. Bunu yapmak için Show() yöntemi kullanılır. Kontrolü gizlemek için Hide() yöntemi kullanılır.
    
   
4. Daha önce de belirtildiği gibi, programın çalışması sırasında kontrolün boyutunu değiştirmemiz gerekebilir. Bu nedenle, programlanan nesnenin boyutu ayarlamak için ayrı yöntemleri olmalıdır - SetWidth() ve/veya SetHeght(). Bunlar nadiren değiştirilen özellikler olduğundan, değişikliklerin etkili olmasını sağlamak için görüntülemeyi güncelleyen Refresh() yöntemini uygulamamız gerekir.
   
   
5. Ayrı grafik nesnelerin etkinlikleri, kontrolün belirli bir etkinliğine karşılık gelen bir değer verecek Event() yönteminde işlenir. Event() yöntemi OnChartEvent() fonksiyonundan çağrılmalıdır; OnChartEvent() fonksiyonuyla aynı parametre setine sahip olacaktır.

Böylece programlanmış bir nesnenin gerekli yöntemler setini elde ederiz:

• void Init(string aName...) - kontrolün başlatılması;
  
• void SetPosLeft(int aLeft) - X koordinatının ayarı;
• void SetPosTop(int aTop) - Y koordinatının ayarı;
• void SetPos (int aLeft, int aTop) - X ve Y koordinatlarının eşzamanlı ayarı;
• void SetWidth(int aWidth) - genişlik ayarı;
• void SetHeght(int aHeight) - yükseklik ayarı;
• int Width() - genişliği alma;
• int Height() - yüksekliği alma;
• int Left() - X koordinatını alma;
• int Top() - Y koordinatını alma;
• void Refresh() - görüntülemenin tam yenilenmesi;
• void Show() - gösterme;
• void Hide() - gizleme;
• int Event(const int id, const long & lparam, const double & dparam, const string & sparam) - grafik etkinliklerinin işlenmesi;
  

Diğer yöntemlerin varlığı (veya listelenen yöntemlerden bazılarının yokluğu) kontrolün kendisine ve amacına bağlıdır.

Bu makalenin ilerleyen bölümlerinde yukarıda açıklanan ilkeleri uygulamaya çalışacağız - bir kullanıcının bir metin veya sayı girmesi için bir kontrol oluşturacağız.

Bundan önce, grafik nesnelerle hızlı ve rahat çalışma için kendimize araçlar sağlamamız gerekir.

2. Grafik Nesnelerle Hızlı ve Rahat Bir Şekilde Çalışma

Grafik nesnelerle çalışmak için, MQL5 aşağıdaki temel fonksiyonları sağlar: ObjectCreate(), ObjectDelete(), ObjectSetDouble(), ObjectSetInteger(), ObjectSetString(), ObjectGetDouble(), ObjectGetInteger(), ObjectGetString(). Bu fonksiyonları doğrudan kullanabiliriz, ancak programlama süreci çok zahmetli ve uzun olacaktır. Fonksiyonların uzun adları vardır; uzun adları olan birçok tanımlayıcı fonksiyonlara geçirilmelidir.

Grafik nesnelerle çalışmayı daha kullanışlı hale getirmek için, MetaTrader 5 istemci terminal paketinde (MQL5/Include/ChartObjects/ChartObject.mqh dosyasından CChartObject sınıfı) bulunan hazır bir sınıf kullanabilir veya kendi sınıfımızı yazıp gerekli tüm yöntemleri verebiliriz.

Şakayla karışık, programlamaya yönelik bu yaklaşım, bir tuşa basma ve sonrasında bir noktadan oluşur. Bir nesnenin adını belirttikten sonra nokta koymak için bırakılır ve özelliklerinin ve yöntemlerinin listesi açıktır; sadece listeden gerekli bir öğeyi seçin (şekil 4).

Şekil 4. Nesnenin özelliklerinin ve yöntemlerinin listesi

Yardımcı sınıfı kullanarak bir grafik nesneyi yönetmenin iki çeşidi vardır:

1. Her grafik nesnesi için ayrı bir sınıf örneği oluşturulur. Tüketilen bellek açısından oldukça uygun ama ekonomik olmayan bir yöntem. Bu varyant için, her grafik nesnesi türü için özel sınıflar yazmak daha iyidir. Ancak bu yaklaşım çok zahmetli olduğu için optimum değildir. Uzman Danışmanların (EA) programlanmasından farklı olarak, bir kullanıcı arayüzü oluştururken maksimum performans için katı bir gereklilik yoktur.
   
2. Bir sınıf örneği kullanın. Bir grafik nesneyi yönetmek gerekiyorsa, nesne sınıfa eklenir. İkinci varyantı kullanacağız.

Grafik nesneleri yönetmenin ikinci türü için en uygun, evrensel bir sınıf oluşturalım.

3. Grafik Nesneleri Yönetmek için Evrensel Sınıf

Programlama sırasında, her grafik nesneyle yapılan çalışma üç aşamadan oluşur: oluşturma, özellikleri okuma/ayarlama, uygulamanın çalışması bittiğinde silme.

Bu nedenle, her şeyden önce, grafik nesneleri yönetmek için sınıf bunları oluşturan yöntemleri içermelidir. Bir grafik nesnenin oluşturulması için zorunlu bir parametre adıdır; bu nedenle, nesnelerin oluşturma yöntemleri, oluşturulan bir nesnenin adını belirtmek için zorunlu bir parametreye sahip olacaktır.

Genellikle, grafik nesneler, programın (Uzman Danışman (EA), Gösterge veya Komut Dosyası) çalıştırıldığı grafikte oluşturulur. Daha nadir bir durum bir alt penceredir ve daha da nadir bir durum terminalin başka bir grafik penceresidir. Bu nedenle, ikinci isteğe bağlı parametre, bir alt pencere numarasını belirten parametre olacaktır ve üçüncüsü bir grafiğin tanımlayıcısıdır.

Varsayılan olarak, her iki isteğe bağlı parametre de 0'a eşit olacaktır (fiyat grafiği "kendi" grafiğindedir). Belgelerdeki grafik nesne türlerinin listesini arayın. Her tür için Create yöntemini ekleyin.

Bundan önce bir dosya oluşturmamız gerekir. Bunu yapmak için MetaEditor'u açın, yeni bir içerme dosyası oluşturun ve IncGUI.mqh olarak adlandırın. Açık dosyada, korumalı ve ortak bölümlerle CGraphicObjectShell sınıfını oluşturun. Korumalı bölümde, bir nesnenin adı ve grafiğin tanımlayıcısı için değişkenler bildirin.

Nesnelerin oluşturma yöntemlerinde, bu değişkenlere, bir ad ve grafik tanımlayıcısı belirtmeden nesne oluşturulduktan sonra bunları yönetme olanağına sahip olmak için yöntemler tarafından geçirilen değerler parametre olarak atanacaktır. Böylece sınıfı grafik nesneleri yönetmenin ilk varyantı için de kullanabiliriz.

İkinci varyant için sınıfı kullanma olanağına sahip olmak için (herhangi bir grafik nesneyi yönetmek için), buna bir grafik nesneyi ekleme (Attach() yöntemi) yöntemi verin. Bu yöntemin bir zorunlu parametresi - grafiksel adı - ve isteğe bağlı bir parametresi - bir grafik tanımlayıcısı - olacaktır. Ekli bir grafik nesnenin adını ve tanımlayıcısını bilmeniz gerekebilir. Bunu yapmak için, nesneye aşağıdaki yöntemleri ekleyin: Name() ve ChartID().

Sonuç olarak, sınıfın aşağıdaki "iş parçasını" alırız: 

class CGraphicObjectShell
  {
protected:
   string            m_name;
   long              m_id;
public:
   void Attach(string aName,long aChartID=0)
     {
      m_name=aName;
      m_id=aChartID;
     }
   string Name()
     {
      return(m_name);
     }    
   long ChartID()
     {
      return(m_id);
     }
  };

Grafik nesnelerin oluşturulması için yukarıda belirtilen yöntemleri ekleyin. Bu yöntemlerin adları "Create" ile başlayacaktır.

Okuyucular bunu atlayabilir, makaleye eklenen IncGUI.mqh dosyası hazır CGraphicObjectShell sınıfını içerir.

Örnek olarak, dikey çizgi grafik nesnesinin oluşturulmasının bir yöntemi verilmiştir (OBJ_VLINE):

void CreateVLine(string aName,int aSubWindow=0,long aChartID=0)
  {
   ObjectCreate(m_id,m_name,OBJ_VLINE,aSubWindow,0,0);
   Attach(aName,aChartID);
  }

Şimdi kullanıcı kılavuzunda grafik nesnelerin özelliklerinin listesini açın ve ObjectSetDouble(), ObjectSetInteger() ve ObjectSetString() fonksiyonlarını kullanarak her özellik için bir değer ayarlama yöntemlerini yazın. Yöntemlerin adı "Set" ile başlayacaktır. Ardından, ObjectGetDouble() ve ObjectGetInteger() fonksiyonlarını kullanarak özellikleri okumak için yöntemler yazın. ObjectGetString().

Örnek olarak, rengi ayarlama ve alma yöntemleri şunlardır:

void SetColor(color aColor)
  {
   ObjectSetInteger(m_id,m_name,OBJPROP_COLOR,aColor);
  }
color Color()
  {
   return(ObjectGetInteger(m_id,m_name,OBJPROP_COLOR));
  }

Şimdi grafik nesnelerle çalışmak için gerekli minimum araçlara sahibiz gibi görünüyor, ancak hepsine sahip değiliz.

Bazen bir grafik nesneyle çalışırken, bir nesneyle yalnızca bir eylem gerçekleştirmeniz gerekebilir. Bu durumda, nesne için Attach() yöntemini yürütmek ve sonra ana nesneye dönmek ve bunun için yeniden Attach() yürütmek uygun olmayacaktır.

Sınıfa tüm özellikleri ayarlama/alma yöntemlerinin iki çeşidini daha ekleyelim.

Birincisi - "kendi" grafiğindeki ada göre:

void SetColor(string aName,color aColor)
  {
   ObjectSetInteger(0,aName,OBJPROP_COLOR,aColor);
  }
color Color(string aName)
  {
   return(ObjectGetInteger(0,aName,OBJPROP_COLOR));
  }

İkincisi - bir grafiğin adına ve tanımlayıcısına göre:

void SetColor(long aChartID,string aName,color aColor)
  {
   ObjectSetInteger(aChartID,aName,OBJPROP_COLOR,aColor);
  }
color Color(long aChartID,string aName)
  {
   return(ObjectGetInteger(aChartID,aName,OBJPROP_COLOR));
  }

ObjectGet... ve ObjectSet... fonksiyonlarına ek olarak, grafik nesnelerle çalışmak için başka fonksiyonlar da vardır: ObjectDelete(), ObjectMove(), ObjectFind(), ObjectGetTimeByValue(), ObjectGetValueByTime(), ObjectsTotal(). Ayrıca, her birinin üç çağrı varyantı olan sınıfa eklenebilirler.

Son olarak, bu dosyada basit ve kısa bir ad "g" ile CGraphicObjectShell sınıfını belirtin. 

CGraphicObjectShell g;

Şimdi, grafik nesnelerle çalışmaya başlamak için IncGUI.mqh dosyasını bağlamak yeterlidir; böylece çalışmak için "g" sınıfına sahip olacağız. Bunu kullanarak, mevcut tüm grafik nesneleri yönetmek kolaydır.

4. Kontroller için İş Parçaları

Grafik nesnelerle hızlı çalışma sınıfına sahip olmamıza rağmen, kontrolleri daha kolay bir şekilde oluşturabiliriz. Tüm kontroller dört grafik nesne temelinde oluşturulabilir:

1. Dikdörtgen etiket (OBJ_RECTANGLE_LABEL),
2. Metin etiketi (OBJ_LABEL),
   
3. Düzenleme alanı (OBJ_EDIT),
   
4. Düğme (OBJ_BUTTON).

Grafik nesnelerin oluşturulmasından sonra, bunlar için birçok özellik ayarlanmalıdır: koordinatlar, boyut, renk, yazı tipi boyutu vb. İşlemi hızlandırmak için, başka bir sınıf oluşturalım ve adını CWorkPiece (iş parçaları) koyalım ve buna parametrelerle geçirilen özelliklere sahip grafik nesnelerin oluşturulması için yöntemler sağlayalım. 

Kontrollerin çalışması için grafik etkinliklerini işlemeniz gerekir. Diğer grafiklerin etkinlikleri mevcut değildir, bu nedenle yalnızca kendi grafiğiyle çalışacağız - CWorkPiece sınıfının yöntemlerinin parametrelerinde hiçbir grafik tanımlayıcısı olmayacaktır. 0 (kendi grafiği) her yerde kullanılacaktır.

Bir alt pencere numarası belirten parametre, hem fiyat grafiğinde hem de bunun alt pencerelerinde kontrollerin oluşturulması olasılığını sağlamak için kullanılır. Grafik nesneler yalnızca sol üst köşeye bağlanır; bir kontrolü görece başka bir köşeye yerleştirmek gerekiyorsa, grafik boyutu göz önüne alarak tüm kontrolün koordinatlarını yeniden hesaplamak çok daha kolaydır. Grafiğin boyut değişikliklerini kontrol etmek için CHARTEVENT_CHART_CHANGE etkinliğini işleyebilirsiniz.

Birçok kontrol için temel olarak, "Dikdörtgen etiket" nesnesini kullanacağız; bu nesnenin oluşturma yöntemini CWorkPiece sınıfına ekleyeceğiz; yöntem Canvas() olarak adlandırılır:

void Canvas(string aName="Canvas",
             int aSubWindow=0,
             int aLeft=100,
             int aTop=100,
             int aWidth=300,
             int aHeight=150,
             color aColorBg=clrIvory,
             int aColorBorder=clrDimGray)
  {
   g.CreateRectangleLabel(aName,aSubWindow); // Creation of rectangle label
   g.SetXDistance(aLeft);                    // Setting of the X coordinate
   g.SetYDistanse(aTop);                        // Setting of the Y coordinate
   g.SetXSize(aWidth);                          // Setting of width
   g.SetYSize(aHeight);                         // Setting of height
   g.SetBgColor(aColorBg);                   // Setting of background color
   g.SetColor(aColorBorder);                 // Setting of border color
   g.SetCorner(CORNER_LEFT_UPPER);             // Setting of a anchor point
   g.SetBorderType(BORDER_FLAT);             // Setting of border type
   g.SetTimeFrames(OBJ_ALL_PERIODS);            // Setting visibility at all timeframes
   g.SetSelected(false);                        // Disabling selection
   g.SetSelectable(false);                   // Disabling of selection possibility
   g.SetWidth(1);                               // Setting of border width
   g.SetStyle(STYLE_SOLID);                  // Setting of border style
  }

Dikkat edin: yöntem 14 kod satırından oluşur; bu nesneyi her oluşturduğunuzda hepsini yazmak çok sinir bozucu olurdu. Artık sadece bir satır yazmak yeterlidir, yöntemin tüm parametreleri isteğe bağlıdır ve kullanım sıklığı sırasına göre listelenir: konum, boyut, renk vb.

Canvas() yöntemine benzer şekilde, bir metin etiketi, bir düğme ve bir düzenleme alanı oluşturma yöntemlerini yazın: Label(), Button() ve Edit(). Hazır sınıf CWorkPiece, IncGUI.mqh dosyasındaki makaleye eklenmiştir. Yukarıda belirtilen yöntemlere ek olarak, sınıf birkaç başka yöntem içerir: Frame() ve DeleteFrame() - bir çerçeve oluşturma ve silme yöntemleri (şekil 5). Çerçeve, sol üst köşede resim yazısı bulunan dikdörtgen bir etikettir.

Çerçeveler, kontroller bir formda gruplandırırken kullanılmak üzere planlanır.

Şekil 5. Resim yazısı olan çerçeve.

CWorkPiece sınıfının tüm yöntemlerinin listesi makaleye eklenmiştir.

CGraphicObjectShell sınıfına benzer şekilde, IncGUI.mqh dosyasını bağladıktan hemen sonra kullanabilmek için "w" kısa adlı CWorkPiece sınıfını belirtin.

CWorkPiece w;

Tüm yardımcı araçlar hazır, bu yüzden makalenin konusuna devam edebiliriz - özel bir kontrol oluşturma.

5. Bir "Düzenleme" Kontrolü Oluşturma

Her şeyden önce, terminolojiyi karıştırmamak için, OBJ_EDIT grafik nesnesini metin alanı, OBJ_LABEL nesnesini etiket olarak ve oluşturulan kontrolleri düzenleme alanı olarak adlandıralım. Oluşturulan kontrol iki grafik nesneden oluşur: bir düzenleme alanı (OBJ_EDIT) ve bir metin etiketi (OBJ_LABEL).

Kontrol iki çalışma modunu destekleyecektir: metin verilerinin girişi ve nümerik verilerin girişi. Nümerik verilerin girişi modunda, giriş değerleri aralığında bir sınırlama olacaktır ve ondalık ayırıcılar olarak hem virgül hem de nokta kabul edilebilir olacaktır. Düzenleme alanındaki bir değerin programlanmış çıkışında, belirtilen sayıda ondalık basamaklara göre biçimlendirilir.

Bu nedenle, bir kontrolü başlatırken, çalışma modunu belirtmemiz gerekir: metin veya nümerik; mod aDigits parametresi kullanılarak belirtilir. Sıfırdan büyük bir değer, nümerik modu belirtilen ondalık basamak sayısıyla ayarlar, negatif bir değer metin modunu ayarlar.

Varsayılan olarak, kabul edilebilir değerler aralığı -DBL_MAX ila DBL_MAX (çift değişkenin tüm değer aralığı) arasındadır. Gerekirse, SetMin() ve SetMax() yöntemlerini uygulayarak başka bir aralık ayarlayabilirsiniz. Boyut parametreleri arasında, kontrol için yalnızca genişlik ayarlanır. Düzenleme alanının dengeli görünmesi için, bunun için karşılık gelen bir yükseklik ve genişlik ayarlanmalıdır.

Yazı tipi boyutunun değiştirilmesi, grafik nesnenin ilgili yükseklik değişikliğini gerektirir. Ve bu, diğer tüm kontrollerin yerini değiştirmeyi gerektirir; kimse böyle bir şey yapmaz. Tüm kontroller ve karşılık gelen düzenleme alanları için sabit bir yazı tipi boyutu kullanıldığını varsayarız. Ancak, kontrolün sınıfı, diğer öğelerin koordinatlarının hesaplanmasında kolaylık sağlamak için yüksekliğini veren bir yönteme sahip olacaktır.

Dört renk parametresi olacaktır: arka plan rengi, metin rengi, resim yazısı rengi ve uyarı rengi (örneğin, yanlış bir değer girilmesi durumunda, kullanıcının dikkatini çekmek için metin alanının arka plan rengini değiştirmek mümkün olacaktır).

Daha önce de belirtildiği gibi, bir alt penceredeki kontroller desteklenir. Bir kontrolün çalışması için gereken ana parametrelere ek olarak, Tag diğer parametresini kullanacağız; bu, sınıfın bir örneğinde depolanan basit bir metin değeridir. Bir etiket kullanışlı bir yardımcı araçtır.

Sınıf CInputBox olarak adlandırılacaktır. Bu nedenle, sınıfın aşağıdaki değişken setine sahibiz (özel bölümde bulunur):

string m_NameEdit;    // Name of the Edit object
string m_NameLabel;   // Name of the Label object
int m_Left;           // X coordinate
int m_Top;            // Y coordinate
int m_Width;           // Width
int m_Height;          // Height
bool m_Visible;        // Visibility flag of the control
int m_Digits;          // Number of decimal places for the double number; -1 set the text mode
string m_Caption;      // Caption
string m_Value;        // Value
double m_ValueMin;     // Minimum value
double m_ValueMax;     // Maximum value
color m_BgColor;       // Background color
color m_TxtColor;     // Text color
color m_LblColor;      // Caption color
color m_WarningColor; // Warning font color
bool m_Warning;        // Flag of warning
int m_SubWindow;       // Subwindow
string m_Tag;           // Tag

Kontrol kullanırken, uygulanan ilk yöntem Init() yöntemidir.

Bu yöntemde, daha önce belirlenen tüm parametrelerin değerlerini hazırlarız:

// The initialization method
void Init(string aName="CInputBox",
           int aWidth=50,
           int aDigits=-1,
           string aCaption="CInputBox")
 { 
   m_NameEdit=aName+"_E";  // Preparing the name of the text field
   m_NameLabel=aName+"_L"; // Preparing the caption name
   m_Left=0;                 // X coordinate
   m_Top=0;                  // Y coordinate
   m_Width=aWidth;          // Width
   m_Height=15;             // Height
   m_Visible=false;         // Visibility
   m_Digits=aDigits;       // The mode of operation and the number of decimal places
   m_Caption=aCaption;     // Caption text
   m_Value="";              // Value in the text mode
   if(aDigits>=0)m_Value=DoubleToString(0,m_Digits); // Value in the numeric mode
   m_ValueMin=-DBL_MAX;                   // Minimal value
   m_ValueMax=DBL_MAX;                  // Maximal value
   m_BgColor=ClrScheme.Color(0);       // Background color of the text field
   m_TxtColor=ClrScheme.Color(1);      // Color of text and frame of the text field
   m_LblColor=ClrScheme.Color(2);      // Caption color
   m_WarningColor=ClrScheme.Color(3); // Warning color
   m_Warning=false;                      // Mode: warning, normal
   m_SubWindow=0; // Number of subwindow
   m_Tag=""; // Tag
 }

Bir kontrol metin modunda çalışıyorsa m_Value değişkeni “” değerine atanır, nümerik modda çalışıyorsa belirtilen ondalık basamak sayısına sahip bir sıfır atanır. Renk parametreleri varsayılan değerlerine ayarlanır; son aşamada renk şemaları ile ilgileneceğiz.

Kontrolün koordinatlarını belirleyen değişkenler sıfır olarak ayarlanır, çünkü kontrol henüz görünür değildir. Init() yöntemini uyguladıktan sonra (kontrolün grafikte sabit bir konuma sahip olması planlanıyorsa) SetPos() yöntemini kullanarak koordinatları ayarlayabiliriz:

// Setting the X and Y coordinates
void SetPos(int aLeft,int aTop)
{ 
   m_Left=aLeft;
   m_Top=aTop;
}

Bundan sonra, kontrolü görünür hale getirebiliriz (Show() yöntemi):

// Enable visibility on the previously specified position
void Show()
{ 
   m_Visible=true; // Registration of visibility
   Create();       // Creation of graphical objects
   ChartRedraw();   // Refreshing of the chart
}

Create() fonksiyonu Show() yönteminden çağrılır; grafik nesneler oluşturur (özel bölümde bulunur), sonra grafik yenilenir (ChartRedraw()). Create() fonksiyonunun kodu aşağıda verilmiştir:

// The function of creation of graphical objects
void Create(){ 
   color m_ctmp=m_BgColor;  // Normal background color
      if(m_Warning){ // The warning method is set
         m_ctmp=m_WarningColor; // The text field will be color in the warning color
      }
    // Creation of the text field
   w.Edit(m_NameEdit,m_SubWindow,m_Left,m_Top,m_Width,m_Height,m_Value,m_ctmp,m_TxtColor,7,"Arial"); 
      if(m_Caption!=""){ // There is a caption
          // Creation of caption
         w.Label(m_NameLabel,m_SubWindow,m_Left+m_Width+1,m_Top+2,m_Caption,m_LblColor,7,"Arial"); 
      } 
}   

m_Warning değerine bağlı olarak Create() fonksiyonunda grafik nesneler oluştururken, metin alanına arka planın karşılık gelen rengi atanır. m_Caption değişkeninin bir değeri varsa, resim yazısı oluşturulur (resim yazısı olmadan bir kontrol oluşturabilirsiniz).

Hareketli bir kontrol yapmayı planlıyorsanız, koordinatları belirterek Show() yönteminin ikinci varyantını kullanın. Bu yöntemde, koordinatlar ayarlanır ve Show() yönteminin ilk varyantı çağrılır:

// Setting the X and Y coordinates
void SetPos(int aLeft,int aTop){ 
   m_Left=aLeft;
   m_Top=aTop;
}

Kontrol görüntülendikten sonra, bir süre bunu gizlemeniz gerekir.

Hide() yöntemi bu amaç için kullanılır:

// Hiding (deletion of graphical objects)
void Hide()
{ 
   m_Visible=false; // Registration of the invisible state
   Delete();        // Deletion of graphical objects
   ChartRedraw();    // Refreshing of the chart
}  

Hide() yöntemi, grafik nesneleri silen Delete() fonksiyonunu çağırır ve grafiği yenilemek için ChartRedraw() fonksiyonunu çağırır. Delete() fonksiyonu özel bölümdedir:

// The function of deletion of graphical objects
void Delete()
{ 
   ObjectDelete(0,m_NameEdit);  // Deletion of the text field
   ObjectDelete(0,m_NameLabel); // Deletion of caption
}   

Bir kontrolün görüntülenmesini değiştirmeden özelliklerin değerlerini ayarlayan bir yöntemle (SetPos() yöntemi) zaten tanıştığımız için, bir kontrolün zorla yenilenmesi için bir yöntem oluşturmak mantıklıdır - Refresh() yöntemi: 

// Refreshing of displaying (deletion and creation)
void Refresh()
{ 
   if(m_Visible)
   {   // Visibility enabled
      Delete();     // Deletion of graphical object
      Create();     // Creation of graphical objects
      ChartRedraw(); // Redrawing of the chart 
   }            
}   

Kontrol oldukça basittir, bu yüzden basit yenileme, silme ve oluşturma yöntemini kullanıyoruz. Birçok düzenleme alanından oluşan bir liste gibi daha karmaşık bir kontrol olsaydı, daha akıllı bir yaklaşım seçerdik.

Yani, kontrolü yerleştirmeyi bitirdik. Şimdi bir değer ayarlamaya devam edelim - SetValue() yöntemi. Kontrol iki modda çalışabildiğinden, SetValue() yönteminin iki varyantı olacaktır: dize ve double tip. Metin modunda, değer aşağıdaki gibi kullanılır:

// Setting a text value
void SetValue(string aValue)
{ 
   m_Value=aValue; // Assigning a value to variable to store it
      if(m_Visible)
      { // The visibility of the control is enabled
          // Assigning the text field to the object for managing graphical objects
         g.Attach(m_NameEdit); 
         g.SetText(m_Value); // Setting the value for the text field
         ChartRedraw();        // Redrawing the chart
      }
} 

Elde edilen argüman m_Value değişkenine atanır ve kontrol görünürse metin alanında görüntülenir.

Nümerik modda, elde edilen argüman m_Digits değerine göre normalleştirilir, daha sonra bir dizede dönüştürülen maksimum ve minimum değere (m_MaxValue, m_MinValue) göre düzeltilir ve sonra birinci SetValue() yöntemi çağrılır.

// Setting a number value
void SetValue(double aValue)
{ 
   if(m_Digits>=0)
   {  // In the numeric mode
       // Normalization of the number according to the specified accuracy
      aValue=NormalizeDouble(aValue,m_Digits);
      // "Alignment" of the value according to the minimal acceptable value
      aValue=MathMax(aValue,m_ValueMin); 
       // "Alignment" of the value according to the maximal acceptable value
      aValue=MathMin(aValue,m_ValueMax); 
       // Setting the obtained value as a string
      SetValue(DoubleToString(aValue,m_Digits)); 
   }
   else
   { // In the text mode
      SetValue((string)aValue); // Assigning the value to the variable to store it as is
   }            
}

Değerleri almak için iki yöntem yazalım: biri dize değeri almak için, diğeri double değeri almak içindir:

// Getting a text value
string ValueStrind()
{ 
   return(m_Value);
}

// Getting a numeric value
double ValueDouble()
{ 
   return(StringToDouble(m_Value));
}

Kontrol için ayarlanan değer, maksimum ve minimum kabul edilebilir değerlere göre düzeltilir; bunları almak ve ayarlamak için yöntemler ekleyelim:

// Setting the maximal acceptable value
void SetMaxValue(double aValue)
{ 
   m_ValueMax=aValue; // Registration of the new maximal accepted value
      if(m_Digits>=0)
     { // The control works in the numeric mode
         if(StringToDouble(m_Value)>m_ValueMax)
         { /* The current value of the control is greater than the new maximal acceptable value*/
            SetValue(m_ValueMax); // Setting the new value that is equal to the maximal accepted value
         }
      }         
}

// Setting the minimal acceptable value
void SetMinValue(double aValue)
{ 
   m_ValueMin=aValue; // Registration of the new minimal acceptable value     
      if(m_Digits>=0)
      { // The control works in the numeric mode
         if(StringToDouble(m_Value)<m_ValueMin)
         { /* The current value of the control is less than the new minimal acceptable value*/
            SetValue(m_ValueMin); // Setting the new value that is equal to the minimum acceptable value
         }
      }
}

// Getting the maximal accepted value
double MaxValue()
{ 
   return(m_ValueMax); 
}

// Getting the minimal accepted value
double MinValue()
{ 
   return(m_ValueMin);
}

Kontrol nümerik modda çalışıyorsa, yeni maksimum ve minimum kabul edilebilir değerler ayarlandığında geçerli değerin denetimi ve düzeltmesi (gerekirse) gerçekleştirilir.

Şimdi bir kullanıcı tarafından bir değerin girişiyle, Event() yöntemiyle ilgilenelim. Bir kullanıcı tarafından veri girişinin denetimi CHARTEVENT_OBJECT_ENDEDIT etkinliği kullanılarak gerçekleştirilir. Metin modunda çalışırken, bir kullanıcı tarafından belirtilen bir değer m_Value değerine eşit değilse, yeni değer m_Value olarak atanır ve değer 1 Event() yönteminden döndürülen m_event değişkenine atanır.

Nümerik modda çalışırken, m_OldValue değişkendeki m_Value önceki değerini ezberleyin, virgülü bir nokta ile değiştirin, dizeyi sayıya dönüştürün ve SetValue() fonksiyonuna geçirin. Daha sonra m_Value ve m_OldValue eşit değilse, etkinliği "oluşturun" (değer 1’i m_event değişkenine ayarlayın).

// Handling of events
int Event(const int id,
           const long & lparam,
           const double & dparam,
           const string & sparam)
{ 
   bool m_event=0; // Variable for an event of this control
      if(id==CHARTEVENT_OBJECT_ENDEDIT)
      { // There has been an event of end of editing the text field
         if(sparam==m_NameEdit)
         { // The text field with the name m_NameEdit has been modified
            if(m_Digits<0)
            { // In the text mode
               g.Attach(m_NameEdit); // Assigning the text field for controlling it
                  if(g.Text()!=m_Value)
                  { // New value in the text field
                     m_Value=g.Text(); // Assigning the value to the variable to store it
                     m_event=1;         // There has been an event
                  }
            }
            else
            { // In the numeric mode
               string m_OldValue=m_Value; // The variable with the previous value of the control
               g.Attach(m_NameEdit);      // Attaching the text field for controlling it
               string m_stmp=g.Text();     // Getting text specified by a user in the text field
               StringReplace(m_stmp,",",".");       // Replacing comma with a dot
               double m_dtmp=StringToDouble(m_stmp); // Conversion to a number
               SetValue(m_dtmp);                     // Setting the new numeric value
                     // Comparing the new value with the previous one
                  if(StringToDouble(m_Value)!=StringToDouble(m_OldValue))
                  { 
                     m_event=1; // There has been an event 
                  }
            }
         }
      }               
   return(m_event); // Return the event. 0 - there is no event, 1 - there is an event
}

Alt pencerelerde kontrolün çalışma desteği. Bunu sağlamak için, CHARTEVENT_CHART_CHANGE etkinliği durumunda OnChartEvent() fonksiyonundan çağrılması gereken SetSubWindow() yöntemini ekleyin. Kontrolü yalnızca bir fiyat grafiğinde kullanmayı planlıyorsanız, bu yöntemi çağırmanıza gerek yoktur. 

m_SubWindow değişkeni zaten belirtilmiş, varsayılan olarak 0'a eşittir ve kontrolün grafik nesnelerinin oluşturulmasında "w" sınıfının Edit() ve Label() yöntemlerine geçirilir. Bir alt pencerenin numarası SetSubWindowName() yöntemine geçirilir; numara değiştirilirse, m_SubWindow değişkeninin değerini değiştirin ve Refresh() yöntemini yürütün.

// Setting a subwindow by number
void SetSubWindow(int aNumber)
{ 
   int m_itmp=(int)MathMax(aNumber,0); /* If the number is negative, 0 will be used - the price chart*/
      if(m_itmp!=m_SubWindow)
      { /* The specified number doesn't correspond the number where the control is located*/
         m_SubWindow=m_itmp; // Registration of the new number of subwindow
         Refresh(); // Recreation of the graphical objects
      }
} 

Muhtemelen, numarası yerine bir alt pencerenin adını fonksiyona geçirmek daha uygun olacaktır. SetSubWindow() yönteminin başka bir varyantını ekleyin:

// Setting a subwindow by name
void SetSubWindow(string aName)
{ 
   SetSubWindow(ChartWindowFind(0,aName)); // Determination of the number of the subwindow by its name and setting the subwindow by number
}

Makalenin başında belirtilen konsepte göre, kontrolün sınıfını diğer eksik yöntemlerle sağlayın.

Kontrolün her iki koordinatını da aynı anda ayarlamaya izin veren SetPos() yöntemine sahip olur olmaz, ayrı koordinat ayarı yöntemlerini ekleyin:

// Setting the X coordinate
void SetPosLeft(int aLeft)
{ 
   m_Left=aLeft;
}      

// Setting the Y coordinate
void SetPosTop(int aTop)
{ 
   m_Top=aTop;
}  

Genişlik ayarlama yöntemi:

// Setting the width
void SetWidth(int aWidth)
{ 
   m_Width=aWidth;
}

Koordinatları ve boyutu alma yöntemi:

// Getting the X coordinate
int Left()
{ 
   return(m_Left);
}

// Getting the Y coordinate
int Top()
{ 
   return(m_Top);
}

// Getting the width
int Width()
{ 
   return(m_Width);
}

// Getting the height
int Height()
{
   return(m_Height); 
}

Etiketle çalışma yöntemleri:

// Setting the tag
void SetTag(string aValue)
{ 
   m_Tag=aValue;
}

// Getting the tag
string Tag()
{ 
   return(m_Tag);
}  

Uyarı yöntemleri:

// Setting the warning mode
void SetWarning(bool aValue)
{ 
      if(m_Visible)
      { // Visibility is enabled
         if(aValue)
         { // We need to turn on the warning mode
            if(!m_Warning)
            { // The warning mode has not been enabled
               g.Attach(m_NameEdit);         // Attaching the text field for controlling
               g.SetBgColor(m_WarningColor); // Setting the warning color of text in the text field
            }
         }
         else
         { // We need to disable the warning mode
            if(m_Warning)
            { // The warning mode is enabled
               g.Attach(m_NameEdit);    // Attach the text field for controlling 
               g.SetBgColor(m_BgColor); // Setting the normal font color                
            }
         }
      }
   m_Warning=aValue; // Registration of the current mode
}

// Getting the warning mode
bool Warning()
{ 
   return(m_Warning);
}

Uyarı modu ayarlanırken kontrol görünürse, SetWarning yöntemine geçirilen parametrenin değeri denetlenir; değeri kontrolün geçerli durumuna karşılık gelmiyorsa, metin alanının arka plan rengi değiştirilir.

Her halükarda, ayar modu kontrolün görünmez olması durumunda metin alanına karşılık gelen rengi ayarlamamak üzere kaydedilir.

Bir özellik kaldı - m_Digits. Değerini almak ve ayarlamak için yöntemler ekleyelim: 

// Setting the number of decimal places
void SetDigits(int aValue)
{ 
   m_Digits=aValue; // Registration of the new value
      if(m_Digits>=0)
      { // The numeric mode
         SetValue(ValueDouble()); // Resetting of the current value
      }
}  

// Getting the m_Digits value
int Digits()
{ 
   return(m_Digits);
}  

En ilginç kısmıyla işimiz bitti. Şimdi en güzeline geçiyoruz.

6. Renk Şemaları

Renk şemaları CСolorSchemes sınıfının değişkenlerinde depolanacaktır.

Sınıf önceden ClrScheme adlı IncGUI.mqh dosyasında belirtilecektir. Bir renk şeması ayarlamak için, parametre olarak belirtilen renk şemasının numarasıyla SetScheme() yöntemini çağıracağız. SetScheme() yöntemi çağrılmazsa, 0 numaralı renk şeması kullanılır.

Bir renk elde etmek için, renk şemasından belirtilen numaralı renkle Color() yöntemini kullanacağız. CСolor Schemes sınıfını özel ve genel bölümlerle yazalım. Özel bölümde, bir renk şemasının dizinini depolamak için m_ShemeIndex değişkenini belirtin. Ortak bölümde SetScheme() yöntemini yazın:

// Setting the color scheme number
void SetScheme(int aShemeIndex)
{ 
   m_ShemeIndex=aShemeIndex;
}

Color() yöntemi. Yöntemde iki boyutlu bir dizi belirtilir: birinci boyut renk şeması numarasıdır; ikincisi şemadaki renk numarasıdır. Bir renk düzeninin belirtilen numarasına bağlı olarak, rengi yöntem parametrelerinde belirtilen numaraya göre döndürür.

color Color(int aColorIndex)
{
   color m_Color[3][4];  // The first dimension - the color scheme number, the second one - the number of the color in the color scheme
   // default
   m_Color[0][0]=clrSnow;
   m_Color[0][1]=clrDimGray;
   m_Color[0][2]=clrDimGray;
   m_Color[0][3]=clrPink;
   // yellow-black
   m_Color[1][0]=clrLightYellow;
   m_Color[1][1]=clrBrown;
   m_Color[1][2]=clrBrown;
   m_Color[1][3]=clrPink;
   // blue
   m_Color[2][0]=clrAliceBlue;
   m_Color[2][1]=clrNavy;
   m_Color[2][2]=clrNavy;
   m_Color[2][3]=clrPink;
   return(m_Color[m_ShemeIndex][aColorIndex]); // Returning a value according to the scheme number and the number of color in the scheme
}

Şimdilik, renk şemalarının her biri dört renk içerir; bunlardan ikisi aynı değerlere sahiptir. Ayrıca, diğer kontrolleri oluştururken daha fazla renge ihtiyacımız olabilir.

Şemada uygun bir rengi kolayca bulmak veya yeni bir renk eklemeye karar vermek için, sınıf renkleri görüntülemeye izin veren bir yöntem içerir - Show() yöntemi (şekil 6). Ayrıca, grafikten renk örneklerini silmek için Hide() ters yöntemi de vardır.

Şekil 6. Show() yöntemini kullanarak renk şemalarını görüntüleme

Makale ekli ColorSchemesView.mq5 dosyasına sahiptir. Bu, renk şemalarını (ColorSchemesView.mq5) görüntülemek için bir Uzman Danışmandır (EA).

CInputBox sınıfında Init() yöntemini biraz değiştirelim. Renklerini ClrScheme sınıfındaki renklerle değiştirin:

m_BgColor=ClrScheme.Color(0);       // Background color of the text field
m_TxtColor=ClrScheme.Color(1);      // Font color and frame color of the text field
m_LblColor=ClrScheme.Color(2);     // Caption color
m_WarningColor=ClrScheme.Color(3); // Warning color

Bir kontrolün oluşturulması burada biter ve şimdi başka herhangi bir kontrolü geliştirmek için temele sahibiz.

7. Kontrolü Kullanma

Bir Uzman Danışman (EA) oluşturalım ve bunu GUITest olarak adlandıralım; IncGUI.mqh dosyasını bağlayalım:  

#include <IncGUI.mqh>

Ib adlı CInputBox sınıfını belirtin:

CInputBox ib;

EA'nın OnInit() fonksiyonunda, ib nesnesinin Init() yöntemini çağırın:

ib.Init("InpytBox",50,4,"input");

Kontrolü görünür hale getirin ve bunun için bir konum ayarlayın:

ib.Show(10,20);

EA'nın OnDeinit() fonksiyonunda kontrolü silin:

ib.Hide(); 

Uzman Danışmanı (EA) bir grafiğe derleyin ve ekleyin. Kontrolümüzü göreceksiniz (şekil 7).

Şek. 7. InputBox Kontrolü

Renk şemasını değiştirme olasılığını Uzman Danışmana (EA) ekleyin.

Şu anda üç renk şemamız var. Bir renk şeması seçmek için bir numaralandırma ve harici bir değişken oluşturalım: 

enum eColorScheme
  {
   DefaultScheme=0,
   YellowBrownScheme=1,
   BlueScheme=2
  };

input eColorScheme ColorScheme=DefaultScheme;

Uzman Danışmanın (EA) OnInit() fonksiyonunun en başında, bir renk şemasının ayarını ekleyin:

ClrScheme.SetScheme(ColorScheme);

Şimdi EA'nın özellikleri penceresinde üç renk şemasından birini seçebiliriz (şekil 8).

Şekil 8. Farklı Renk Şemaları

Yeni bir değer belirtme etkinliğini işlemek için, EA'nın OnChartEvent() fonksiyonuna aşağıdaki kodu ekleyin:

if(ib.Event(id,lparam,dparam,sparam)==1)
  {
   Alert("Entered value "+ib.ValueStrind());
  }

Şimdi, düzenleme alanında yeni bir değer belirtildiğinde, belirtilen değer hakkında bilgi veren bir mesaj penceresi açılır.

Uzman Danışmana (EA) bir alt pencerede kontrol oluşturma imkanı sağlayın.

Öncelikle bir test göstergesi TestSubWindow (TestSubWindow.mq5 dosyasına ekli) oluşturun. MQL5 Sihirbazında göstergeyi oluştururken, ayrı bir alt pencerede çalışması gerektiğini belirtin. EA'nın OnChartEvent() fonksiyonuna aşağıdaki kodu ekleyin:

if(CHARTEVENT_CHART_CHANGE)
  {
   ip.SetSubWindow("TestSubWindow");
  }

Şimdi, gösterge grafikte değilse, kontrol fiyat grafiğinde oluşturulur. Göstergeyi grafiğe eklerseniz, kontrol alt pencereye atlar (şekil 9). Göstergeyi silerseniz, kontrol fiyat grafiğine geri dönecektir.

 
Şekil 9. Alt penceredeki kontrol

Sonuç

Yapılan çalışmaların bir sonucu olarak, aşağıdaki sınıfları içeren IncGUI.mqh içerme dosyasına sahibiz: CGraphicObjectShell (grafik nesnelerin oluşturulması ve yönetimi), CWorkPiece (parametreleri kullanarak özelliklerini ayarlayarak birkaç grafik nesnenin hızlı oluşturulması), CColorSchemes (bir renk şeması ayarlama ve geçerli renk şemasının rengini alma) ve bir kontrolün bir sınıfı - CInputBox.

CGraphicObjectShell, CWorkPiece ve CColorSchemes sınıfı dosyada zaten "g", "w" ve "ClrScheme" adlarıyla belirtilmiştir, yani bunlar IncGUI.mqh dosyasını bağladıktan hemen sonra kullanıma hazırdır.

CInputBox sınıfının nasıl kullanılacağını tekrarlayalım:

1. IncGUI.mqh dosyasını bağlayın.
2. CInputBox türünde bir sınıf belirtin.
3. Init() yöntemini çağırın.
4. SetPos() yöntemini kullanarak koordinatları ayarlayın; gerekirse Show() kullanarak görünürlüğü açın. İkinci varyant: Koordinatları belirterek, Show() kullanarak görünürlüğü açın.
5. Gerekirse veya Uzman Danışmanın (EA) çalışmasının sonunda Hide() yöntemini kullanarak kontrolü gizleyin.
6. OnChartEvent() fonksiyonuna Event() yönteminin çağrısını ekleyin.
7. Bir alt pencerede kontrol oluşturmanız gerekiyorsa, CHARTEVENT_CHART_CHANGE etkinliği oluştuğunda OnChartEvent() fonksiyonuna SetSubWindow() yönteminin bir çağrısını sağlayın.
8. Renk şemalarını kullanmak için, Init() yöntemini çağırmadan önce ClrScheme sınıfının SetScheme() yöntemini çağırın. 

Ekler

• IncGUI.mqh - ana içerme dosyası. Dosya, istemci terminali veri klasörünün MQL5/Include klasörüne yerleştirilmelidir.
• GUITest.mq5 - CInputBox kontrolünün bir örneğine sahip Uzman Danışman (EA). Dosya, istemci terminali veri klasörünün MQL5/Experts klasörüne yerleştirilmelidir.
• TestSubWindow.mq5 - bir alt pencerede kontrolün görüntülenmesi için fonksiyonu test etme göstergesi. Dosya, istemci terminali veri klasörünün MQL5/Indıcators klasörüne yerleştirilmelidir.
• ColorSchemesView.mq5 - renk şemalarını görüntülemek için Uzman Danışman (EA). Kontrollerin oluşturulması için yardımcı bir araç. Dosya, istemci terminali veri klasörünün MQL5/Experts klasörüne yerleştirilmelidir.
• IncGUImqh.chm - IncGUI.mqh dosyası için belgeler.