MetaTrader 5 herunterladen

Grafische Interfaces V: Die vertikale und horizontale Scrollbar (Kapitel 1)

6 Juli 2016, 13:26
Anatoli Kazharski
0
263

Inhalt



Einleitung

In den vorangegangenen Artikeln der Serie über grafische interfaces innerhalb der MetaTrader Umgebung, haben wir die Hauptbestandteile der Bibliothek entwickelt und zudem einige weitere Interface-Elemente erzeugt: das Hauptmenü, das Kontextmenü, die Statusbar, Buttons, Gruppen von Buttons und Tooltips. Der fünfte Teil dieser Serie beschäftigt sich mit den Scrollbars und ListView Controls. In the first chapter, we will write classes for creating a vertical and horizontal scrollbar. In dem zweiten Kapitel, werden wir die ListView entwickeln, ein Komponenten-Interface-Element. Dieses Element besteht aus Komponenten, da die Scrollbar einen Teil dieser Komponente ist. Also lassen Sie uns nun mit der Erzeugung der Scrollbar anfangen. 

 


Das Scrollbar Control

Eine Scrollbar wird in unterschiedlichen ist ListViews und Tabellen verwendet, wenn die Daten nicht in einen festgelegten Bereich passen. Die Hauptbestandteile einer Scrollbar sind die Buttons für das Verschieben der Daten um einen Schritt und einen Schieberegler für die schnelle Bewegung der Daten durch das Ziehen des Reglers bei gedrückter linker Maustaste.

Wir stellen die Scrollbar aus fünf verschiedenen grafischen Objekten zusammen.

  1. Der Hintergrund.
  2. Der Hintergrund des Schiebereglers.
  3. Zwei Buttons für das Bewegen der Daten um einen Schritt.
  4. Den Schieberegler für die schnelle Bewegung der Daten.

 

Abbildung 1. Die Komponenten des Scrollbar Controls.

Da es sowohl eine horizontale, wie auch eine vertikale Scrollbar geben kann, macht es Sinn diese in zwei separate Klassen aufzuteilen. Dieses sind abgeleitete Klassen, die die besonderen Eigenschaften jedes Typs reflektieren. 

  • CScrollV – Abgeleitete Klasse für die vertikale Scrollbar.
  • CScrollH – Abgeleitete Klasse für die horizontale Scrollbar.

Die CScroll Klasse wird die Basisklasse für beide abgeleitete Klassen darstellen. Sie enthält variabel und Methoden die für beide Scrollbars gleich sind. Wir platzieren alle drei Klassen in der Scrolls.mqh Datei. Das schematische Diagramm des Scrollbar Controls sieht wie folgt aus:

 Abbildung  2. Schematisches Diagramm des Scrollbar Controls.

Abbildung 2. Schematisches Diagramm des Scrollbar Controls.


Wir betrachten nun die Entwicklung der Basisklasse für diese Controls CScroll

 


Basis-Klasse des Controls

Das Scrollbar Control ist kein eigenständiges Element der grafischen Oberfläche. Es handelt sich hier um ein Zusatzelement, welches zu anderen Elementen hinzugefügt werden kann, welche das Scrollen von Daten in einem Arbeitsbereich benötigen. Das bedeutet, dass die Scrolls.mqh Datei nicht direkt in der WndContainer.mqh Datei miteinbezogen werden muss. Die Klasse für die Scrollbar ist in der Bibliothek über die Einbeziehung der Datei innerhalb der Klassen von anderen Elementen verfügbar.

Erzeugen Sie die CScroll Klasse in der Scrolls.mqh Datei mit den Standardmethoden für alle Interface-elemente:

//+----------------------------------------------------------------
//|                                                      Scrolls.mqh |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+----------------------------------------------------------------
#include "Element.mqh"
#include "Window.mqh"
//+----------------------------------------------------------------
//| Basisklasse für die Erzeugung der Scrollbar                            |
//+----------------------------------------------------------------
class CScroll : public CElement
  {
protected:
   //--- Ein Pointer zu der Form zu welchem das Element hinzugefügt worden ist
   CWindow          *m_wnd;
   //---
public:
   //--- Speichert den Pointer
   void              WindowPointer(CWindow &object)           { m_wnd=::GetPointer(object);       }
   //---
public:
   //--- Chart Eventhandler
   virtual void      OnEvent(const int id,const long &lparam,const double &dparam,const string &sparam);
   //--- Timer
   virtual void      OnEventTimer(void) {}
   //--- Bewegen des Elementes
   virtual void      Moving(const int x,const int y);
   //--- (1) Anzeigen, (2) verstecken, (3) zurücksetzen, (4) löschen
   virtual void      Show(void);
   virtual void      Hide(void);
   virtual void      Reset(void);
   virtual void      Delete(void);
   //--- (1) Setzen, (2) Zurücksetzen der Prioritäten der linken Maustaste
   virtual void      SetZorders(void);
   virtual void      ResetZorders(void);
   //--- Zurücksetzen der Farbe
   virtual void      ResetColors(void) {}
  };
//+----------------------------------------------------------------
//| Konstruktor                                                      |
//+----------------------------------------------------------------
CScroll::CScroll(void)
  {
  }
//+----------------------------------------------------------------
//| Destruktor                                                       |
//+----------------------------------------------------------------
CScroll::~CScroll(void)
  {
  }

Die abgeleiteten Klassen müssen in der gleichen Datei erzeugt werden, wie es in dem nachfolgenden Programmcode gezeigt wird. In Abhängigkeit davon, welche Klasse benutzt werden soll, bekommt das Elements einen entsprechenden Namen in dem Konstruktor der Klasse.  

//+----------------------------------------------------------------
//| Klasse für die Verwaltung der vertikalen Scrollbar                        |
//+----------------------------------------------------------------
class CScrollV : public CScroll
  {
public:
                     CScrollV(void);
                    ~CScrollV(void);
  };
//+----------------------------------------------------------------
//| Konstruktor                                                      |
//+----------------------------------------------------------------
CScrollV::CScrollV(void)
  {
//--- Abspeichern des namens der Elementklasse in der Basisklasse
   CElement::ClassName(CLASS_NAME);
  }
//+----------------------------------------------------------------
//| Destruktor                                                       |
//+----------------------------------------------------------------
CScrollV::~CScrollV(void)
  {
  }
//+----------------------------------------------------------------
//| Klasse für die Verwaltung der Horizontalen Scrollbar                      |
//+----------------------------------------------------------------
class CScrollH : public CScroll
  {
public:
                     CScrollH(void);
                    ~CScrollH(void);
  };
//+----------------------------------------------------------------
//| Konstruktor                                                      |
//+----------------------------------------------------------------
CScrollH::CScrollH(void)
  {
//--- Abspeichern des namens der Elementklasse in der Basisklasse
   CElement::ClassName(CLASS_NAME);
  }
