Galerie der in MQL geschriebenen UIs - Seite 66

[Реter Konow]

12. Programmatische Ermittlung/Einstellung der Wertgrenzen desSchiebereglers und des Feldes mit Schaltflächen (_V_MIN, _V_MAX, _V_STEP, _DIGITS).

1. öffnen wir ein Fenster mit Elementen mit den oben genannten Parametern:

int _OnInit()
  {
   //------------------------------------------------
   //Open the window "Settings example 1".
   //------------------------------------------------
   w_6_Settings_example_1();
   //------------------------------------------------

2. Wir schreiben die Werte von _V_MIN, _V_MAX, _V_STEP, _DIGITS auf und geben sie in das Protokoll ein:

   //------------------------------------------------
   //Get parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP, _DIGITS
   //------------------------------------------------
   int Min_value = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_V_MIN);
   int Max_value = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_V_MAX);
   int Step      = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_V_STEP);
   int digits    = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_DIGITS);
   //------------------------------------------------
   //Print the results:
   //------------------------------------------------
   Print("Min_value:  ",Min_value,"  Max_value:  ",Max_value,"  Step:  ",Step,"  digits:  ",digits);
   //------------------------------------------------

Ergebnis: Die Werte der Eigenschaften der Schiebereglerparameter werden protokolliert.

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

3. Wiederholen wir den Vorgang mit dem Feld mit Schaltflächen. Im Gegensatz zum Schieberegler hat das Feld andere Zahlengrenzen und sein Wertetyp ist doppelt.

   //------------------------------------------------
   //Get parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP, _DIGITS
   //------------------------------------------------
   double _Min_value  =  w6_d_p5_S_EDIT_Spin_the_value(get_d,p5_V_MIN);
   double _Max_value  =  w6_d_p5_S_EDIT_Spin_the_value(get_d,p5_V_MAX);
   double _Step       =  w6_d_p5_S_EDIT_Spin_the_value(get_d,p5_V_STEP);
   double _digits     =  w6_d_p5_S_EDIT_Spin_the_value(get_d,p5_DIGITS);
   //------------------------------------------------
   Print("Min_value:  ",_Min_value,"  Max_value:  ",_Max_value,"  Step:  ",_Step,"  digits:  ",_digits);
   //------------------------------------------------ 

Ergebnis: DieWerte der Parametereigenschaften des Feldes mit Schaltflächen werden im Protokoll angezeigt.

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

4. Setzen Sie andere Grenzen des Schiebereglerbereichs (zum ersten Mal getestet, das Ergebnis ist unbekannt).

   //------------------------------------------------
   //Set parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP.
   //------------------------------------------------
   Min_value = -100;
   Max_value = 100;
   Step      = 1;
   //-----------------
   w6_i_p3_H_SLIDER_Roll_the_value(Min_value, p3_V_MIN);
   w6_i_p3_H_SLIDER_Roll_the_value(Max_value, p3_V_MAX);
   w6_i_p3_H_SLIDER_Roll_the_value(Step,      p3_V_STEP);
   //------------------------------------------------

Ergebnis: *Fand einProblem mit dem Bereich bei negativen Zahlen (wird in der nächsten Version behoben).

Prüfen wir mit positiven Bereichsgrenzen:

   //------------------------------------------------
   //Set parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP.
   //------------------------------------------------
   Min_value = 0;
   Max_value = 1000;
   Step      = 1;
   //-----------------
   w6_i_p3_H_SLIDER_Roll_the_value(Min_value, p3_V_MIN);
   w6_i_p3_H_SLIDER_Roll_the_value(Max_value, p3_V_MAX);
   w6_i_p3_H_SLIDER_Roll_the_value(Step,      p3_V_STEP);
   //------------------------------------------------

Ergebnis: Die Bereichsgrenzen wurden erfolgreich geändert.

Wichtigster Punkt: Der Bereich des Schiebereglers kann über seine Funktion geändert werden.

**Wichtig:Sie können den Wertetyp des Parameters nicht rückwirkend von int auf double oder umgekehrt ändern.

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

Lassen Sie uns ein ähnliches Experiment mit dem Eingabefeld durchführen:

   //------------------------------------------------
   //Set NEW parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP, _DIGITS
   //------------------------------------------------
   double _Min_value  = -100.0;
   double _Max_value  =  100.0;
   double _Step       =  2.5;
   //-----------------
   //Set another default value---
   w6_d_p5_S_EDIT_Spin_the_value(50.5);
   //-----------------
   w6_d_p5_S_EDIT_Spin_the_value(_Min_value,p5_V_MIN);
   w6_d_p5_S_EDIT_Spin_the_value(_Max_value,p5_V_MAX);
   w6_d_p5_S_EDIT_Spin_the_value(_Step     ,p5_V_STEP);
   //------------------------------------------------

