Galerie der in MQL geschriebenen UIs - Seite 58

Neuer Kommentar
 
Eine voll funktionsfähige Basisversion der Engine und des Builders ist ein gültiges und erreichbares Ziel. Es erfordert einen klaren Plan und eine Prioritätensetzung. Das wiederum bedeutet das Ende des Hinzufügens großer Aufgaben zu den Plänen und den Beginn der Lösung dringender Probleme.

Lassen Sie mich eine Analogie zum Bau eines Hochhauses anführen. Stellen wir uns ein Projekt vor, bei dem der Bauleiter nicht genau weiß, wie viele Stockwerke gebaut werden müssen. Nehmen wir an, dass er nicht informiert wurde. Aber er ist im Herzen ein Schöpfer - ein kreativer Mensch. Es ist ihm egal. Je größer, desto besser. Er mag hohe Häuser und Wolkenkratzer. Während er arbeitet, wird weiter gebaut, werden Stockwerke hinzugefügt und das Gebäude wächst in den Himmel. Aber die Wohnungen können nicht an die Mieter übergeben werden, weil die Gerüste nicht entfernt und die Wohnräume nicht gereinigt wurden. Selbst die Türen sind nicht eingesetzt. Das Haus ist unvollendet. Aber für den Bauleiter sind das Kleinigkeiten. Er blickt nach oben. In den Himmel. Und die Mieter warten schon ungeduldig, sie brauchen Wohnungen.

Im Allgemeinen ist es für den Polier an der Zeit, "die Firmware zu wechseln" und sich geistig neu zu organisieren. Er sollte aufhören, Stockwerke zu bauen, und anfangen, Türen in die Öffnungen zu setzen. Und endlich anfangen, die Räume zu reinigen, Wände zu verputzen, Parkett zu verlegen und Kronleuchter zu installieren ....

Lassen Sie es mich so ausdrücken: Die Böden werden vorerst nicht gebaut. Stattdessen werden die bereits gebauten Böden fertiggestellt. Die Arbeiten werden so geplant, dass das Haus so schnell wie möglich an die Mieter übergeben werden kann.

Schließlich wurde das Haus für sie gebaut....


 

Hallo zusammen,

Angesichts der jüngsten Diskussion möchte ich vorschlagen, dass wir die Ergebnisse und Fortschritte des Projekts von Peter Konow in der "Codebase" und nicht im Forum dokumentieren. Das Forum eignet sich hervorragend für Diskussionen und unmittelbares Feedback, aber es fehlt ihm die Struktur und Kohärenz, die notwendig ist, um das Gesamtbild und die konsistente Politik des Projekts darzustellen.

Durch die Verwendung der Codebase können wir sicherstellen, dass alle relevanten Informationen organisiert und leicht zugänglich sind und einen klaren Überblick über den Stand des Projekts bieten. Dies wird nicht nur dazu beitragen, Klarheit zu schaffen, sondern auch die Zusammenarbeit und das Verständnis zwischen allen Teammitgliedern und Beteiligten zu verbessern.

Ich wäre Ihnen sehr dankbar, wenn Sie diese Anregung berücksichtigen könnten.

 
Yutaka Okamoto Projekts von Peter Konow in Codebase und nicht im Forum dokumentiert werden. Das Forum ist großartig für Diskussionen und unmittelbares Feedback, aber es fehlt die Struktur und Kohärenz, die notwendig ist, um das Gesamtbild und die konsistente Politik des Projekts zu präsentieren.

Durch die Verwendung einer 'Codebase' können wir sicherstellen, dass alle relevanten Informationen organisiert und leicht zugänglich sind und ein klares Bild vom Stand des Projekts vermitteln. Dies trägt nicht nur dazu bei, Klarheit zu schaffen, sondern fördert auch die Zusammenarbeit und das Verständnis zwischen allen Teammitgliedern und Beteiligten.

Ich wäre Ihnen sehr dankbar, wenn Sie diesen Vorschlag prüfen würden.