//+----------------------------------------------------------------
//| Destruktor                                                       |
//+----------------------------------------------------------------
CScrollH::~CScrollH(void)
  {
  }

Lassen Sie uns die das Erscheinungsbild der Scrollbar flexibel gestalten. Dafür erzeugen wir in der Basisklasse CScroll Variablen und Methoden für die folgenden Parameter des Objektes:

  • Die Breite der Scrollbar
  • Die Farbe des generellen Hintergrund-Rahmens
  • Die Farbe des Hintergrundes und des Rahmens des Bereiches, in welchem sich der Schieberegler befindet
  • Die Farbe des Hintergrundes und des Rahmens des Schiebereglers in unterschiedlichen Zuständen
  • Icons für die unterschiedlichen Zustände der Buttons, mit welchen die Daten gescrollt werden.

Wir weisen an dieser Stelle darauf hin, dass die Breite der vertikalen Scrollbar und seiner Objekte die Größe entlang der X Achse darstellt und die Breite der Horizontalen Scrollbar entspricht der Größe entlang der Y Achse. Die Standardbreite entspricht 15 Pixeln. Die Standard Icons für die Buttons werden so ausgewählt, dass sie dieser Größe entsprechen. Sie befinden sich innerhalb des generellen Hintergrundes mit einem Abstand von 1 Pixel, wodurch Sie nicht den Rahmen des Hintergrundes abdecken. Ihre Größe ist somit 13x13 Pixel. Falls Sie sich also für eine andere Größe der Scrollbar entscheiden, müssen Sie die Buttons entsprechend anpassen. Lassen Sie uns nun die relevanten Methoden erzeugen.

Die Breite von anderen Objekten der Scrollbar (interner Bereich und der Schieberegler) werden automatisch berechnet in Relation zu der Breite des generellen Hintergrundes. Die Länge wird ebenso automatisch berechnet, da dieser Parameter von der Anzahl der Elemente innerhalb der Liste und deren Größe entlang entlang der Y Achse abhängt. Die Implementation hierfür werden wir später in diesem Artikel zeigen. 

class CScroll : public CElement
  {
protected:
   //--- Die Eigenschaften des generellen Bereiches der Scrollbar
   int               m_area_width;
   int               m_area_length;
   color             m_area_color;
   color             m_area_border_color;
   //--- Eigenschaften des Hintergrundes des Schiebereglers
   int               m_bg_length;
   color             m_bg_border_color;
   //--- Button Icons
   string            m_inc_file_on;
   string            m_inc_file_off;
   string            m_dec_file_on;
   string            m_dec_file_off;
   //--- Die Farben des Schiebereglers in unterschiedlichen Zuständen
   color             m_thumb_color;
   color             m_thumb_color_hover;
   color             m_thumb_color_pressed;
   color             m_thumb_border_color;
   color             m_thumb_border_color_hover;
   color             m_thumb_border_color_pressed;
   //--- (1) Die Breite des Schiebereglers, (2) Länge des Schiebereglers (3) und seine minimale Länge
   int               m_thumb_width;
   int               m_thumb_length;
   int               m_thumb_min_length;
   //--- (1) Schrittweite des Schiebereglers (2) die Anzahl der Schritte
   double            m_thumb_step_size;
   double            m_thumb_steps_total;
   //--- Priorität eines Klicks mit der linken Maustaste
   int               m_area_zorder;
   int               m_bg_zorder;
   int               m_arrow_zorder;
   int               m_thumb_zorder;
   //---
public:
   //--- Breite des Schiebereglers
   void              ScrollWidth(const int width)             { m_area_width=width;               }
   int               ScrollWidth(void)                  const { return(m_area_width);             }
   //--- (1) Farbe des Hintergrundes, (2) des Rahmens des Hintergrundes (3) der interner Rahmen des Hintergrundes
   void              AreaColor(const color clr)               { m_area_color=clr;                 }
   void              AreaBorderColor(const color clr)         { m_area_border_color=clr;          }
   void              BgBorderColor(const color clr)           { m_bg_border_color=clr;            }
   //--- Festlegen der Icons für die Buttons
   void              IncFileOn(const string file_path)        { m_inc_file_on=file_path;          }
   void              IncFileOff(const string file_path)       { m_inc_file_off=file_path;         }
   void              DecFileOn(const string file_path)        { m_dec_file_on=file_path;          }
   void              DecFileOff(const string file_path)       { m_dec_file_off=file_path;         }
   //--- (1) Die Farbe des Hintergrundes des Schiebereglers und (2) des Rahmens von dem Hintergrund des Schiebereglers
   void              ThumbColor(const color clr)              { m_thumb_border_color=clr;         }
   void              ThumbColorHover(const color clr)         { m_thumb_border_color_hover=clr;   }
   void              ThumbColorPressed(const color clr)       { m_thumb_border_color_pressed=clr; }
   void              ThumbBorderColor(const color clr)        { m_thumb_border_color=clr;         }
   void              ThumbBorderColorHover(const color clr)   { m_thumb_border_color_hover=clr;   }
   void              ThumbBorderColorPressed(const color clr) { m_thumb_border_color_pressed=clr; }
  };
//+----------------------------------------------------------------
//| Konstruktor                                                      |
//+----------------------------------------------------------------
CScroll::CScroll(void) : m_area_width(15),
                         m_area_length(0),
                         m_inc_file_on(""),
                         m_inc_file_off(""),
                         m_dec_file_on(""),
                         m_dec_file_off(""),
                         m_thumb_width(0),
                         m_thumb_length(0),
                         m_thumb_min_length(15),
                         m_area_color(C'210,210,210'),
                         m_area_border_color(C'240,240,240'),
                         m_bg_border_color(C'210,210,210'),
                         m_thumb_color(C'190,190,190'),
                         m_thumb_color_hover(C'180,180,180'),
                         m_thumb_color_pressed(C'160,160,160'),
                         m_thumb_border_color(C'170,170,170'),
                         m_thumb_border_color_hover(C'160,160,160'),
                         m_thumb_border_color_pressed(C'140,140,140')
  {
//--- Setzen der Priorität eines Klicks mit der linken Maustaste
   m_area_zorder  =8;
   m_bg_zorder    =9;
   m_arrow_zorder =10;
   m_thumb_zorder =11;
  }

Lassen Sie uns nun die Methoden für das Erzeugen der Scrollbar-Elemente betrachten Jeder Teil wird durch eine eigene separate private Methode erzeugt. Die Größe der ListView und die Größe des sichtbaren Teils der ListView werden über die letzten zwei Parameter in der Hauptmethode angegeben. Diese Parameter werden dann auch für die Berechnung der Anzahl der Schritte des Scrollbar-Schiebereglers verwendet. 