Ergebnis: Es funktioniert wie vorgesehen. Das Feld mit den Schaltflächen akzeptiert den angegebenen Bereich und Schritt. Wenn der Bereich überschritten wird, wird ein Fehler im Protokoll gemeldet.

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

5. Schließlich setzen wir den Wert_DIGITS in das Feld mit den Schaltflächen (der Schieberegler funktioniert nicht, da sein Parametertyp int ist):

• Wir setzen den Schrittwert mit vier Ziffern nach dem Punkt.
• Die Variable digits wird auf 4 (vier Dezimalstellen) gesetzt.

   //------------------------------------------------
   //Set parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP, _DIGITS
   //------------------------------------------------
   double _Min_value  = -100.0;
   double _Max_value  =  100.0;
   double _Step       =  2.5567;
          digits      =  4;
   //-----------------
   //Set another default value---
   w6_d_p5_S_EDIT_Spin_the_value(50.5);
   //-----------------
   w6_d_p5_S_EDIT_Spin_the_value(_Min_value,p5_V_MIN);
   w6_d_p5_S_EDIT_Spin_the_value(_Max_value,p5_V_MAX);
   w6_d_p5_S_EDIT_Spin_the_value(_Step     ,p5_V_STEP);
 
   //Set the new number of digits:
   w6_d_p5_S_EDIT_Spin_the_value(digits    ,p5_DIGITS);
   //------------------------------------------------

Ergebnis:

• Zunächst gab es drei Stellen nach dem Komma (die ursprüngliche Zahl vor der Softwareänderung).

• Dann wurde die Genauigkeit durch den Software-Aufruf auf vier Ziffern erhöht:

• Danach auf 7 Stellen:

//Setting 7 digits after the decimal point:

w6_d_p5_S_EDIT_Spin_the_value(7,p5_DIGITS);

Ergebnisse:

• Es ist möglich, die ursprünglichen Zahlenbereichsgrenzen des Schaltflächenfeldes sowie des Schiebereglers programmatisch zurückzusetzen.

• Es ist möglich, die ursprüngliche Genauigkeit des Doppelwerts programmatisch zu ändern, indem eine andere Anzahl von Dezimalstellen eingestellt wird.
  

• Der Schieberegler hat ein Problem mit der Berechnung von Werten innerhalb der Grenzen von negativen Zahlen (wird behoben).

• Der ursprüngliche Typ des Elementparameters kann nicht zurückgesetzt werden.

Damit ist dieses Thema abgeschlossen.

[Реter Konow]

13. Abfrage des Zustands von Elementen _GET_STATE.

Oft gibt es Situationen, in denen es notwendig ist, den Zustand des einen oder anderen Elements der Schnittstelle programmatisch abzufragen. Um dieses Problem zu lösen, wurde der Bezeichner _GET_STATE geschaffen.

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

*Wichtig:Bei der Anfrage_GET_STATE gibt die Funktion den Index des aktuellen Zustands des Elements zurück.

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

Die folgende Abbildung zeigt die Liste der Elementzustände.

1. Zustandsbezeichner :

(*in dernächsten Version wird das Präfix v_ durch das Präfix s_ ersetzt )

Ausgabe der Indizes in das Protokoll:

  v_NEUTRAL_STATE           15
  //-----------------------------
  v_ACTIVATED_STATE         62
  //-----------------------------
  v_NEUTRAL_BLOCKED         64
  //-----------------------------
  v_ACTIVATED_BLOCKED       65   
  //----------------------------- 
  v_NEUTRAL_HIGHLIGHTED     66  
  //-----------------------------
  v_ACTIVATED_HIGHLIGHTED   67

Testen wir das Abfragen und Abrufen von Elementzuständen:

1. das Fenster öffnen und den Anfangszustand der Schaltfläche "Start" abfragen:

