Galerie der in MQL geschriebenen UIs - Seite 65
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
Wie kann man den Ein-/Aus-Zustand der Taste ermitteln?
Das ist das nächste Thema. Wir werden es heute behandeln.
Ich sollte hinzufügen, dass die Elemente dieser GUI gezeichnet werden, so dass die Standardmethode zum Abrufen des Zustands ObjectGetInteger(0, "button1", OBJPROP_STATE); nicht funktionieren wird.
Außerdem möchte ich Sie daran erinnern, dass Ereignisse von Elementen, einschließlich Schaltflächen, an die API-Datei gesendet werden.
Eine allgemeine Liste der zu beachtenden Themen:
1. die Orientierung in der Liste von intellisense und die Auswahl der Funktion des richtigen Fensters.
2. Programmgesteuertes Öffnen und Schließen von Fenstern.
3. die Orientierung in der Liste von intellisense und die Auswahl des richtigen Elements im richtigen Fenster.
4. Navigieren durch Listen einzelner Elementeigenschaften.
5. Parsing des Namens einer Element- und Fenster-Wrapper-Funktion.
6. Rückgabe des Parameterwertes eines ausgewählten Elementes an eine Variable seines Typs. Betrachtung von drei Typen mehrerer verschiedener Elemente.
7. Setzen von Werten in den Parametern verschiedener Typen von Elementen. Schauen wir uns an, wie die Werte in den Schnittstellenfenstern dieser Elemente erscheinen werden.
8. Rückgabe der Parameterwerte eines Elements, Änderung und Weiterleitung dieses Werts an ein anderes Element. Betrachten Sie verschiedene Arten von Elementen und Werten, und testen Sie die Weiterleitung zwischen verschiedenen Arten von Elementen in verschiedenen Fenstern.
9. Rückgabe des letzten Wertes (_V_LAST). Wann und für welche Fälle wird der letzte Wert benötigt (nicht zu verwechseln mit dem aktuellen Wert).
10. Testen Sie die Einstellung der Zustände ON/OFF/LOCK_ON/LOCK_OFF/LOCK/UNLOCK für verschiedene Arten von Elementen.
11. Versuchen Sie, die Änderungen der Werte von Elementen verschiedener Typen zu verknüpfen und zu synchronisieren: z.B. Eingabefeld mit Schaltflächen und Schieberegler. Nehmen wir an, dass, wenn sich der Wert eines Elements (manuell oder Software) ändert, sich der Wert im zweiten Element entsprechend ändert.
12. Versuchen wir, die Bereichsgrenzen des Schiebereglers und des Eingabefeldes mit Schaltflächen über Wrapper-Funktionen programmatisch zurückzusetzen. Ich hatte noch keine Zeit, das zu testen, aber etwas deutet darauf hin, dass es funktionieren wird. Wie auch immer, schauen wir mal.
13. Versuchen wir, Elementzustände über Wrapper-Funktionen zurückzugeben. Das ist in der Funktionalität enthalten, aber ich hatte noch keine Zeit, es zu testen. Wir werden also sehen... Das Ergebnis ist unbekannt.
14. Lassen Sie uns die Farben für Text und Elementbasen abrufen und setzen. Wir können versuchen, diese Farben mit einigen einfachen Ereignissen oder Wertgrenzen zu verknüpfen.
15. Ich erzähle Ihnen mehr darüber, wie Sie den Ausdruck der neuen API-Datei navigieren und lesen können.
//------------------------------------------
Die Themen, die wir bereits behandelt haben, sind gelb hervorgehoben.
Heute werden wir sie wiederholen:
11. Synchronisierung (Verknüpfung) von sich ändernden Werten von Elementen verschiedener Typen: z.B. Eingabefeld mit Schaltflächen und Schieberegler. Wenn Sie den Wert eines Elements (manuell oder per Software) ändern, ändert sich der Wert im zweiten Element entsprechend.
12. Lassen Sie uns versuchen, die Bereichsgrenzen des Schiebereglers und des Eingabefeldes mit Schaltflächen über Wrapper-Funktionen programmatisch zurückzusetzen. Ich hatte noch keine Zeit, das zu testen, aber etwas deutet darauf hin, dass es funktionieren wird. Wie auch immer, schauen wir mal.
13. Versuchen wir, Elementzustände über Wrapper-Funktionen zurückzugeben. Das ist in der Funktionalität enthalten, aber ich hatte noch keine Zeit, es zu testen. Wir werden also sehen... Das Ergebnis ist unbekannt.
11. Bindung von Parametern von Elementen verschiedener Typen.
Dem aufmerksamen Betrachter ist aufgefallen, dass in einer Mehrfenster-GUI verschiedene Elemente oft durch Parameterwerte, Eigenschaften und Zustände miteinander verbunden sind. Zum Beispiel:
//-------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------
Man könnte meinen, es gäbe irgendwo eine unsichtbare Elementverbindung. Und die gibt es tatsächlich. Aber sie ist nur für einen außenstehenden Beobachter unsichtbar. Für einen Entwickler ist sie ganz offensichtlich und wir werden sie heute im Detail betrachten.
1. Die Verbindung von Elementen hat zwei Seiten:
Die technische Realisierung von Verbindungen wird durch das Vorhandensein einer grafischen Engine vereinfacht.
Lassen Sie mich das erklären:
In einem herkömmlichen Expert Advisor wird jeder Parameter vom Benutzer erfunden, benannt, gespeichert und verarbeitet . Dies ist eine Routinearbeit, die nicht umgangen werden kann. Bei der Verwendung einer grafischen Engine erhalten die im Konstruktor erstellten Elemente jedoch automatisch den Parameter zusammen mit dem Speicherort und der Verarbeitungs-/Rückgabefunktion. Darüber hinaus erhält der Benutzer ihre Eigenschaften wie Typ, Bereich, früherer Wert usw. Dies vereinfacht die Arbeit erheblich. Theoretisch ist es möglich, vorgefertigte Parameter von GUI-Elementen als andere Benutzerparameter zu verwenden und sie direkt mit der Handelslogik zu verknüpfen. Zum Beispiel, Lot, Trailing Stop, Take-Take-Profit und andere, nicht von ihren eigenen Variablen, sondern von den Einstellungsfeldern, die für ihre Werte verantwortlich sind.
Einige allgemeine Schlussfolgerungen:
1. Das Vorhandensein eines grafischen Steuerelements in einem Programm = das Vorhandensein eines vorgefertigten Programmparameters + seine Eigenschaften + die Funktion der Rückgabe/Einstellung des Wertes.
2. Je mehr Steuerelemente in den Fenstern des Schnittstellenprogramms platziert sind, desto mehr Parameter sind an der Handelslogik und der Eingabe/Ausgabe von Handelsinformationen beteiligt.
3. je mehr Einstellungen und Fenster - desto höher die Kontrolle und desto größer die Bandbreite der Marktdatenausgabe (unbeschadet der Automatisierung).
4. Je höher die Kontrolle und je größer die Bandbreite der Marktdatenausgabe, desto besser ist das Bewusstsein des Händlers.
5. Bewusstsein multipliziert mit Automatisierung und Kontrolle = Skalierung der Möglichkeiten des Händlers.
Ich sollte noch hinzufügen, dass die Automatisierung oft gegen die manuelle Kontrolle steht. Es heißt, eine grafische Oberfläche bedeute manuellen Handel. Das ist aber nicht der Fall. Die Softwareschnittstelle schließt die Automatisierung nicht aus, sondern erweitert sie, indem sie ihr einen "Gradienten" hinzufügt - sie eröffnet drei Optionen: manuelle Kontrolle, halbautomatischer Handel und autonomer Modus.
Alles, was der Händler tun muss, ist, eine Option auszuwählen.
Meine Güte, es ist einfach, ein Fenster für diesen Zweck zu erstellen.
//---------------------------------------------------------------------------------------------------
2. Kommen wir nun zur technischen Umsetzung der Bindungsparameter von Steuerelementen.
Betrachten wir einige praktische Beispiele:
1. öffnen wir ein vertrautes Einstellungsfenster:
2. öffnen Sie die API-Datei und finden Sie die Elemente des geöffneten Fensters in der Funktion On_Gui_Event():
Zur Erinnerung: Alle Steuerereignisse kommen in die Funktion On_Gui_Event();
In diesem Zusammenhang werden wir einige der Parameterlinks innerhalb dieser Funktion und einige außerhalb ihres Körpers schreiben.
1. Stellen wir eine Verbindung zwischen dem Feld mit den Schaltflächen (S_EDIT) "Drehen Sie den Wert" und dem Schieberegler (H_SLIDER) "Drehen Sie den Wert" her:
Ergebnis: Wir ändern den Wert im Feld mit den Schaltflächen, und der Schieberegler bewegt sich von selbst.
(*Wichtig - der Schieberegler kann sich nur innerhalb seines Bereichs bewegen (in diesem Fall von 0 bis 100). Wird der Bereich überschritten, ändert sich der Wert nicht, sondern es wird ein Fehler im Protokoll angezeigt).
//----------------------------------------------------------------------------------------------------------------
3. Lassen Sie uns die Rolle umkehren. Der Schieberegler wird den Wert im Eingabefeld steuern:
Ergebnis: Wenn Sie den Schieberegler bewegen, ändert das Feld mit den Schaltflächen den Wert synchron.
//----------------------------------------------------------------------------------------------------------------
4. Schreiben wir die gegenseitige Steuerung des Schiebereglers und des Feldes mit den Schaltflächen durch einander:
Ergebnis: Schieberegler und Eingabefelder steuern sich gleichzeitig gegenseitig.
//---------------------------------------------------------------------------------------------------
Morgen werde ich den zweiten Teil dieses Themas mit anderen Elementen veröffentlichen.
Dieses Zeug ist großartig! Ich plane, diesen Thread in mehr Details gegeben Zeit zu überprüfen. Ich dachte, meine Arbeit war schieben den Umschlag von mt4 GUI, aber Ihre Arbeit ist nächste Ebene.
Das ist ein großartiges Material! Ich plane, dieses Thema in mehr Details zu erforschen, wenn ich Zeit habe. Ich dachte, meine Arbeit wurde die Grenzen der mt4 GUI schieben, aber Ihre Arbeit ist nächste Ebene.
Vielen Dank für Ihre freundlichen Worte!
11. Bindungsparameter von Elementen verschiedener Typen.
Fortführung des Themas.
Teil 2.
//--------------------------------------------------------------------------------------------------------------------------------
Schauen wir uns an, ob wir die gezeigte Bindungsmethode auf andere Elemente anwenden können. Zum Beispiel auf Kontrollkästchen.
1. Wir wollen das oberste Kästchen sperren und das darunter liegende Kästchen entsperren:
Um dies zu tun:
1. Suchen wir in der API-Datei das Kontrollkästchen"Eine Option festlegen".
2. Schreiben Sie einen Funktionsaufruf für das Kontrollkästchen"Eine andere Option einstellen", der das Kontrollkästchen sperren/entsperren soll.
Ergebnis: Das Kontrollkästchen wird wie vorgesehen gesperrt und entsperrt:
//--------------------------------------------------------------------------------------------------------------------------------
2. lassen Sie uns nun das Kontrollkästchen sperren und die beiden darunter liegenden Kontrollkästchen entsperren:
Ergebnis: Das Kontrollkästchen sperrt und entsperrt die beiden darunter liegenden Kontrollkästchen:
So sieht es in Dynamics aus:
//--------------------------------------------------------------------------------------------------------------------------------
3. lösen wir nun das Problem, das im folgenden Diagramm dargestellt ist: Die Kontrollkästchen sollen die gegenüberliegenden Dropdown-Listen sperren und entsperren.
Um dies zu tun:
Ergebnis: Die Kontrollkästchen sperren die Dropdown-Listen und sperren sich selbst mit dem Hauptkontrollkästchen:
//--------------------------------------------------------------------------------------------------------------------------------
4. Gehen wir zur nächsten Aufgabe über: Die Dropdown-Listen sollen den vom Benutzer ausgewählten Wert in ein Feld eines anderen Fensters übersetzen.
Um dies zu tun:
*Ergebnis: Beide Dropdown-Listen senden ihre Werte erfolgreich an die Eingabefelder im gegenüberliegenden Fenster:
//--------------------------------------------------------------------------------------------------------------------------------
5. Die folgende Aufgabe ist in diesem Diagramm dargestellt: Die umgeschalteten Optionsfelder müssen ihren Namen an die gegenüberliegenden Eingabefelder senden.
Um dies zu tun:
*WichtigerHinweis: Optionsfelder werden umgeschaltet, weil der SWITCH-Operator im KIB-Code auf sie angewendet wurde. Daher haben sie einen gemeinsamen Parameter für alle und befinden sich in der API-Datei im gleichen Fall.
Ergebnis: Das Umschalten der Schaltflächen bewirkt, dass sich der Text im Eingabefeld ändert. *Esgibt ein kleines technisches Problem mit dieser Option. Eswird in der nächsten Version behoben werden.
Der zweite Teil ist abgeschlossen.
Im dritten Teil werden wir mit der Tabelle arbeiten.
Der letzte Teil des Themas der Parameterbindung.
Übergeben wir die Werte der Elementparameter an die Tabellenzellen.
Schema:
Lösung:
Ergebnis: Die Werte werden sicher in den ausgewählten Tabellenzellen platziert.
Wie Sie an den obigen Beispielen sehen können, haben wir eine einfache und bequeme Lösung entwickelt. Ich hoffe, dass sie für viele nützlich ist.
Damit ist das Thema der Verknüpfung von Elementparametern abgeschlossen.
Die folgenden Themen müssen noch behandelt werden:
12. Programmatische Ermittlung/Einstellung von Wertgrenzen des Schieberegler- und Schaltflächenfeldes(_V_MIN, _V_MAX, _V_STEP, _DIGITS).
13. Abfrage des Status von Elementen(_GET_STATE).
14. Verknüpfung von Text- und Rahmenfarben mit Wertabstandsgrenzen.
15. Ausrichtung in der API-Datei.
Hinzufügen eines Themas:
16. Realisierung der Programmlogik für das Aussehen von Meldungs- und Warnfenstern.