class CScroll : public CElement
  {
protected:
   //--- Objekte für die Erzeugung der Scrollbar
   CRectLabel        m_area;
   CRectLabel        m_bg;
   CBmpLabel         m_inc;
   CBmpLabel         m_dec;
   CRectLabel        m_thumb;
   //---
public:
   //--- Methoden für die Erzeugung der Scrollbar
   bool              CreateScroll(const long chart_id,const int subwin,const int x,const int y,const int items_total,const int visible_items_total);
   //---
private:
   bool              CreateArea(void);
   bool              CreateBg(void);
   bool              CreateInc(void);
   bool              CreateDec(void);
   bool              CreateThumb(void);
  };

Wir zeigen hier beispielhaft nur den Programmcode von einigen dieser Methoden, da die gleichen Prinzipien auch für die restlichen Methoden gelten, was einfach nachzuvollziehen ist. Schauen Sie sich den Programmcode der nachfolgenden CScroll::CreateBg() Methode an. Beachten Sie, dass die Erzeugung des Objekt namens von dem Scrollbar-Typ und von dem Index dieses Elementes abhängt. Die Angabe eines Index ist deshalb wichtig, da es bei der Entwicklung von zusammengestellten Controls auch verschiedene Scrollbars eines Typs geben kann. Ein solches Beispiel zeigen wir in einem der nachfolgenden Artikel.

Der Typ der Scrollbar definiert auch die Berechnung von Parametern wie (1) Koordinaten, (2) Länge des Bereiches des Schiebereglers und (3) seine Größe. Im nachfolgenden Programmcode ist dieses in Blau hervorgehoben. 

//+----------------------------------------------------------------
//| Erzeugten Hintergrund der Scrollbar                                 |
//+----------------------------------------------------------------
bool CScroll::CreateBg(void)
  {
//--- Den Objektnamen bilden
   string name      ="";
   string name_part =(CElement::ClassName()=="CScrollV")? "_scrollv_bg_" : "_scrollh_bg_";
//--- Falls ein Index nicht angegeben wurde
   if(CElement::Index()==WRONG_VALUE)
      name=CElement::ProgramName()+name_part+(string)CElement::Id();
//--- Falls ein Index angegeben wurde
   else
      name=CElement::ProgramName()+name_part+(string)CElement::Index()+"__"+(string)CElement::Id();
//--- Koordinaten
   int x=0;
   int y=0;
//--- Größe
   int x_size=0;
   int y_size=0;
//--- Festlegen der Eigenschaften unter Berücksichtigung des Typs der Scrollbar
   if(CElement::ClassName()=="CScrollV")
     {
      m_bg_length =CElement::YSize()-(m_thumb_width*2)-2;
      x           =CElement::X()+1;
      y           =CElement::Y()+m_thumb_width+1;
      x_size      =m_thumb_width;
      y_size      =m_bg_length;
     }
   else
     {
      m_bg_length =CElement::XSize()-(m_thumb_width*2)-2;
      x           =CElement::X()+m_thumb_width+1;
      y           =CElement::Y()+1;
      x_size      =m_bg_length;
      y_size      =m_thumb_width;
     }
//--- Erzeugen eines Objektes
   if(!m_bg.Create(m_chart_id,name,m_subwin,x,y,x_size,y_size))
      return(false);
//--- Festlegen der Eigenschaften
   m_bg.BackColor(m_area_color);
   m_bg.Color(m_bg_border_color);
   m_bg.BorderType(BORDER_FLAT);
   m_bg.Corner(m_corner);
   m_bg.Selectable(false);
   m_bg.Z_Order(m_bg_zorder);
   m_bg.Tooltip("\n");
//--- Abspeichern der Koordinaten
   m_bg.X(x);
   m_bg.Y(y);
//--- Store margins
   m_bg.XGap(x-m_wnd.X());
   m_bg.YGap(y-m_wnd.Y());
//--- Abspeichern der Größe
   m_bg.XSize(x_size);
   m_bg.YSize(y_size);
//--- Abspeichern des Objekt-Pointers
   CElement::AddToArray(m_bg);
   return(true);
  }

Wenn wir den Schieberegler der Scrollbar erzeugen wollen, benötigen wir eine Methode für die Berechnung seiner Länge. Die Länge hängt von der Anzahl der Elemente ab, die in der Liste angezeigt werden sollen und von der Anzahl der Elemente, die in dem sichtbaren Teil dargestellt werden können. Lassen Sie uns eine solche Methode erzeugen und sie CScroll::CalculateThumbSize() nennen. 

Am Anfang der Methode wird eine Überprüfung der Größe des Schieberegler-Bereiches durchgeführt. Wenn die Länge dieses Bereiches kleiner als die minimale Länge des Schiebereglers ist, dann wird die Berechnung nicht benötigt. Die Methode gibt dann false zurück und es wird kein Schieberegler erzeugt, da dieser in diesem Fall auch nicht benötigt wird. Nach einer erfolgreichen Überprüfung wird die Berechnung in verschiedene Abschnitte unterteilt:

  • Berechnung der Schrittweite des Schiebereglers. 
  • Falls der errechnete Wert kleiner als 1 ist, dann wird er gleich 1 gesetzt.
  • Berechnung des Arbeitsbereiches für das Verschieben des Reglers. 
  • Falls die Größe des Arbeitsbereiches kleiner ist als die Größe des gesamten Bereiches für die Bewegung des Schiebereglers, dann berechnen wir die Länge des Schiebereglers. Andernfalls setzen wir die minimale Länge auf den Standardwert von 15 Pixeln.
  • Die Überprüfung der berechneten Länge des Schiebereglers, welche auch eine Typumwandlung zum Typ Integer (int) Beinhaltet, findet am Ende der Methode Stadt, sowie auch die Anpassung, falls der die berechnete Länge kleiner als die Minimale ist. 

Nachfolgend wird der detaillierte Programmcode der CScroll::CalculateThumbSize() Methode gezeigt.

class CScroll : public CElement
  {
protected:

public:
   //--- Berechnung der Länge des Schiebereglers
   bool              CalculateThumbSize(void);
  };
//+----------------------------------------------------------------
//| Berechnung der Länge des Schiebereglers                |
//+----------------------------------------------------------------
bool CScroll::CalculateThumbSize(void)
  {
//--- Eine Berechnung ist nicht notwendig falls die Länge des Bereiches für die Bewegung des Schiebereglers kleiner ist als die minimale Länge des Schiebereglers
   if(m_bg_length<m_thumb_min_length)
      return(false);
//--- Die Berechnung der Größe der Schrittweite des Schiebereglers
   m_thumb_step_size=(double)(m_bg_length-m_thumb_min_length)/m_thumb_steps_total;
//--- Die schrittweise kann nicht kleiner als 1 sein
   m_thumb_step_size=(m_thumb_step_size<1)? 1 : m_thumb_step_size;
//--- Berechnung der Größe des Arbeitsbereiches für die Bewegung des Schiebereglers
   double work_area=m_thumb_step_size*m_thumb_steps_total;
//--- Falls die Größe des Arbeitsbereiches kleiner als die Größe des gesamten Bereiches, dann frag die Größe des Schiebereglers ab, anderenfalls setze die minimale Größe
   double thumb_size=(work_area<m_bg_length)? m_bg_length-work_area+m_thumb_step_size : m_thumb_min_length;
//--- Die Überprüfung der Größe des Schiebereglers unter Verwendung von Typumwandlung
   m_thumb_length=((int)thumb_size<m_thumb_min_length)? m_thumb_min_length :(int)thumb_size;
   return(true);
  }