int _OnInit()
  {
   //------------------------------------------------
   //Open the window "Settings example 1".
   //------------------------------------------------
   w_6_Settings_example_1();
   //------------------------------------------------
   //Get state of button "Start":
   //------------------------------------------------
   int Button_state = w6_i_p1_BUTTON_Start(get_i,p1_GET_STATE);
   //------------------------------------------------
   //Print out:
   //------------------------------------------------
   Print("Button state:  ",Button_state);
   //------------------------------------------------

Ergebnis: Der Wert 15, der dem Zustand v_NEUTRAL_STATE entspricht, wird ermittelt .

2. Erfassen wir die Zustände der Schaltfläche beim Drücken und Loslassen:

Um dies zu tun:

• Suchen wir die Schaltfläche in der API-Datei.
• Schreiben Sie eine _GET_STATE-Anfrage für beide Fälle - gedrückt und losgelassen.

case Settings_example_1___Start:

               //------------------------------------------------------------------------------------------------------
               //What to do when the button is pressed or released?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                //------------------------------------------------------------------------
                case pressed: 
                               {
                                //Get button's state when it pressed:
                                int Button_state =  w6_i_p1_BUTTON_Start(get_i,p1_GET_STATE);
                                
                                //Print out the result:
                                Print("Button state:  ",Button_state);
                               }
                break;
                //------------------------------------------------------------------------
                case released: 
                               {
                                //Get button's state when it released:
                                int Button_state =  w6_i_p1_BUTTON_Start(get_i,p1_GET_STATE);
                                
                                //Print out the result:
                                Print("Button state:  ",Button_state);
                               }
                break;
                //------------------------------------------------------------------------
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

Ergebnis: Beim Ereignis Drücken/Freigeben wird der aktuelle Zustandsindex in das Protokoll geschrieben.

Zur Erinnerung:

15 = v_NEUTRAL_STATE

62 = v_ACTIVATED_STATE

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

3. Wiederholen wir die Abfrage mit dem Kontrollkästchen.

1. Ermitteln wir den Zustand des Kontrollkästchens beim Öffnen des Fensters:

   //------------------------------------------------
   //Open the window "Settings example 1".
   //------------------------------------------------
   w_6_Settings_example_1();
   //------------------------------------------------
   
   //Get the state of the checkbox when it checked:
   int Checkbox_state = w6_i_p7_CHECKBOX_Set_an_option(get_i,p7_GET_STATE);
   
   //Print out the result:
   Print("Checkbox state:  ",Checkbox_state);
   //------------------------------------------------

Ergebnis: Man erhält den Wert 15, der dem neutralen Zustand v_NEUTRAL_STATE entspricht (in dem sich das Kontrollkästchen befindet).

2. Als nächstes werden die Zustände des Kontrollkästchens beim Drücken und Loslassen abgefragt.

Um dies zu tun:

• Suchen wir in der API-Datei das Kontrollkästchen"Eine Option einstellen".
• Schreiben wir die Abfrage _GET_STATE für beide Fälle - markiert und nicht markiert.

case Settings_example_1___Set_an_option:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the checkbox is checked or unchecked? 
               //------------------------------------------------------------------------------------------------------
                case checked: 
                               {
                                //Get checkbox state when it checked:
                                int Checkbox_state = w6_i_p7_CHECKBOX_Set_an_option(get_i,p7_GET_STATE);
                                
                                //Print out the result:
                                Print("Checkbox state:  ",Checkbox_state);
                               }
                break;
                //------------------------------------------------------------------------
                case unchecked: 
                               {
                                //Get checkbox state when it unchecked:
                                int Checkbox_state = w6_i_p7_CHECKBOX_Set_an_option(get_i,p7_GET_STATE);
                                
                                //Print out the result:
                                Print("Checkbox state:  ",Checkbox_state);
                               }
                break;
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

Ergebnis: Wir erhalten die Werte 66 (v_NEUTRAL_HIGHLIGHTED) und 67 (v_ACTIVATED_HIGHLIGHTED), also den hervorgehobenen neutralen und den hervorgehobenen gedrückten Zustand.

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

Damit ist der erste Teil des Themas abgeschlossen.

Im zweiten Teil werden wir die Zustände der Dropdown-Liste D_LIST, des Schiebereglers H_SLIDER und der Eingabefelder S_EDIT und EDIT zurückgeben.

[[Gelöscht]]

Ich begann, eine Kryptowährungsbörse namens coinsbitfx.com zu nutzen. Coins Bit FX behauptete, bei der National Futures Association registriert zu sein, um die Nutzer von seiner Legitimität zu überzeugen. Irgendwann glaubte ich, dass der Wert meines Kontos auf 135.134 $ gestiegen war. Als ich jedoch versuchte, Geld von meinem Konto abzuheben, teilte mir die Börse mit, dass die Transaktion "in Prüfung" sei. Der Bewohner konnte seitdem niemanden mehr auf der Website erreichen und hat keinen Zugriff auf die angelegten Gelder. Ich las in einem Blog über RECOVERYCOINGROUP AT GMAIL DOT COM, recherchierte und beschloss, ihre Dienste in Anspruch zu nehmen. In weniger als 72 Stunden waren meine Gelder wieder da, und als ob das nicht genug wäre, wurden auch die BTC meiner Freunde wiederhergestellt. Also bin ich mutig genug, um die Welt über diese Jungs wissen zu lassen. Fühlen Sie sich frei, die Recovery Coin Group heute zu kontaktieren und danken Sie mir später !

[Реter Konow]

13. Statusabfrage _GET_STATE.

Teil 2: Abrufen der Zustände der Elemente D_LIST, H_SLIDER, EDIT, S_EDIT.

Im letzten Teil haben wir uns angesehen, wie man programmatisch die Zustände der BUTTON-Schaltfläche und des CHECKBOX-Kontrollkästchens abfragt. Die Abfrage _GET_STATE wurde verwendet, und die Liste der von den Funktionen zurückgegebenen Zustandsnamen wurde angezeigt. Es gibt insgesamt sechs Namen, von denen jeder mit dem Präfix v_ beginnt. (Eine Abkürzung für value, die durch s_ - eine Abkürzung für state - ersetzt wird ).

Erinnern Sie sich an die Zustandsindizes:

  v_NEUTRAL_STATE           15
  //-----------------------------
  v_ACTIVATED_STATE         62
  //-----------------------------
  v_NEUTRAL_BLOCKED         64
  //-----------------------------
  v_ACTIVATED_BLOCKED       65   
  //----------------------------- 
  v_NEUTRAL_HIGHLIGHTED     66  
  //-----------------------------
  v_ACTIVATED_HIGHLIGHTED   67

In diesem Fall sind die spezifischen Indexnummern nicht wichtig. Wenn der Benutzer einen bestimmten Zustand in eine Bedingung aufnehmen muss, verwendet er einen Bezeichner.

Beispiel 1:

//Getting state of the first element:
int Button_state = w6_i_p1_BUTTON_Start(get_i,p1_GET_STATE);

//Getting state of the second element:
int Checkbox_state = w6_i_p7_CHECKBOX_Set_an_option(get_i,p7_GET_STATE);


//Setting conditions for both elements when they're simultaneously ON:
if(Button_state == v_ACTIVATED_STATE)
  { 
   //Is the checkbox was already on:
    if(Checkbox_state == v_ACTIVATED_STATE)
      {
       Function_1();
      }
    //If the checkbox was the last pressed element and still highlighted:
    if(Checkbox_state == v_ACTIVATED_HIGHLIGHTED)
      {
       Function_2();
      }
  }

Beispiel 2:

//Getting state of the first element:
int Button_state = w6_i_p1_BUTTON_Start(get_i,p1_GET_STATE);

//Getting state of the second element:
int Checkbox_state = w6_i_p7_CHECKBOX_Set_an_option(get_i,p7_GET_STATE);


//Setting conditions for one element being ON, while the other is OFF:
if(Button_state == v_ACTIVATED_STATE)
  { 
   //If the checkbox was already off:
    if(Checkbox_state == v_NEUTRAL_STATE)
      {
       Function_A();
      }
    //If the checkbox was just turned off and still highlighted:
    if(Checkbox_state == v_NEUTRAL_HIGHLIGHTED)
      {
       Function_B();
      }
  }

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

*Sehr wichtig:

Lassen Sie mich den wesentlichen Unterschied zwischen den Zuständen v_NEUTRAL_STATE und v_NEUTRAL_HIGHLIGHTED sowie zwischen v_ACTIVATED_STATE und v_ACTIVATED_HIGHLIGHTED erklären:

v_NEUTRAL_STATE - это нейтральное состояние в котором элемент находится неопределенное время.

v_NEUTRAL_HIGHLIGHTED - это нейтральное состояние в которое элемент перешел ТОЛЬКО ЧТО, после отжатия пользователя. Поэтому элемент подсвечен - HIGHLIGHTED. 

gilt das Gleiche für den aktivierten Zustand:

v_ACTIVATED_STATE - это активированное состояние в котором элемент находится неопределенное время.

v_ACTIVATED_HIGHLIGHTED - это активированное состояние в которое элемент перешел ТОЛЬКО ЧТО, после нажатия пользователя. Поэтому элемент подсвечен - HIGHLIGHTED. 

Dieser Unterschied macht einen großen Unterschied.

Derzeit geben die Schaltfläche und einige andere Elemente nur v_NEUTRAL_STATE und v_ACTIVATED_STATE zurück, nicht aber HIGHLIGHTED-Zustände wie z.B. ein Kontrollkästchen. Das bedeutet, dass der Benutzer keine Möglichkeit hat, zu wissen, ob Elemente gerade angeklickt oder nicht angeklickt wurden, oder wann, vor einer unbestimmten Zeit. Der Benutzer kann jedoch den Moment, in dem sie gedrückt wurden, in der API-Datei erfassen. Ja, aber diese Funktion ist im restlichen Programm noch nicht verfügbar. In der nächsten Version werden alle interaktiven Elemente mit der HIGHLIGHTED-Statusanzeige ausgestattet. Auf diese Weise kann der Benutzer von jeder Stelle des Programms aus erkennen, ob ein Element gerade gedrückt oder nicht gedrückt wurde, oder ob es sich schon lange in diesem Zustand befindet.

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

Kommen wir nun zum praktischen Teil:

• Wir öffnen zwei Fenster mit den Elementen D_LIST, H_SLIDER, EDIT und S_EDIT.
• Geben wir die Zustände der Elemente unmittelbar nach dem Öffnen zurück.

1. öffnen Sie die Fenster:

int _OnInit()
  {
   //------------------------------------------------
   //Open the windows "Settings example 1" and "Settings example 2".
   //------------------------------------------------
   w_6_Settings_example_1();
   w_7_Settings_example_2();
   //------------------------------------------------

2. Holen wir uns die Zustände der Elemente:

   //------------------------------------------------
   //Get the states of the elements S_EDIT, H_SLIDER, EDIT and D_LIST
   //------------------------------------------------
   //1. State index is type int, S_EDIT's function is double. Convert the types.
   int S_edit_state   = (int)w6_d_p5_S_EDIT_Spin_the_value(get_d,p5_GET_STATE); 
   
   //2. Getting the slider's state. 
   int H_slider_state =      w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_GET_STATE);
   
   //3.State index is type int, EDIT's function is string. Convert the types. 
   int Edit_state     = (int)w7_s_p4_EDIT_Comment_3(get_s,p4_GET_STATE);
   
   //State index is type int, D_LIST's function is string. Convert the types.
   int D_list_state   = (int)w7_s_p6_D_LIST_D_LIST_1(get_s,p6_GET_STATE);
   //------------------------------------------------
   
   //Print out the results:
   Print("S_edit_state   = ",S_edit_state);
   Print("H_slider_state = ",H_slider_state);
   Print("Edit_state     = ",Edit_state);
   Print("D_list_state   = ",D_list_state);
   //------------------------------------------------

Ergebnis: Alle Elemente des D_LIST-Knotenshaben den Zustandsindex 15 (neutraler Zustand v_NEUTRAL_STATE). D_LIST hat einen Fehler zurückgegeben (-1).

Grund: Die Rückgabe von Zuständen dieses Elements ist in der zentralen Funktion nicht spezifiziert. Technischer Fehler.Er wird in der nächsten Version behoben.

Da die Funktion D_LIST den Zustandsindex noch nicht zurückgibt, wollen wir uns auf drei Elemente konzentrieren, deren Zustände erfolgreich empfangen wurden: EDIT , S_EDIT und H_SLIDER.

Was zu prüfen ist:

• Welche Indizes die Funktion zurückgibt, wenn die Elemente gesperrt sind und angeklickt werden.
• Ob die angegebenen Elemente einenHIGHLIGHTED ( hervor gehobenen) Zustand haben. Mit anderen Worten, ob es möglich ist zu wissen, ob das Element gerade angeklickt wurde oder nicht.

Wir haben soeben überprüft, dass die Elementfunktionen EDIT, S_EDIT und H_SLIDER beim Öffnen des Fensters einen Index des neutralen Zustands zurückgeben. Es bleibt noch, die anderen Zustände zu überprüfen. Da diese Arten von Elementen theoretisch nur die Zustände neutral, gesperrt und hervorgehoben annehmen können (im Gegensatz zu Schaltflächen und Kontrollkästchen, die mehr Zustände annehmen können), müssen wir die folgenden zwei möglichen Zustände prüfen: gesperrt und hervorgehoben. Es gibt auch eine Gruppe von Zuständen"unter dem Cursor", die ich noch nicht hinzufügen möchte, um Verwirrung zu vermeiden. In den nächsten Versionen werde ich ein spezielles Präfix erstellen, das eine individuelle Liste der möglichen Zustände für jeden Elementtyp öffnet. Dies wird die programmatische Arbeit erleichtern.

Wie werden wir die Rückkehr der blockierten und hervorgehobenen ZuständeEDIT, S_EDIT und H_SLIDER überprüfen:

• Suchen wir in der API-Datei das Kontrollkästchen "Eine Option setzen".

• Wir schreiben die Sperrung/Entsperrung der Elemente EDIT, S_EDIT und H_SLIDER in ihr Gehäuse und drucken() die Zustände der Elemente dort aus.

• Suchen wir die Elemente EDIT, S_EDIT und H_SLIDER in der API-Datei.

• Schreiben Sie eine Zustandsrückgabe für den Fall, dass ein Wert in diese Elemente eingegeben wird.

• Drucken wir das Ergebnis über Print() aus.

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

1. Suchen Sie das Kontrollkästchen "Setze eine Option" in der API-Datei und schreiben Sie die Sperrung/Entsperrung der ElementeEDIT, S_EDIT und H_SLIDER in dessen Gehäuse.Geben Sie dann die Zustände über Print() aus.

case Settings_example_1___Set_an_option:
  
            switch((int)action)
               {
               //------------------------------------------------------------------------------------------------------
               //What to do when the checkbox is checked or unchecked? 
               //------------------------------------------------------------------------------------------------------
                case checked: 
                               {
                                //-----------------------------------------------
                                //Locking EDIT:
                                w7_s_p4_EDIT_Comment_1(p4_LOCK);
                                
                                //Locking H_SLIDER:
                                w6_i_p3_H_SLIDER_Roll_the_value(p3_LOCK);
                                
                                //Locking S_EDIT:
                                w6_d_p5_S_EDIT_Spin_the_value(p5_LOCK); 
                                
                                //-----------------------------------------------
                                //Getting state of EDIT:
                                int EDIT_state =  (int)w7_s_p4_EDIT_Comment_1(get_s, p4_GET_STATE);

                                //Getting state of H_SLIDER:
                                int H_SLIDER_state = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_GET_STATE); 

                                //Getting state of S_EDIT:
                                int S_EDIT_state = (int)w6_d_p5_S_EDIT_Spin_the_value(get_d, p5_GET_STATE); 
                                //-----------------------------------------------
                                
                                //Printing results:
                                Print("EDIT_state      = ",EDIT_state);
                                Print("H_SLIDER_state  = ",H_SLIDER_state);
                                Print("S_EDIT_state    = ",S_EDIT_state);
                                //-----------------------------------------------
                               }
                break;
                //------------------------------------------------------------------------
                case unchecked: 
                               {
                                //-----------------------------------------------
                                //Unlocking the element EDIT:
                                w7_s_p4_EDIT_Comment_1(p4_UNLOCK);
                                
                                //Unlocking H_SLIDER:
                                w6_i_p3_H_SLIDER_Roll_the_value(p3_UNLOCK);
                                
                                //Unlocking S_EDIT:
                                w6_d_p5_S_EDIT_Spin_the_value(p5_UNLOCK);
                                
                                //-----------------------------------------------
                                //Getting state of EDIT:
                                int EDIT_state =  (int)w7_s_p4_EDIT_Comment_1(get_s, p4_GET_STATE);

                                //Getting state of H_SLIDER:
                                int H_SLIDER_state = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_GET_STATE); 

                                //Getting state of S_EDIT:
                                int S_EDIT_state = (int)w6_d_p5_S_EDIT_Spin_the_value(get_d, p5_GET_STATE); 
                                //-----------------------------------------------
                                
                                //Printing results:
                                Print("EDIT_state      = ",EDIT_state);
                                Print("H_SLIDER_state  = ",H_SLIDER_state);
                                Print("S_EDIT_state    = ",S_EDIT_state);
                                //-----------------------------------------------
                               }
                break;
               } 
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