Es ist ein sehr vernünftiger Vorschlag, vielen Dank. Zweifellos ist die Codebasis sehr praktisch, um Aktualisierungen zu veröffentlichen und mit den Benutzern zu kommunizieren. Sie ist eine große Bereicherung für die Entwicklung des Projekts. Obwohl ich die Codebase in der Vergangenheit kaum genutzt habe, sehe ich jetzt den praktischen Sinn darin, die Bedingungen zu erkunden und mich an die Anforderungen anzupassen. Um eine Vorstellung von den Möglichkeiten und Grenzen dieser Plattform zu bekommen, werde ich mir Projekte von bekannten Mitgliedern der Community ansehen. Anhand ihres Beispiels werde ich das Projekt in der Codebase informativ und kompetent durchführen können.

 

Ich habe für heute eine Veröffentlichung geplant.

Allerdings habe ich beschlossen, den hilfreichen Rat eines Forumsmitglieds zu folgen und die neue Version in der Codebase zu veröffentlichen. Um es richtig zu machen, werde ich ein paar Tage brauchen, um Beispiele ähnlicher Veröffentlichungen zu studieren, einen Plan für den Parallelbetrieb des Projekts im Forum und dort zu erstellen. Und auch um die Moderation zu durchlaufen.

Ein paar Worte zu dieser Version:

1. Konzeption und Implementierung eines Systems der programmatischen Interaktion zwischen einem Benutzerprogramm und seiner grafischen Schnittstelle.

Mehr Details:

  • Nach der Durchführung technischer Tests und der Analyse der Ergebnisse wurde beschlossen, Element-Wrapper-Funktionen anstelle von abstrakten globalen Eigenschaften zu verwenden. Wie sich herausstellte, ist dies die effektivste und einfachste Variante der Programmkopplung von Algorithmen mit der grafischen Umgebung.
  • Die Funktionen zum Speichern und Drucken der Dateien UIDATA.mqh und API.mqh wurden so ergänzt, dass jedes interaktive Element der Schnittstelle beim Speichern des Projekts automatisch eine Wrapper-Funktion erhält.
  • Gleichzeitig haben die Element-Wrapper-Funktionen einen sehr kleinen Körper und ihre Hauptaufgabe besteht darin, die zentrale Funktion aufzurufen und dabei drei Hauptparameter zu übergeben - Elementnummer, Wert und Eigenschaftswert.
  • Dieäußere Einfachheit der Funktionen behindert die Vielseitigkeit ihrer Anwendung nicht:

1. Wenn sie mit leeren Klammern aufgerufen werden, geben die Funktionen den Wert des Elementparameters mit einem der drei Typen zurück: int, double, string je nach dem Typ des Elements.

     int i    = w6_i_CHECKBOX_Some_checkbox(); //Элемент чекбокс. Буква i  после префикса означает что тип возвращаемого/устанавливаемого значения int.
     
     double d = w6_d_S_EDIT_Spin_the_value();  //Элемент поле ввода с кнопками. Буква d после префикса означает что тип возвращаемого/устанавливаемого значения double.

     string s = w7_s_EDIT_Comment_1();         //Элемент текстовое поле ввода. Буква s означает что тип возвращаемого/устанавливаемого значения string.

2. Beim Aufruf mit einem Wert in Klammern setzen die Funktionen den übergebenen Wert auf den Elementparameter und zeichnen ihn dann neu (der Wert wird je nach Elementtyp auf int, double oder string gesetzt).

     int i    = w6_i_CHECKBOX_Some_checkbox(0/1/2/3); //Элемент чекбокс. Передача нуля,единицы, двойки или тройки для смены между нейтральным, активированным, нетр.блокир. и актив. блокир. состояниями элемента. 
                                                      //Тот же метод работает для всех кнопок.
     
     double d = w6_d_S_EDIT_Spin_the_value(653.89);   //Элемент поле ввода с кнопками. Передача значения параметра в функцию для установки его в элемент.

     string s = w7_s_EDIT_Comment_1("Any text");      //Элемент текстовое поле ввода. Передача текста для установки в поле ввода.   


3. Beim Aufruf mit dem Standardwert des ersten Parameters und einer Eigenschaftsnummer (aus den verfügbaren Eigenschaften) geben die Funktionen den Wert dieser Eigenschaft des Elements zurück (alle Eigenschaftsnummern sind vom Typ int, übergeben im Eigenschaftsparameter).

      int i = w6_i_BUTTON_Start(get_i,_A_COLOR); //Элемент Кнопка. Возврат значения цвета из свойства _A_COLOR. Может быть указано другое значение или другое свойство из списка доступных свойств.
                                                                  //Однако, данных тип функции принимает значения только типа int, но может приводить их к другим родственным типам (uint, short, bool...).
                                                                  //Значение первого параметра get_i говорит функции что не нужно принимать значение первого параметра в расчет, а лишь вернуть значение свойства _A_COLOR.