Der Aufruf der CScroll::CalculateThumbSize() Methode muss in der CScroll::CreateThumb() Methode vor der Erzeugung des Objektes stattfinden. Später werden wir auch noch einen anderen Fall betrachten, bei dem die Länge der Scrollbar während des Prozesses der Verwendung dieses Controls berechnet werden muss. Wir werden dieses näher betrachten, wenn wir dieses Control entwickeln.

//+----------------------------------------------------------------
//| Erzeugt Sie den Schieberegler der Scrollbar                              |
//+----------------------------------------------------------------
bool CScroll::CreateThumb(void)
  {
//--- Den Objektnamen bilden  
   string name      ="";
   string name_part =(CElement::ClassName()=="CScrollV")? "_scrollv_thumb_" : "_scrollh_thumb_";
//--- Falls ein Index nicht angegeben wurde
   if(CElement::Index()==WRONG_VALUE)
      name=CElement::ProgramName()+name_part+(string)CElement::Id();
//--- Falls ein Index angegeben wurde
   else
      name=CElement::ProgramName()+name_part+(string)CElement::Index()+"__"+(string)CElement::Id();
//--- Koordinaten
   int x=0;
   int y=0;
//--- Größe
   int x_size=0;
   int y_size=0;
//--- Berechnet die Größe der Scrollbar
   if(!CalculateThumbSize())
      return(true);
//--- Sitzen der Eigenschaften unter Berücksichtigung des Typs
   if(CElement::ClassName()=="CScrollV")
     {
      x      =(m_thumb.X()>0) ? m_thumb.X() : m_x+1;
      y      =(m_thumb.Y()>0) ? m_thumb.Y() : m_y+m_thumb_width+1;
      x_size =m_thumb_width;
      y_size =m_thumb_length;
     }
   else
     {
      x      =(m_thumb.X()>0) ? m_thumb.X() : m_x+m_thumb_width+1;
      y      =(m_thumb.Y()>0) ? m_thumb.Y() : m_y+1;
      x_size =m_thumb_length;
      y_size =m_thumb_width;
     }
//--- Erzeugen eines Objektes
   if(!m_thumb.Create(m_chart_id,name,m_subwin,x,y,x_size,y_size))
      return(false);
//--- Festlegen der Eigenschaften
   m_thumb.BackColor(m_thumb_color);
   m_thumb.Color(m_thumb_border_color);
   m_thumb.BorderType(BORDER_FLAT);
   m_thumb.Corner(m_corner);
   m_thumb.Selectable(false);
   m_thumb.Z_Order(m_thumb_zorder);
   m_thumb.Tooltip("\n");
//--- Abspeichern der Koordinaten
   m_thumb.X(x);
   m_thumb.Y(y);
//--- Store margins
   m_thumb.XGap(x-m_wnd.X());
   m_thumb.YGap(y-m_wnd.Y());
//--- Abspeichern der Größe
   m_thumb.XSize(x_size);
   m_thumb.YSize(y_size);
//--- Abspeichern des Objekt-Pointers
   CElement::AddToArray(m_thumb);
   return(true);
  }

Andere Methoden für die Erzeugung des Scrollbar-Objekte sind für individuelle Studien gedacht. Sie finden diese in den Dateien, die diesem Artikel beigefügt sind.

Fügen Sie in der Hauptmmethode (public) für die Erzeugung der Scrollbar eine Überprüfung des Klassentyps hinzu. Der Name der Klasse wird nicht in der Basisklasse der Elemente CScroll gespeichert. Das ist der Grund, warum bei dem Versuch eine Scrollbar mit der Basisklasse zu erzeugen, die Erzeugung des grafischen Interfaces abbrechen wird. In dem Journal finden Sie dann eine Nachricht, dass die abgeleitete Klasse vom Typ CScrollV oder CScrollH verwendet werden muss. Bitte beachten Sie, wie einige Parameter des Elementes initialisiert werden. Ein solcher Ansatz erlaubt es, die Berechnungen automatisch durchzuführen und gleichzeitig mit einer minimalen Anzahl von Eigenschaften auszukommen, während das Control mit einer Scrollbar erzeugt wird. 

//+----------------------------------------------------------------
//| Erzeugt die Scrollbar                                            |
//+----------------------------------------------------------------
bool CScroll::CreateScroll(const long chart_id,const int subwin,const int x,const int y,const int items_total,const int visible_items_total)
  {
//--- Verlassen, wenn es keinen Pointer zu einer Form gibt
   if(::CheckPointer(m_wnd)==POINTER_INVALID)
     {
      ::Print(__FUNCTION__," > Before creating the scrollbar, the class must be passed "
              "the form pointer: CScroll::WindowPointer(CWindow &object)");
      return(false);
     }
//--- Abbrechen, falls es den Versuch gibt die Basisklasse für die Scrollbar zu verwenden
   if(CElement::ClassName()=="")
     {
      ::Print(__FUNCTION__," > Use derived classes of the scrollbar (CScrollV or CScrollH).");
      return(false);
     }
//--- Initialisierung der Variablen
   m_chart_id          =chart_id;
   m_subwin            =subwin;
   m_x                 =x;
   m_y                 =y;
   m_area_width        =(CElement::ClassName()=="CScrollV")? CElement::XSize() : CElement::YSize();
   m_area_length       =(CElement::ClassName()=="CScrollV")? CElement::YSize() : CElement::XSize();
   m_thumb_width       =m_area_width-2;
   m_thumb_steps_total =items_total-visible_items_total+1;
//--- Ränder von den Kanten
   CElement::XGap(m_x-m_wnd.X());
   CElement::YGap(m_y-m_wnd.Y());
//--- Erzeugung des Buttons
   if(!CreateArea())
      return(false);
   if(!CreateBg())
      return(false);
   if(!CreateInc())
      return(false);
   if(!CreateDec())
      return(false);
   if(!CreateThumb())
      return(false);
//--- Verstecken des Elementes, falls dieses ein Dialogfenster ist oder es minimiert ist
   if(m_wnd.WindowType()==W_DIALOG || m_wnd.IsMinimized())
      Hide();
//---
   return(true);
  }

Um den Status der linken Maustaste in Relation zu dem Schieberegler der Scrollbar identifizieren zu können, erzeugen Sie die ENUM_THUMB_MOUSE_STATE Enumeration in der Enums.mqh Datei.

