Grafische Interfaces V: Die vertikale und horizontale Scrollbar (Kapitel 1)
684
0
Inhalt
- Einleitung
- Das Scrollbar Control
- Basis-Klasse des Controls
- Abgeleitete Classen des Controls
- Schlussfolgerung
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.
- Der Hintergrund.
- Der Hintergrund des Schiebereglers.
- Zwei Buttons für das Bewegen der Daten um einen Schritt.
- 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.
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:
- Grafische Interfaces V: Die vertikale und horizontale Scrollbar (Kapitel 1)
- Grafische Interfaces V: Das ListView-Element (Kapitel 2)
- Grafische Interfaces V: Das Combobox-Element (Kapitel 3)
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/2379
Grafische Interfaces V: Das ListView-Element (Kapitel 2)
Grafische Interfaces IV: Der Multi-Window-Modus und das System für Prioritäten (Kapitel 2)
Die Erstellung eines Helfers im manuellen Handeln
Grafische Interfaces IV: Informierende Interface-Elemente (Kapitel 1)
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.