4 . Wenn die Funktionen mitvalue und propertyvalue in Klammernaufgerufen werden, setzen sie die übergebenen Werte auf die verfügbaren Eigenschaften des Elements. DieEigenschaftsnummer wird im Property-Parameter übergeben, der Eigenschaftswert wird imValue-Parameter übergeben. 

     int i = w6_i_BUTTON_Start(C'255,0,0',_A_COLOR); //Элемент Кнопка. Передача и установка польз. значения цвета в свойство _A_COLOR. Может быть указано другое значение или другое свойство из списка доступных свойств.
                                                                      //Однако, тип функции этого элемента принимает значения только типа int, но может приводить их к другим родственным типам (uint, short, bool...).


Die Struktur der Funktions-Wrapper-Namen: w6_i_BUTTON_Start();

1. w ist der Anfangsbuchstabe aller Wrapper-Funktionen. Es ist eine Abkürzung für window.

2. 6 (oder eine andere Zahl) - die laufende Nummer des Fensters, das das Element enthält.

3. i (entweder d oder s) - bezeichnet den Typ des zurückgegebenen/eingestellten Wertes des Parameters des Elements.

  • Kann int sein: für Schaltflächen, Kontrollkästchen, Schieberegler, Eingabefelder mit/ohne Schaltflächen, Fortschrittsbalken, Diagrammbalken, Optionsfelder.
  • Kann double sein : für Schieberegler, Eingabefelder mit/ohne Schaltflächen.
  • Kann ein String sein : für Texteingabefelder, für VALUE-Elemente, für Tabellenzellen, für Pop-up-Listen.


4 BUTTON - Name des Elementtyps, zu dem die Wrapper-Funktion gehört. Es kann ein beliebiges anderes Element sein.

5. start - Name eines bestimmten Elements.


  • Alle Wrapper-Funktionen haben eine identische Namensstruktur.
  • Ich wiederhole: alle Funktionen werden automatisch gedruckt.

//----------------------------------------------------------------------------------------------------

Intelligente Anwendung des Intellisense-Systems:

Es wurde beschlossen, ein spezielles Präfix-System zu verwenden, das die Suche und das Auffinden der notwendigen Funktionen und Wrapper von Fenstern und Elementen erleichtert. Hier ist ein Beispiel:

Alle Fenster- und Element-Wrapper-Funktionen haben den Buchstaben w am Anfang. Wenn Sie jedoch einen kleinen Bindestrich nach w: _ setzen, öffnet sich ein Intellisense-Fenster mit einer Liste der Namen aller UI-Fensterfunktionen. Als Nächstes müssen Sie das Fenster mit dem gesuchten Namen in der Liste finden, sich seine Nummer ansehen (sie ist im Funktionsnamen angegeben), den Bindestrich löschen und diese Nummer hinter w setzen. Die Liste von intellisense mit den Namen der Funktionen der im Fenster enthaltenen Elemente wird sofort angezeigt. So wird es gemacht:

Dies ist ein einfacher Weg, um schnell durch die Liste der Element-Wrapper-Funktionen zu navigieren. Sie brauchen sie nicht einmal zu drucken.

//----------------------------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------------------------