//+----------------------------------------------------------------
//| Enumeration der Zustände der linken Maustaste für die Scrollbar|
//+----------------------------------------------------------------
enum ENUM_THUMB_MOUSE_STATE
  {
   THUMB_NOT_PRESSED     =0,
   THUMB_PRESSED_OUTSIDE =1,
   THUMB_PRESSED_INSIDE  =2
  };

Dafür müssen wir entsprechende Variablen und Methoden erzeugen. Die CScroll::CheckMouseButtonState() Methode wird benötigt, um herauszufinden über welchem Bereich die linke Maustaste gedrückt wurde. Die CScroll::ZeroThumbVariables() Methode wird für das Zurücksetzen der Variablen im Zusammenhang mit der Bewegung des Schiebereglers verwendet. Sie wird in der CScroll::CheckMouseButtonState() Methode aufgerufen, sobald die linke Maustaste losgelassen wird.

Behalten Sie im Hinterkopf, dass wenn die Scrollbar sich in dem Modus für die Bewegung des Schiebereglers befindet, das Formular nur blockiert wird, falls das Element kein Dropdown Element ist. Dieses ist notwendig um auszuschließen, dass andere Element hervorgehoben werden, wenn sich der Mauszeiger über ihnen befindet, der Schieberegler der Scrollbar sich in dem Bewegungsmodus befindet und der Mauszeiger außerhalb seines Bereiches ist. Wenn der Bewegungsmodus des Schiebereglers deaktiviert ist, muss das Formular in der CScroll::ZeroThumbVariables() Methode entsperrt werden

class CScroll : public CElement
  {
protected:
   //--- Variablen in Zusammenhang mit der Bewegung des Schiebereglers
   bool              m_scroll_state;
   int               m_thumb_size_fixing;
   int               m_thumb_point_fixing;
   //--- Für die Identifizierung des Bereiches in welchen die linke Maustaste gedrückt wurde
   ENUM_THUMB_MOUSE_STATE m_clamping_area_mouse;
   //---
public:
   //--- Zur Identifizierung des Bereiches in welchem die linke Maustaste gedrückt wurde
   void              CheckMouseButtonState(const bool mouse_state);
   //--- Zurücksetzen der Variablen
   void              ZeroThumbVariables(void);
  };
//+----------------------------------------------------------------
//| Identifizierung des Bereiches in welchem die linke Maustaste gedrückt wurde            |
//+----------------------------------------------------------------
void CScroll::CheckMouseButtonState(const bool mouse_state)
  {
//--- Identifizierung des Status der linken Maustaste:
//    Falls losgelassen
   if(!mouse_state)
     {
      //--- Zurücksetzen der Variablen
      ZeroThumbVariables();
      return;
     }
//--- Falls gedrückt
   if(mouse_state)
     {
      //--- Abbrechen, falls die Taste innerhalb eines anderen Bereiches gedrückt wurde
      if(m_clamping_area_mouse!=THUMB_NOT_PRESSED)
         return;
      //--- Außerhalb des Bereiches des Schiebereglers
      if(!m_thumb.MouseFocus())
         m_clamping_area_mouse=THUMB_PRESSED_OUTSIDE;
      //--- Innerhalb des Bereiches des Schiebereglers
      else
        {
         m_clamping_area_mouse=THUMB_PRESSED_INSIDE;
         //--- Falls es sich nicht um ein Dropdown Element handelt
         if(!CElement::IsDropdown())
           {
            //--- Sperre das Formular und speichere den Bezeichner des aktiven Elementes
            m_wnd.IsLocked(true);
            m_wnd.IdActivatedElement(CElement::Id());
           }
        }
     }
  }
//+----------------------------------------------------------------
//| Zurücksetzen der Variablen die in Zusammenhang mit der Bewegung des Schiebereglers stehen             |
//+----------------------------------------------------------------
void CScroll::ZeroThumbVariables(void)
  {
//--- Falls es sich nicht um ein Dropdown Element handelt
   if(!CElement::IsDropdown())
     {
      //--- Entsperren des Formulars und zurücksetzen des Bezeichners des aktiven Elementes
      m_wnd.IsLocked(false);
      m_wnd.IdActivatedElement(WRONG_VALUE);
     }
   m_thumb_size_fixing   =0;
   m_clamping_area_mouse =THUMB_NOT_PRESSED;
  }

Für die Veränderung der Farbe der Scrollbar-Objekte, in Abhängigkeit der Position des Mauszeigers und des Status der linken Maustaste, erzeugen Sie die CScroll::ChangeObjectsColor() Methode. Zu Beginn dieser Methode, wird eine Überprüfung durchgeführt, ob das Formular gesperrt ist und ob sich der Bezeichner der Scrollbar von dem Bezeichner, der in der dem Formular gespeichert ist, unterscheidet. Wenn beide Bedingungen zutreffen, dann wird in Abhängigkeit des aktuellen Modus der Scrollbar und dem Fokus der Buttons ein entsprechender Status gesetzt. Eine Scrollbar kann zwei Modi haben: (1) frei und (2) im Prozess der Bewegung des Schiebereglers. Anschließend, in Abhängigkeit der Position des Mauszeigers und in welchem Bereich die linke Maustaste gedrückt wurde, bekommt der Schieberegler eine entsprechende Farbe. Der Modus der Scrollbar wird hier ebenfalls definiert.

class CScroll : public CElement
  {
public:
   //--- Wechsel der Farben der Scrollbar-Objekte
   void              ChangeObjectsColor(void);
  };
//+----------------------------------------------------------------
//| Ändert die Farben der Objekte der ListView-Scrollbar          |
//+----------------------------------------------------------------
void CScroll::ChangeObjectsColor(void)
  {
//--- Abbrechen, falls das Formular gesperrt ist und der Bezeichner des aktuell aktiven Elementes ein anderer ist
   if(m_wnd.IsLocked() && m_wnd.IdActivatedElement()!=CElement::Id())
      return;
//--- Die Farbe der Buttons von der ListView-Scrollbar
   if(!m_scroll_state)
     {
      m_inc.State(m_inc.MouseFocus());
      m_dec.State(m_dec.MouseFocus());
     }
//--- Falls sich der Mauszeiger in dem Bereich der Scrollbar befindet
   if(m_thumb.MouseFocus())
     {
      //--- Falls die linke Maustaste losgelassen wurde
      if(m_clamping_area_mouse==THUMB_NOT_PRESSED)
        {
         m_scroll_state=false;
         m_thumb.BackColor(m_thumb_color_hover);
         m_thumb.Color(m_thumb_border_color_hover);
        }
      //--- Die linke Maustaste wurde auf dem Schieberegler heruntergedrückt
      else if(m_clamping_area_mouse==THUMB_PRESSED_INSIDE)
        {
         m_scroll_state=true;
         m_thumb.BackColor(m_thumb_color_pressed);
         m_thumb.Color(m_thumb_border_color_pressed);
        }
     }
//--- Falls sich der Mauszeiger außerhalb des Bereiches der Scrollbar befindet
   else
     {
      //--- Die linke Maustaste wurde losgelassen
      if(m_clamping_area_mouse==THUMB_NOT_PRESSED)
        {
         m_scroll_state=false;
         m_thumb.BackColor(m_thumb_color);
         m_thumb.Color(m_thumb_border_color);
        }
     }
  }