Ergebnis:

• Beim Anklicken der Checkbox geben die Elementfunktionen den Index 64 zurück, was dem Zustand v_NEUTRAL_BLOCKED (neutral-locked) entspricht.
• Wird das Häkchen entfernt, geben die Elementfunktionen den Index 15 zurück, was dem Zustand v_NEUTRAL_STATE (neutraler Zustand) entspricht.

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

[Реter Konow]

2. Zweite Aufgabe:

• Finden Sie die ElementeEDIT, S_EDIT, H_SLIDER in der API-Datei und schreiben Sie vor, den Status zu erhalten, wenn ein Wert eingegeben wird, um zu sehen, ob ihre Funktionen einen HIGHLIGHTED ( hervorgehobenen) Index zurückgeben.

Erste Schritte:

case Settings_example_2___Comment_1:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the text is entered?
               //------------------------------------------------------------------------------------------------------
               {
                //Getting state of EDIT:
                int EDIT_state =  (int)w7_s_p4_EDIT_Comment_1(get_s, p4_GET_STATE);
                                
                //Printing the results:
                Print("EDIT_state      = ",EDIT_state);
               } 
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

case Settings_example_1___Roll_the_value:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the slider's handle is moved?
               //------------------------------------------------------------------------------------------------------
               //Min value:  0  |   Max value:  100  |   V_step:  1  |   Default value:  75  |  Digits: Integer value
               //------------------------------------------------------------------------------------------------------
               {
                //Getting state of H_SLIDER:
                int H_SLIDER_state = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_GET_STATE); 
                                
                //Printing results:
                Print("H_SLIDER_state  = ",H_SLIDER_state);
               }           
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