Außerdem wurden Änderungen und Ergänzungen an der API-Datei vorgenommen. Jetzt stehen dem Benutzer mehr Informationen über das Element und das Fenster zur Verfügung:

 switch(Element)
   {
//=====================================================================================================================
//WINDOW:       Settings example 1 | #: 6 | PFX: w_6 | GET/SET: int w_6_Settings_example_1(int value = get_i, int Property = 0)
//---------------------------------------------------------------------------------------------------------------------
//ELEMENT:      BUTTON
//NAME:         Start
//PARAMETER:    int
//INIT STATE:   OFF
//LOCATION:     Location: Window's Main Frame
//---------------------------------------------------------------------------------------------------------------------
//GET/SET:   int w6_i_BUTTON_Start(int value = none, int Property = 0)      | PFX: w6
//=====================================================================================================================
  
case Settings_example_1___Start:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when button pressed or released?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                case pressed:  Alert("BUTTON Start pressed!");   break;
  
                case released:  Alert("BUTTON Start released!");   break;
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;
  
//=====================================================================================================================
//WINDOW:       Settings example 1 | #: 6 | PFX: w_6 | GET/SET: int w_6_Settings_example_1(int value = get_i, int Property = 0)
//---------------------------------------------------------------------------------------------------------------------
//ELEMENT:      CHECKBOX
//NAME:         Set an option
//PARAMETER:    int
//INIT STATE:   OFF
//LOCATION:     Location: Window's Main Frame
//---------------------------------------------------------------------------------------------------------------------
//GET/SET:   int w6_i_CHECKBOX_Set_an_option(int value = none, int Property = 0)      | PFX: w6
//=====================================================================================================================
  
case Settings_example_1___Set_an_option:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when checkbox checked or unchecked?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                case checked:  Alert("CHECKBOX Set_an_option pressed!");   break;
  
                case unchecked:  Alert("CHECKBOX Set_an_option released!");   break;
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;
  
//=====================================================================================================================
//WINDOW:       Settings example 1 | #: 6 | PFX: w_6 | GET/SET: int w_6_Settings_example_1(int value = get_i, int Property = 0)
//---------------------------------------------------------------------------------------------------------------------
//ELEMENT:      CHECKBOX
//NAME:         Set another option
//PARAMETER:    int
//INIT STATE:   OFF
//LOCATION:     Location: Window's Main Frame
//---------------------------------------------------------------------------------------------------------------------
//GET/SET:   int w6_i_CHECKBOX_Set_another_option(int value = none, int Property = 0)      | PFX: w6
//=====================================================================================================================
  
case Settings_example_1___Set_another_option:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when checkbox checked or unchecked?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                case checked:  Alert("CHECKBOX Set_another_option pressed!");   break;
  
                case unchecked:  Alert("CHECKBOX Set_another_option released!");   break;
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;
  
//=====================================================================================================================
//WINDOW:       Settings example 1 | #: 6 | PFX: w_6 | GET/SET: int w_6_Settings_example_1(int value = get_i, int Property = 0)
//---------------------------------------------------------------------------------------------------------------------
//ELEMENT:      D_LIST
//NAME:         D_LIST 1
//PARAMETER:    string
//INIT OPTION:  L_ITEM  1
//LOCATION:     Location: Window's Main Frame
//---------------------------------------------------------------------------------------------------------------------
//GET/SET:   string w6_s_D_LIST_D_LIST_1(string value = get_s, int Property = 0)      | PFX: w6
//=====================================================================================================================
 
Ich hoffe, dass ich diese Funktionen bald ausprobieren kann.
 
hini #:
Ich hoffe, dass ich diese Funktionen bald ausprobieren kann.
Ich werde die neue Version morgen Abend in Codobase hochladen.
 
Spätabendliche Veröffentlichung.
 

Ich präsentiere eine Version des Motors, die programmatisch mit der GUI interagiert.

Ich habe eine Menge getan. Es gibt etwas zu erzählen und zu zeigen.

Nach dem öffentlichen Testen werde ich es in die Codebase hochladen.

Eine interessante Sache hat sich herausgestellt...

Mehr Details morgen.

Dateien:
4uh38_06.08.24.zip  1712 kb
 

Um es gleich vorwegzunehmen: Ich habe eine sehr praktische Lösung für die Benutzer gefunden. Innerhalb ihres Codes können sie einfach durch Fenster, Elemente und Eigenschaften navigieren. Die Lösung erlaubt es ihnen, sich nicht an die Namen von Elementen oder Eigenschaften zu erinnern, sondern sie einfach zu finden und mit ihnen zu arbeiten. Gleichzeitig verfügt jedes Element über eine Liste von get/set-Eigenschaften, die nur für dieses Element und "verwandte" Elemente verfügbar sind. Da das Präfix in den Funktionsnamen des Elements eingebettet ist, ruft der Benutzer die Funktion auf und macht nicht den Fehler, eine Eigenschaft zurückzugeben oder zu setzen, die das Element nicht hat.

Die Wrapper-Funktionen haben sich als so vielseitig und einfach zu verwenden erwiesen, dass ich selbst überrascht bin. Sie geben den Wert eines Parameters zurück, wenn die Klammern leer sind, setzen ihn, wenn der Wert eins ist, geben den Wert einer Eigenschaft aus einer Liste zurück, wenn der erste Parameter leer ist und der Eigenschaftsindex im zweiten steht. Sie setzen einen Wert für eine Eigenschaft, wenn der erste Parameter einen Wert und der zweite einen Eigenschaftsindex enthält. Sie geben auch eine Ergebnismeldung zurück: 1 bei Erfolg und -1 bei Fehler (ungültiger Wert oder ungültige Eigenschaft). Die Funktionen zeichnen die Elemente selbst neu. Sie brauchen sich darum nicht zu kümmern.

Was Sie mit Wrapper-Funktionen tun können:

1. Den Wert des Elementparameters abfragen.

2. Den Wert eines Elementparameters setzen.

3. Holen Sie sich Werte von Element-Eigenschaften aus der individuellen Liste der Eigenschaften, die zu seinem Typ von Elementen gehören (aufgerufen durch das Präfix im Funktionsnamen geschrieben).

4. Setzen der Werte der Elementeigenschaften aus derselben Liste.

5. Einstellen des Zustands des Elements: neutral, aktiviert, (ein/aus), blockiert neutral, blockiert aktiviert.

6. Gibt den aktuellen Zustand des Elements zurück.


Im ersten Fall gibt die Funktion den Wert des Parameters zurück.

Im zweiten Fall gibt sie das Ergebnis zurück: erfolgreich oder Fehler. Der Fehler wird in das Protokoll ausgegeben.

Im dritten Fall gibt sie den Wert der Eigenschaft zurück.

Im vierten Fall - Ergebnis: Erfolg oder Fehler beim Setzen der Eigenschaft.

Im fünften Fall - gibt 1 oder -1 zurück.

Im sechsten Fall wird der Statusindex des Elements zurückgegeben (Details siehe unten).


Alles wird von einer Wrapper-Funktion erledigt, die automatisch gedruckt wird. Um es zu finden, geben Sie w_, die Liste der Intellisense wird geöffnet, es enthält die Namen der Fenster. In einem davon befindet sich das Element, das Sie suchen. Sie müssen sich ungefähr merken, in welchem Fenster es sich befindet. Dann löschen Sie den Teufel, tippen die Fensternummer ein und wählen das gesuchte Element aus der Liste der Elemente aus. Kein Auswendiglernen.

Auch die Eigenschaften der Elemente müssen Sie sich nicht merken. Schauen Sie sich den Namen des Elements an, sehen Sie das Präfix, um eine Liste der einzelnen Eigenschaften zu öffnen. Tippen Sie es ein, öffnen Sie es, wählen Sie die Eigenschaft aus. Sie brauchen sich überhaupt nichts zu merken. Sie müssen auch nicht tippen. Intellisense macht alles.

Windows hat auch seine eigenen Wrapper. Sie können sie öffnen und schließen. Der Rest der Funktionen ist noch nicht implementiert worden.


Ich habe ein großes Upgrade der API-Datei vorgenommen. Sie enthält jetzt eine RIESIGE Menge an nützlichen Informationen über das Element. Nämlich: Präfixe, individuelle Eigenschaften, Prototypen der Element-Wrapper-Funktion und ihres Fensters, die genaue Position des Elements (Tabelle, Canvas und Registerkarte, zu der das Element gehört, falls vorhanden), der Typ seines Parameters (int, double, string...), die Eigenschaften seines Parameters (Min.-Wert, Max.-Wert, Schritt, Anzahl der Ziffern nach dem Dezimalpunkt) werden ausgegeben. Anfangswert oder ausgewählte Option (je nach Element). Alles ist recht lesbar und verständlich gestaltet.

Ich habe die neue Funktionalität teilweise getestet und bin damit zufrieden. Alles funktioniert wie vorgesehen.

Morgen werde ich es in der Praxis zeigen.

 
Das Verzeichnis ist immer noch in Russisch ...... Ich hoffe, dass es möglich ist, das Verzeichnis und die Dateinamen in Englisch zu haben, wie KIB PROJECTS ...... Dies ist eine kleine Bitte von mir!
1...515253545556575859606162636465...83
Neuer Kommentar