Für die Entwicklung eines Interface-Elementes mit einer Scrollbar, sind Methoden für die Abfrage des Namens und des Status der Scrollbar notwendig. Zudem benötigen wir Methoden für das Setzen und Identifizieren des Status des Schiebereglers der Scrollbar und Informationen über seine aktuellen Position in Relation zu der ListView zu welchem die Scrollbar hinzugefügt wurde. 

class CScroll : public CElement
  {
protected:
   //--- Definition des Status der Scrollbar
   bool              m_scroll_state;
   //--- Die aktuelle Position des Schiebereglers
   int               m_current_pos;
   //---
public:
   //---Namen der Button Objekte 
   string            ScrollIncName(void)                const { return(m_inc.Name());             }
   string            ScrollDecName(void)                const { return(m_dec.Name());             }
   //--- Status der Buttons
   bool              ScrollIncState(void)               const { return(m_inc.State());            }
   bool              ScrollDecState(void)               const { return(m_dec.State());            }
   //--- Status der Scrollbar
   void              ScrollState(const bool scroll_state)     { m_scroll_state=scroll_state;      }
   bool              ScrollState(void)                  const { return(m_scroll_state);           }
   //--- Die aktuelle Position des Schiebereglers
   void              CurrentPos(const int pos)                { m_current_pos=pos;                }
   int               CurrentPos(void)                   const { return(m_current_pos);            }
  };

Hiermit haben wir die Entwicklung der Basisklasse der Scrollbar abgeschlossen. Jetzt werden wir uns mit den abgeleiteten Klassen beschäftigen. 

 


Abgeleitete Classen des Controls

Während die Basisklasse der Scrollbar Methoden für die Erzeugung des Objektes, Festlegung der Parameter und die Abfrage dieser Parameter enthält, besitzen die abgeleiteten Klassen die Funktionen für die Verwaltung dieses Controls. Wir haben zuvor schon in der Scrolls.mqh Datei die abgeleiteten Klassen CScrollV und CScrollH erzeugt. Wir werden hier nur die Methoden von einer dieser beiden Klassen besprechen - Die Klasse für die vertikale Scrollbar(CScrollV). In der anderen Klasse (CScrollH) ist mit Ausnahme des Typs eigentlich alles gleich, bzw. es läuft dort alles gleich ab. In der Klasse mit der Horizontalen Scrollbar arbeiten wir mit der X Koordinate und in der Vertikalen Scrollbar arbeiten wir mit der Y Koordinate.

Zunächst betrachten wir den Programmcode der CScrollV::OnDragThumb() und CScrollV::UpdateThumb() Methoden, die für die Bewegung des Schiebereglers verantwortlich sind. Diese müssen in der privaten Sektion der Klasse deklariert werden, da sie auch nur innerhalb der CScrollV Klasse verwendet werden.

//+----------------------------------------------------------------
//| Klasse für die Verwaltung der vertikalen Scrollbar                        |
//+----------------------------------------------------------------
class CScrollV : public CScroll
  {
private:
   //--- Bewegen des Schiebereglers
   void              OnDragThumb(const int y);
   //--- Aktualisieren der Position des Schiebereglers
   void              UpdateThumb(const int new_y_point);
  };

Die CScrollV::OnDragThumb() Methode wird dafür benötigt, den Versuch des Users, den Schieberegler zu bewegen, zu identifizieren. Wenn die linke Maustaste über dem Schieberegler der Scrollbar gedrückt wurde und der Mauszeiger entlang der Y Achse bewegt wurde, bedeutet das, dass der Prozess für die Bewegung gestartet hat und das Objekt bewegt werden muss. Die Aktualisierung der Koordinaten des Schiebereglers wird mit der CScrollV::UpdateThumb() Methode durchgeführt.  

//+----------------------------------------------------------------
//| Bewegen des Schiebereglers                                                |
//+----------------------------------------------------------------
void CScrollV::OnDragThumb(const int y)
  {
//--- Zur Identifizierung der neuen y-Koordinate
   int new_y_point=0;
//--- Falls die Scrollbar inaktiv ist, ...
   if(!CScroll::ScrollState())
     {
      //--- ...zurücksetzen der Hilfsvariablen für die Bewegung des Schiebereglers
      CScroll::m_thumb_size_fixing  =0;
      CScroll::m_thumb_point_fixing =0;
      return;
     }
//--- Falls der Fixpunkt 0 ist, speichere die aktuellen Koordinaten des Mauszeigers
   if(CScroll::m_thumb_point_fixing==0)
      CScroll::m_thumb_point_fixing=y;
//--- Falls der Abstand von der Ecke des Schiebereglers zu der aktuellen Koordinaten des Mauszeigers 0 ist, berechne ihn...
   if(CScroll::m_thumb_size_fixing==0)
      CScroll::m_thumb_size_fixing=m_thumb.Y()-y;
//--- Falls der Schwellenwert nach unten überschritten worden ist und der Mauszeiger gedrückt ist
   if(y-CScroll::m_thumb_point_fixing>0)
     {
      //--- Berechne die Y Koordinate
      new_y_point=y+CScroll::m_thumb_size_fixing;
      //--- Aktualisiere die Position des Schiebereglers
      UpdateThumb(new_y_point);
      return;
     }
//--- Falls die Bewegung den Schwellenwert nach oben überschritten hat und das bei gedrückter Maustaste
   if(y-CScroll::m_thumb_point_fixing<0)
     {
      //--- Berechne die Y Koordinate
      new_y_point=y-::fabs(CScroll::m_thumb_size_fixing);
      //--- Aktualisiere die Position des Schiebereglers
      UpdateThumb(new_y_point);
      return;
     }
  }

Nachfolgend ist der detaillierte Code der CScrollV::UpdateThumb() Methode aufgeführt. Die in der CScrollV::OnDragThumb() Methode berechnete y Koordinate wird übergeben. Hier wird sie auf Korrektheit überprüft. Wenn sich herausstellt, dass wir die Begrenzungen des Arbeitsbereiches für die Bewegung des Schiebereglers überschritten haben, dann werden die Werte korrigiert. Nur dann werden die Koordinaten in den variablen der Basisklasse aktualisiert und gespeichert. 