case Settings_example_1___Spin_the_value:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the value is set?
               //------------------------------------------------------------------------------------------------------
               //Min value:  NOT SET  |   Max value:  NOT SET  |   V_step:  1.7  |   Default value:  468.99  |  Digits: 3
               //------------------------------------------------------------------------------------------------------
               {
                //Getting state of S_EDIT:
                int S_EDIT_state = (int)w6_d_p5_S_EDIT_Spin_the_value(get_d, p5_GET_STATE); 
                                
                //Printing results:
                Print("S_EDIT_state    = ",S_EDIT_state); 
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

Ergebnis:

• EDIT: Gibt bei einem Benutzerinteraktionsereignis einen Statusindex von 67 zurück, wasv_ACTIVATED_HIGHLIGHTED ( aktiviert, hervorgehoben) bedeutet.

• S_EDIT: Gibt bei einem Benutzerinteraktionsereignis einen Statusindex von 67 zurück, wasv_ACTIVATED_HIGHLIGHTED ( aktiviert, hervorgehoben) bedeutet.

• H_SLIDER: Gibt bei einem Benutzerinteraktionsereignis abwechselnd die Indizes 66 und 67 zurück, wasv_NEUTRAL_HIGHLIGHTED ( neutral, beleuchtet) undv_ACTIVATED_HIGHLIGHTED (aktiviert, beleuchtet) bedeutet.Fehler. Behebung in der nächsten Version.

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

Ergebnisse:

Im Allgemeinen können die Ergebnisse als zufriedenstellend bewertet werden. Die Elemente geben die Indizes der neutralen und gesperrten Zustände wie vorgesehen zurück. Allerdings gibt es einige Unzulänglichkeiten:

• Die Elementfunktion D_LIST gibt keine Zustände zurück.

• Die Elementfunktion H_SLIDER liefert abwechselnd Indizes der Zuständev_NEUTRAL_HIGHLIGHTED undv_ACTIVATED_HIGHLIGHTED anstelle eines Index 67 - v_ACTIVATED_HIGHLIGHTED(aktiviert, beleuchtet).

Schlussfolgerungen:

• Die Unzulänglichkeiten müssen behoben werden.
• Es ist notwendig, eine Liste von Intellisense zu erstellen, die durch ein spezielles Präfixs_ aufgerufen wird, damit der Benutzer weiß, welche Arten von Elementen welche Zustände haben und sie leicht im Code verwenden kann.

Potenziell ist es möglich, neue Elementzustände hinzuzufügen. Zum Beispiel "Neutral pointed" und "Activated pointed" ( neutral unter dem Cursor und aktiviert unter dem Cursor), aber es ist eine Frage der Praktikabilität und des tatsächlichen Bedarfs des Benutzers, diese Funktionen zu haben. Solange diese Anforderungen nicht erfüllt sind, werde ich keine neuen Zustände hinzufügen.

Das ist das Ende dieses Themas.

Weiter, zu den folgenden Themen.

[hini]

Ich habe die letzte Woche damit verbracht, zu recherchieren, wie man eine Schnittstelle mit WinForm schreibt und sie in MT5-Charts einbettet. Heute habe ich es endlich realisiert.

[hini]

Das Hochladen eines Videos ist einfacher als das Hochladen eines Gifs und die Datei ist kleiner.

[Реter Konow]

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. das Öffnen einer Liste von programmatisch verfügbaren Fensterelementen.

4. das Öffnen einer Liste mit den Eigenschaften einzelner Elemente.

5. Parsen des Namens der Element- und Fenster-Wrapper-Funktion.

6. die Rückgabe des Wertes eines Elementparameters an eine Variable seines Typs.

7. Setzen von Werten für Elementparameter verschiedener Typen.

8. Rückgabe, Änderung und Weitergabe von Werten zwischen Parametern verschiedener Elemente. Betrachtung verschiedener Typen von Elementen und Werten und Test der Weiterleitung zwischen verschiedenen Typen 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. Test zum Setzen der Zustände ON, OFF, LOCK_ON, LOCK_OFF, LOCK, UNLOCK für verschiedene Elementtypen.

11. Test der Bindung und Synchronisation von sich ändernden Werten von Elementen: z.B. Eingabefeld mit Schaltflächen und Schieberegler. So dass, wenn sich der Wert eines Elements (manuell oder softwaremäßig) ändert, sich der Wert im zweiten Element entsprechend ändert.

12. das Testen des Erhalts/Einstellens der Bereichsgrenzen des Schiebereglers und des Feldes mit Schaltflächen durch die Software (Eigenschaften _V_MIN, _V_MAX, _V_STEP, _DIGITS).

13. Testen der Funktionsweise der Abfrage des Elementstatus (_GET_STATE).

14. Verknüpfung von Text- und Rahmenfarben mit Wertabständen.

15. Orientierung in der API-Datei.

16. dieImplementierung einer einfachen Programmlogik für die Darstellung von Nachrichten- und Warnfenstern.

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

Die berücksichtigten Themen sind gelb hervorgehoben.

Zum jetzigen Zeitpunkt gibt es noch einige, die berücksichtigt werden müssen:

14. Verknüpfung von Text- und Rahmenfarben mit Werteabständen.

15. Orientierung in der API-Datei.

16. dieImplementierung einer einfachen Programmlogik für die Darstellung von Meldungs- und Warnfenstern.

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

Ich schlage vor, Thema 14 mit Thema 16 zu verknüpfen. Die Überschreitung der festgelegten Parameterwerte führt zunächst zu Signalen in Form einer Farbänderung von Teilen der Elemente (Text, Basis, Rahmen, Streifen usw.), dann zum Öffnen eines Dialogfensters und schließlich eines Warnfensters. Gleichzeitig blockiert das Warnfenster die Änderung der Werte in den Elementen, bis es vom Benutzer manuell geschlossen wird.

Außerdem würde ich gerne ein Thema in die Liste aufnehmen:

17. das Abbrechen eingegebener Einstellungen, wenn der Benutzer auf die Schaltfläche "Abbrechen" klickt.

Vor langer Zeit wurde die Technik des Abbrechens von Benutzereinstellungen durch Anklicken der Schaltfläche "Abbrechen" entwickelt und in gewissem Umfang getestet. Im Moment ist nicht bekannt, inwieweit die frühere Funktionalität funktioniert. Daher ist ein Test erforderlich.

Aufgrund der Überschneidung der Themen wird die Reihenfolge der Überprüfung wie folgt sein:

14. Implementierung eines gestaffelten Schutzes der Parametergrenzen:

• Schreiben einer Logik zur Kontrolle von Einstellungen innerhalb vorgegebener Grenzen und Erstellen eines Warnsystems.

• Warnung 1: Der Benutzer erhält ein Signal in Form einer Änderung der Farbe von Teilen der Elemente.( Verknüpfen wir die Farbe von Text, Sockel, Rahmen und Schieberegler mit den Wertgrenzen).

• Warnung 2: Es öffnet sich ein Dialogfeld mit einem Risikohinweis und einem Vorschlag, zu den ursprünglichen Einstellungen zurückzukehren. ( Testen Sie, ob Sie tatsächlich zu den vorherigen Einstellungen zurückkehren können, wenn Sie auf die Schaltfläche "Abbrechen" klicken. )

• Warnung 3: Es öffnet sich ein Warnfenster, das weitere Änderungen an den Einstellungen blockiert und den Benutzer auf den Haftungsausschluss hinweist, der eine manuelle Bestätigung durch den Benutzer erfordert. ( Testen wir die Sperrung von Fenstern, wenn das Warnfenster erscheint. )

15. Betrachten wir nun den Ausdruck der neuen API-Datei im Detail.

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

Als nächstes werde ich alle gefundenen Fehler oder Mängel sammeln und eine Liste mit Aufgaben für die nächste Version erstellen.

Nach der nächsten Version mit Korrekturen und Ergänzungen werde ich mich auf die Tabellen konzentrieren, in denen ich eine der Hauptrichtungen der weiteren Entwicklung der Engine sehe.

[Реter Konow]

hini #:

Ich habe die letzte Woche damit verbracht, zu lernen, wie man eine Schnittstelle mit WinForm schreibt und sie in MT5-Charts einbaut. Heute habe ich endlich herausgefunden, wie man es macht.

Und wie werden Sie die Schnittstelle mit Ihrem Programmiercode kommunizieren lassen?

[Реter Konow]

Реter Konow #:

Und wie stellen Sie eine Verbindung zwischen der Schnittstelle und Ihrem Programmiercode her?

Noch ein paar Fragen:

• Wie viele Formulare (Fenster) können Sie in MT5-Charts "einbauen"?
• Wie werden Sie Daten in Tabellen übersetzen?
• Können Sie bei der Erstellung von Fenstern vorgefertigte Vorlagen verwenden?
• Können Sie Ihre eigene Taskleiste und Ihr eigenes Kontextmenü in MT5 erstellen?
• Wie implementieren Sie Software-Rückgabe-/Setzeigenschaften von Elementen? Durch Abfrage der DLL von der Timer-Funktion aus?

Erzählen Sie mir mehr über die Lösung, die Sie gefunden haben. Das ist sehr interessant. :)