//+----------------------------------------------------------------
//| Aktualisieren der Position des Schiebereglers                           |
//+----------------------------------------------------------------
void CScrollV::UpdateThumb(const int new_y_point)
  {
   int y=new_y_point;
//--- Zurücksetzen des Fixpunktes
   CScroll::m_thumb_point_fixing=0;
//--- Überprüfung ob die Werte den Arbeitsbereich nach unten überschritten haben und Korrektur der Werte
   if(new_y_point>m_bg.Y2()-CScroll::m_thumb_length)
     {
      y=m_bg.Y2()-CScroll::m_thumb_length;
      CScroll::CurrentPos(int(CScroll::m_thumb_steps_total));
     }
//--- Überprüfen ob die Werte den Arbeitsbereich nach oben überschritten haben und Korrektur der Werte
   if(new_y_point<=m_bg.Y())
     {
      y=m_bg.Y();
      CScroll::CurrentPos(0);
     }
//--- Aktualisierung der Koordinaten und Ränder
   m_thumb.Y(y);
   m_thumb.Y_Distance(y);
   m_thumb.YGap(m_thumb.Y()-(CElement::Y()-CElement::YGap()));
  }

Wir benötigen jetzt noch eine weitere private Methode für die Korrektur der aktuellen Position des Schiebereglers in Relation zu seiner Y Koordinate. Lassen Sie sie uns CScrollV::CalculateThumbPos() nennen. Ihr Programmcode wird nachfolgend gezeigt. 

class CScrollV : public CScroll
  {
private:
   //--- Korrigiert die Position des Schiebereglers
   void              CalculateThumbPos(void);
  };
//+----------------------------------------------------------------
//| Korrigiert die Position des Schiebereglers                        |
//+----------------------------------------------------------------
void CScrollV::CalculateThumbPos(void)
  {
//--- Abbrechen, falls der Schritt Null ist
   if(CScroll::m_thumb_step_size==0)
      return;
//--- Korrigiert den Wert der Position der Scrollbar
   CScroll::CurrentPos(int((m_thumb.Y()-m_bg.Y())/CScroll::m_thumb_step_size));
//--- Überprüfung auf Überschreitung des Arbeitsbereiches nach oben und unten
   if(m_thumb.Y2()>=m_bg.Y2()-1)
      CScroll::CurrentPos(int(CScroll::m_thumb_steps_total-1));
   if(m_thumb.Y()<m_bg.Y())
      CScroll::CurrentPos(0);
  }

Lassen Sie uns nun die public (öffentliche) Methode CScrollV::ScrollBarControl() Für die Verwaltung des Schiebereglers erzeugen. Alle oben besprochenen privaten Methoden werden in dieser Methode aufgerufen. Diese muss in der OnEvent() Methode des Eventhandlers von den Elementen aufgerufen werden, die eine Scrollbar besitzen. Wir werden noch ein detailliertes Beispiel in dem zweiten Kapitel zeigen, wo wir eine Klasse für die Erzeugung des ListView-Controls entwickeln. 

Der Programmcode der CScrollV::ScrollBarControl() Methode wird nachfolgend gezeigt. Die Mauszeiger-Koordinaten und der Status der linken Maustaste werden hier als Argumente übergeben. Zu Beginn überprüfen wir den Fokus über der Scrollbar. Anschließend überprüfen wir, über welchen Bereich die linke Maustaste gedrückt wurde. In Abhängigkeit der aktuellen Mauszeigerposition und dem Status der linken Maustaste, verändern sich die Farben der Scrollbar. Anschließen, nachdem die Verwaltung der Scrollbar übergeben wurde, wird die Scrollbar entsprechend der neu berechneten Y Koordinate bewegt. Die Nummer des ListView-Elements wird in Relation dazu berechnet. 

class CScrollV : public CScroll
  {
public:
   //--- Verwalten der Scrollbar
   bool              ScrollBarControl(const int x,const int y,const bool mouse_state);
  };
//+----------------------------------------------------------------
//| Verwalten der Scrollbar                                           |
//+----------------------------------------------------------------
bool CScrollV::ScrollBarControl(const int x,const int y,const bool mouse_state)
  {
//--- Überprüfen des Fokus über der Scrollbar
   m_thumb.MouseFocus(x>m_thumb.X() && x<m_thumb.X2() && 
                      y>m_thumb.Y() && y<m_thumb.Y2());
//--- Überprüfen und Abspeichern des Status der linken Maustaste
   CScroll::CheckMouseButtonState(mouse_state);
//--- Verändern der Farbe der Scrollbar
   CScroll::ChangeObjectsColor();
//--- Falls die Verwaltung der Scrollbar übergeben worden ist, Identifizierung der Position der Scrollbar
   if(CScroll::ScrollState())
     {
      //--- Bewegen des Schiebereglers
      OnDragThumb(y);
      //--- Ändert den Wer der Position der Scrollbar
      CalculateThumbPos();
      return(true);
     }
//---
   return(false);
  }

Die CScrollV::CalculateThumbPos() Methode konvertiert die Y Koordinate in die Nummer des ListView-Elementes. Wir benötigen zudem eine Methode für eine Rückwärts-Konvertierung. Das bedeutet die Berechnung der Y Koordinate in Relation zu der aktuellen Position der Scrollbar. Hier gibt es ebenfalls Überprüfungen für das Überschreiten des Arbeitsbereiches und eine Korrektur im Falle einer Überschreitung. Am Ende der Methode werden die Koordinaten und Ränder der Objekte aktualisiert. 

class CScrollV : public CScroll
  {
public:
   //--- Berechnung der y-Koordinate der Scrollbar
   void              CalculateThumbY(void);
  };
//+----------------------------------------------------------------
//| Berechnung der y-Koordinate der Scrollbar                 |
//+----------------------------------------------------------------
void CScrollV::CalculateThumbY(void)
  {
//--- Identifizierung der aktuellen y-Koordinate der Scrollbar
   int scroll_thumb_y=int(m_bg.Y()+(CScroll::CurrentPos()*CScroll::m_thumb_step_size));
//--- Falls der Arbeitsbereich nach oben überschritten worden ist
   if(scroll_thumb_y<=m_bg.Y())
      scroll_thumb_y=m_bg.Y();
//--- Falls der Arbeitsbereich nach unten überschritten worden ist
   if(scroll_thumb_y+CScroll::m_thumb_length>=m_bg.Y2() || 
      CScroll::CurrentPos()>=CScroll::m_thumb_steps_total-1)
     {
      scroll_thumb_y=int(m_bg.Y2()-CScroll::m_thumb_length);
     }
//--- Aktualisierung der Koordinate und der Ränder entlang der y-Achse
   m_thumb.Y(scroll_thumb_y);
   m_thumb.Y_Distance(scroll_thumb_y);
   m_thumb.YGap(m_thumb.Y()-m_wnd.Y());
  }

Die CScrollV::CalculateThumbY() Methode wird in den Methoden für die Verwaltung des Klickens auf die Scrollbar-Buttons aufgerufen, so wie es in dem nachfolgenden Programmcode gezeigt wird. Den Methoden CScrollV::OnClickScrollInc() und CScrollV::OnClickScrollDec() wird lediglich der Name des Objektes als einziges Argument übergeben. Zu Beginn der Methode werden die folgenden Parameter geprüft.

  • Ob dieser Button gedrückt wurde. Überprüfung über den Objektnamen.
  • Status der Scrollbar. Um die Überprüfung abzuschließen, muss der Modus "frei" sein.
  • Die anzahl der schritte muss definiert sein und dieser Wert kann nicht kleiner als 1 sein.

Wenn alle diese Überprüfungen erfolgreich waren, dann wird die Position um einen Schritt verändert, unter der Berücksichtigung, dass der Arbeitsbereich nicht überschritten werden kann. Anschließend wird in der CScrollV::CalculateThumbY() Methode die Y Koordinate berechnet und aktualisiert, sowie auch die Ränder von den Ecken des Formulars. Der Button muss in dem on Status verbleiben, nachdem er gedrückt wurde.

class CScrollV : public CScroll
  {
public:
   //--- Verarbeiten eines Klicks auf die Scrollbar buttons
   bool              OnClickScrollInc(const string clicked_object);
   bool              OnClickScrollDec(const string clicked_object);
  };
//+----------------------------------------------------------------
//| Verarbeiten eines Klicks auf den nach oben / nach links Button          |
//+----------------------------------------------------------------
bool CScrollV::OnClickScrollInc(const string clicked_object)
  {
//--- Abbrechen, falls es sich nicht um einen Klick auf dieses Objekt gehandelt hat oder falls die Scrollbar nicht aktiv ist oder falls die Anzahl der Schritte nicht identifiziert werden konnte.
   if(m_inc.Name()!=clicked_object || CScroll::ScrollState() || CScroll::m_thumb_steps_total<1)
      return(false);
//--- Verringern des Wertes der Scrollbar-Position
   if(CScroll::CurrentPos()>0)
      CScroll::m_current_pos--;
//--- Berechnung der y-Koordinate der Scrollbar
   CalculateThumbY();
//--- Setzen des On-Status
   m_inc.State(true);
   return(true);
  }
//+----------------------------------------------------------------
//| Verarbeiten eines Klicks auf dem nach unten / nach rechts Button         |
//+----------------------------------------------------------------
bool CScrollV::OnClickScrollDec(const string clicked_object)
  {
//--- Abbrechen, falls es sich nicht um einen Klick auf dieses Objekt gehandelt hat oder falls die Scrollbar nicht aktiv ist oder falls die Anzahl der Schritte nicht identifiziert werden konnte.
   if(m_dec.Name()!=clicked_object || CScroll::ScrollState() || CScroll::m_thumb_steps_total<1)
      return(false);
//--- Erhöhen des Wertes für die Scrollbar-Position
   if(CScroll::CurrentPos()<CScroll::m_thumb_steps_total-1)
      CScroll::m_current_pos++;
//--- Berechnung der y-Koordinate der Scrollbar
   CalculateThumbY();
//--- Setzen des On-Status
   m_dec.State(true);
   return(true);
  }

Die Entwicklung der Methoden für die Verwaltung der vertikalen Scrollbar ist hiermit abgeschlossen. Die gleichen Methoden werden für die horizontale Scrollbar verwendet, mit dem einzigen Unterschied dass hier die Berechnungen für die X Koordinate durchgeführt werden. 

 


Schlussfolgerung

In diesem Kapitel haben wir die vertikale und horizontale Scrollbar betrachtet. In dem nachfolgenden Artikel werden wir ein weiteres Element des grafischen Interfaces entwickeln - die ListView. Die Anzahl der Elemente in der ListView passen eventuell nicht in den verfügbaren Platz und in diesem Fall benötigen wir das Scrollbar-Control, welches wir in diesem Artikel entwickelt haben.

Sie können das gesamte Material des fünften Teils herunterladen und testen. Wenn Sie fragen zur Verwendung dieses Materials haben, dann können Sie zunächst auf die detaillierte Beschreibung in dem Artikel zu dieser Bibliothek zurückgreifen oder Sie stellen Ihre Frage(n) in den Kommentaren zu diesem Artikel.

Liste der Artikel des fünften Teils:

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/2379

Beigefügte Dateien |
Grafische Interfaces IV: Der Multi-Window-Modus und das System für Prioritäten (Kapitel 2) Grafische Interfaces IV: Der Multi-Window-Modus und das System für Prioritäten (Kapitel 2)

In diesem Kapitel werden wir die Bibliothek um die Möglichkeit der Erzeugung von Multi-Window-Modus-Interfaces für MQL Anwendungen erweitern. Wir werden zudem ein System für die Priorität eines Klicks mit der linken Maustaste auf grafische Objekte entwickeln. Dieses ist notwendig um Probleme zu vermeiden, falls der Anwender auf ein grafisches Element klickt und dieses nicht reagiert.

Grafische Interfaces IV: Informierende Interface-Elemente (Kapitel 1) Grafische Interfaces IV: Informierende Interface-Elemente (Kapitel 1)

Zum aktuellen Stand der Entwicklung, beinhaltet die Bibliothek für die Erzeugung von grafischen Interfaces ein Formular und verschiedene Steuerelemente (Controls), welche dem Formular hinzugefügt werden können. Wie zuvor schon erwähnt, sollte sich einer der zukünftigen Artikel mit dem Thema Multi-Window-Modus beschäftigen. Dafür liegt nun alles vor, und wir werden in dem folgenden Kapitel dieses Thema behandeln. In diesem Kapitel schreiben wir Klassen für die Erzeugung der Statusbar und des Tooltip-Elementes.

Grafische Interfaces V: Das ListView-Element (Kapitel 2) Grafische Interfaces V: Das ListView-Element (Kapitel 2)

In dem vorherigen Kapitel haben wir Klassen für die Erzeugung der vertikalen und horizontalen Scrollbar geschrieben. In diesem Kapitel werden wir diese implementieren. Wir werden eine Klasse für das Erzeugen eines ListView Elementes (Liste / Listenansicht) schreiben, bei der eine Komponente eine vertikale Scrollbar darstellt.

Die Erstellung eines Helfers im manuellen Handeln Die Erstellung eines Helfers im manuellen Handeln

Die Anzahl der Handelsroboter für die Arbeit an Devisenmärkten nimmt in den letzten Jahren lawinenartig zu. In den Robotern werden verschiedene Konzepte und Strategien umgesetzt, keinem ist aber bis jetzt gelungen, eine gewinnsichere künstliche Intelligenz zu entwilckeln. Aus diesem Grund bleiben viele Trader manuellem Handel treu. Aber auch für sie werden Assistenten, die sogenannten Trading Panels erstellt. Dieser Artikel stellt ein Beispiel für die Erstellung eines solchen Panels von Grund auf dar.