Galería de interfaces de usuario escritas en MQL - página 66

[Реter Konow]

Continuemos con una nueva página.

[Реter Konow]

12. Obtención/configuración programática de los límites de valor del deslizador y del campo con botones (_V_MIN, _V_MAX, _V_STEP, _DIGITS).

1. Abramos una ventana con elementos con los parámetros anteriores:

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

2. 2. Escribamos los valores de _V_MIN, _V_MAX, _V_STEP, _DIGITS y enviémoslos al log:

   //------------------------------------------------
   //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);
   //------------------------------------------------

Resultado: se registran los valores de las propiedades de los parámetros del deslizador.

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

3. Repitamos la operación con el campo con botones. A diferencia del deslizador, el campo tiene otros límites numéricos y su tipo de valor es doble.

   //------------------------------------------------
   //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);
   //------------------------------------------------ 

Resultado: losvalores de las propiedades de los parámetros del campo con botones se muestran en el registro.

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

4. Establecer otros límites del rango del deslizador (probado por primera vez, el resultado es desconocido).

   //------------------------------------------------
   //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);
   //------------------------------------------------

Resultado: *se ha encontrado unproblema con el rango en números negativos (arreglo en la próxima versión).

Comprobemos con limites de rango positivos:

   //------------------------------------------------
   //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);
   //------------------------------------------------

Resultado: límites de rango cambiados con éxito.

Punto principal: El rango del deslizador puede ser cambiado usando su función.

**Importante:No se puede cambiar retroactivamente el tipo de valor del parámetro de int a double o viceversa.

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

Hagamos un experimento similar con el campo de entrada:

   //------------------------------------------------
   //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);
   //------------------------------------------------

Resultado: Funciona según lo previsto. El campo con botones acepta el rango y el paso especificados. Si se sobrepasa el rango, informa de un error en el log.

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

5. Por último, vamos a establecer el valor_DIGITOS al campo con botones (el deslizador no funcionará porque su tipo de parámetro es int):

• Pongamos el valor del paso con cuatro dígitos después del punto.
• La variable dígitos se establece en 4 (cuatro decimales).

   //------------------------------------------------
   //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);
   //------------------------------------------------

Resultado:

• Al principio, había tres dígitos después del punto decimal (el número original antes del cambio de software).

• Después, la llamada de software aumentó la precisión a cuatro dígitos:

• A continuación, a 7 dígitos:

//Setting 7 digits after the decimal point:

w6_d_p5_S_EDIT_Spin_the_value(7,p5_DIGITS);

Resultado:

• Es posible restablecer mediante programación los límites del intervalo numérico original del campo de botón, así como del control deslizante.

• Es posible cambiar programáticamente la precisión inicial del valor doble estableciendo un número diferente de decimales.
  

• El deslizador tiene un problema con el cálculo de valores dentro de los límites de números negativos (se solucionará).

• No se puede restablecer el tipo original del parámetro elemento.

Con esto concluye este tema.

[Реter Konow]

13. Consulta del estado de los elementos _GET_STATE.

A menudo se dan situaciones en las que es necesario obtener mediante programación el estado de uno u otro elemento de la interfaz. Para resolver este problema se crea el identificador _GET_STATE.

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

*Importante:En la petición_GET_STATE, la función devuelve el índice del estado actual del elemento.

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

La siguiente imagen muestra la lista de estados del elemento.

1. identificadores de estado :

(*en lapróxima versión, el prefijo v_ será sustituido por el prefijo s_)

2. Salida de índices al registro:

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

Vamos a probar la consulta y recuperación de los estados de los elementos:

1. Abrir la ventana y obtener el estado inicial del botón "Inicio":

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);
   //------------------------------------------------

Resultado: se obtiene el valor 15 correspondiente al estado v_ESTADO_NEUTRAL.

2. Vamos a registrar los estados del botón al pulsarlo y al soltarlo:

Para ello

• Busquemos el botón en el fichero API.
• Escribe una petición _GET_STATE para ambos casos - pulsado y liberado.

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;

Resultado: en el evento pulsado/liberado, el índice de estado actual se imprime en el registro.

Recordatorio:

15 = v_NEUTRAL_STATE

62 = v_ACTIVATED_STATE

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

3. Repitamos la consulta con la casilla de verificación.

1. Obtengamos el estado de la casilla de verificación en el evento de apertura de la ventana:

   //------------------------------------------------
   //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);
   //------------------------------------------------

Resultado: se obtiene el valor 15, correspondiente al estado neutro v_NEUTRAL_STATE (donde está la casilla de verificación).

2. A continuación, vamos a consultar los estados del checkbox en el evento de pulsar y soltar.

Para ello:

• Busquemos la casilla de verificación"Establecer una opción" en el archivo API.
• Escribamos la consulta _GET_STATE para ambos casos - marcada y desmarcada.

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;

Resultado: obtenemos los valores 66 (v_NEUTRAL_HIGHLIGHTED) y 67 (v_ACTIVATED_HIGHLIGHTED), que significan estado resaltado neutral y resaltado pulsado.

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

Con esto concluye la primera parte del tema.

En la segunda parte, devolveremos los estados de la lista desplegable D_LIST, el deslizador H_SLIDER y los campos de entrada S_EDIT y EDIT.

[Реter Konow]

13. Petición de estado _GET_STATE.

Parte 2: Obtención de los estados de los elementos D_LIST, H_SLIDER, EDIT, S_EDIT.

En la última parte, vimos cómo devolver mediante programación los estados del botón BUTTON y de la casilla de verificación CHECKBOX . Se utilizó la consulta _GET_STATE y se mostró la lista de nombres de estados devueltos por las funciones. Hay seis nombres en total, donde cada uno comienza con el prefijo v_. (abreviatura de value, que se sustituirá por s_, abreviatura de state).

Recordemos los índices de estado:

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

En este caso, los números de índice específicos no son importantes. Cuando el usuario necesita poner un estado concreto en una condición, utiliza un identificador.

Ejemplo 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();
      }
  }

Ejemplo 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();
      }
  }

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

*Muy importante:

Permítanme explicar la diferencia esencial entre los estados v_NEUTRAL_STATE y v_NEUTRAL_HIGHLIGHTED, y entre v_ACTIVATED_STATE y v_ACTIVATED_HIGHLIGHTED:

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

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

lo mismo se aplica al estado activado:

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

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

Esta diferencia marca una gran diferencia.

Actualmente, el botón y algunos otros elementos, sólo devuelven v_NEUTRAL_STATE y v_ACTIVATED_STATE, y no devuelven estados HIGHLIGHTED como una casilla de verificación. Esto significa que el usuario no tiene forma de saber si los elementos fueron pulsados/desactivados justo ahora, o cuándo, hace un tiempo indefinido. Sin embargo, el usuario puede captar el momento en que se pulsaron en el archivo API. Sí, pero esta función aún no está disponible en el resto del programa. En la próxima versión, se añadirá el retorno de estado DESTACADO a todos los elementos interactivos. De esta forma, desde cualquier parte del programa, el usuario podrá saber si un elemento acaba de ser pulsado/desc pulsado, o si lleva mucho tiempo en su estado.

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

Pasemos a la parte práctica:

• Abramos dos ventanas con los elementos D_LIST, H_SLIDER, EDIT y S_EDIT.
• Devolvamos los estados de los elementos inmediatamente después de abrirlas.

1. Abrir las ventanas:

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

2. Obtengamos los estados de los elementos:

   //------------------------------------------------
   //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);
   //------------------------------------------------

Resultado: todos los elementos del cnomo D_LISTtienen el índice de estado 15 (estado neutro v_NEUTRAL_STATE). D_LIST devuelve un error (-1).

Motivo: la devolución de estados de este elemento no está especificada en la función central. Defecto técnico.Se corregirá en la próxima versión.

Dado que la función D_LIST aún no devuelve el índice de estados, centrémonos en tres elementos cuyos estados se han recibido correctamente: EDIT , S_EDIT y H_SLIDER.

Qué hay que comprobar:

• Qué índices devuelve la función cuando se bloquean los elementos y se hace clic en ellos.
• Si los elementos dados tienen un estadoHIGHLIGHTED ( resaltado). Es decir, si es posible saber si el elemento acaba de ser pulsado o no.

Acabamos de comprobar que las funciones de los elementos EDIT, S_EDIT y H_SLIDER devuelven un índice del estado neutro cuando se abre la ventana. Queda por comprobar los demás estados. Como este tipo de elementos, en teoría, sólo pueden estar en estado neutro, bloqueado y resaltado(a diferencia de los botones y las casillas de verificación, que tienen más estados), tenemos que comprobar los dos estados posibles siguientes: bloqueado y resaltado. También hay un grupo de estados"bajo cursor", que no quiero añadir todavía para evitar confusiones. En las próximas versiones crearé un prefijo especial que abra una lista individual de posibles estados de cada tipo de elemento. Esto facilitará el trabajo programático.

Como comprobaremos el retorno de los estados bloqueados y resaltadosEDIT, S_EDIT y H_SLIDER:

• Busquemos la casilla "Establecer una opción" en el archivo API.

• Escribamos el bloqueo/desbloqueo de los elementos EDIT, S_EDIT y H_SLIDER dentro de su caja e imprimamos() los estados de los elementos allí.

• Busquemos los elementos EDIT, S_EDIT y H_SLIDER en el fichero API.

• Escribamos un retorno de estado en el evento de introducir un valor en estos elementos.

• Imprimamos el resultado obtenido mediante Print().

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

1. Encuentre la casilla "Establecer una opción" en el fichero API y escriba el bloqueo/desbloqueo de los elementosEDIT, S_EDIT y H_SLIDER dentro de su caja.A continuación, imprima los estados mediante Print().

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;

Resultado:

• Cuando se hace clic en la casilla de verificación, las funciones del elemento devuelven el índice 64, que corresponde al estado v_NEUTRAL_BLOCKED (neutral-bloqueado).
• En el evento de desmarcar la casilla de verificación, las funciones de elemento devuelven un índice de 15, que corresponde al estado v_NEUTRAL_STATE (estado neutral).

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

[Реter Konow]

2. Segunda tarea:

• Encontrar los elementosEDIT, S_EDIT, H_SLIDER en el fichero API y prescribir la obtención del estado cuando se introduce un valor para ver si sus funciones devuelven el índice HIGHLIGHTED ( resaltado).

Puesta en marcha:

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;

Resultado:

• EDIT: En un evento de interacción del usuario, devuelve un índice de estado de 67, lo que significav_ACTIVATED_HIGHLIGHTED ( activado, resaltado).

• S_EDIT: En un evento de interacción de usuario, devuelve un índice de estado de 67, lo que significav_ACTIVATED_HIGHLIGHTED ( activado, resaltado).

• H_SLIDER: En evento de interacción con el usuario, devuelve alternativamente los índices 66 y 67, que significanv_NEUTRAL_HIGHLIGHTED ( neutral, iluminado) yv_ACTIVATED_HIGHLIGHTED (activado, iluminado).Bug. Corrección en la próxima versión.

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

Resultados:

En general, los resultados pueden valorarse como satisfactorios. Los elementos devuelven los índices de los estados neutro y bloqueado como se pretendía. Sin embargo, hay algunas deficiencias:

• La función del elemento D_LIST no devuelve ningún estado.

• La función del elemento H_SLIDER devuelve alternativamente índices de los estadosv_NEUTRAL_HIGHLIGHTED y v_ACTIVATED_HIGHLIGHTED en lugar de un índice 67 - v_ACTIVATED_HIGHLIGHTED(activado, iluminado).

Conclusiones:

• Necesidad de corregir las deficiencias.
• Es necesario crear una lista de intellisense llamada por un prefijo especials_ para que el usuario pueda saber qué tipos de elementos tienen qué estados y utilizarlos fácilmente en el código.

Potencialmente, es posible añadir nuevos estados de elementos. Por ejemplo, Neutro apuntado y Activado apuntado ( neutro bajo el cursor y activado bajo el cursor), pero hay una cuestión de practicidad y de la necesidad real del usuario de disponer de estas características. Hasta que no se reciban tales requerimientos, no añadiré nuevos estados.

Este es el final de este tema.

Más adelante, a los siguientes temas.

[hini]

He pasado la última semana investigando cómo escribir una interfaz usando WinForm e incrustarla en los gráficos de MT5. Hoy por fin lo he conseguido.

[hini]

Subir un vídeo es más fácil que subir un gif y el archivo es más pequeño.

[Реter Konow]

Una lista general de temas a tener en cuenta:

1. Orientación en la lista de intellisense y la selección de la función de la ventana de la derecha.

2. 2. Abrir y cerrar ventanas mediante programación.

3. Abrir una lista de elementos de ventana disponibles mediante programación.

4. Abrir una lista de propiedades de elementos individuales.

5. 5. Análisis sintáctico del nombre del elemento y de la función envolvente de la ventana.

6. Devolución del valor de un parámetro de elemento a una variable de su tipo.

7. Establecer valores a parámetros de elementos de diferentes tipos.

8. 8. Devolución, modificación y reenvío de valores entre parámetros de elementos diferentes. Considerar diferentes tipos de elementos y valores, y probar el reenvío entre diferentes tipos de elementos en diferentes ventanas.

9. Devolución del valor anterior (_V_LAST). Cuándo y para qué casos se requiere el último valor (no confundir con el valor actual).

10. 10. Prueba de estados ON, OFF, LOCK_ON, LOCK_OFF, LOCK, UNLOCK para diferentes tipos de elementos.

11. Prueba de vinculación y sincronización de los valores cambiantes de los elementos: por ejemplo, campo de entrada con botones y deslizador. Para que cuando cambie el valor de un elemento (manual o software), cambie en consecuencia el valor en el segundo elemento.

12. Prueba de obtención/configuración por software de los límites de rango del deslizador y del campo con botones (propiedades _V_MIN, _V_MAX, _V_STEP, _DIGITS).

13. Pruebas de funcionamiento de la consulta del estado de los elementos (_GET_STATE).

14. Vinculación de los colores del texto y del borde a los límites espaciados de los valores.

15. Orientación en el fichero API.

16.Implementación de una lógica de programa simple de aparición de ventanas de mensajes y avisos.

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

Los temas que se han considerado están resaltados en amarillo.

Por el momento quedan algunos por considerar:

14. Vinculación de los colores del texto y del marco a los límites de los valores espaciados.

15. 15. Orientación en el archivo API.

16.Implementación de una lógica de programa simple de aparición de ventanas de mensajes y avisos.

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

Sugiero enlazar el tema 14 con el tema 16. Sobrepasar los límites establecidos de los valores de los parámetros provocará primero señales en forma de cambio de color de partes de los elementos (texto, base, marco, franja, etc.), luego la apertura de una ventana de diálogo, y después una ventana de advertencia. Al mismo tiempo, la ventana de advertencia bloqueará los cambios de valores en los elementos hasta que el usuario la cierre manualmente.

Además, me gustaría añadir un tema a la lista:

17. Cancelar los ajustes introducidos cuando el usuario pulsa el botón "Cancelar".

Hace mucho tiempo, se desarrolló y hasta cierto punto se probó la tecnología de cancelar los ajustes del usuario haciendo clic en el botón "Cancelar". Por el momento, no se sabe hasta qué punto funciona la funcionalidad anterior. Por lo tanto, es necesario realizar una prueba.

Debido al solapamiento de temas, el orden de revisión será el siguiente:

14. Implementación de la protección de límites de parámetros escalonados:

• Escritura de la lógica para controlar los parámetros dentro de los límites preestablecidos y creación de un sistema de advertencia.

• Advertencia 1: el usuario recibe una señal en forma de cambio de color de partes de los elementos.( Vinculemos el color del texto, las bases, los marcos y la barra deslizante a los límites de los valores).

• Advertencia 2: apertura de un cuadro de diálogo con una notificación de riesgo y una sugerencia de volver a la configuración original. ( Probemos la capacidad real de volver a la configuración anterior al hacer clic en el botón "Cancelar". )

• Advertencia 3: apertura de una ventana de advertencia que bloquea los cambios posteriores en la configuración y notifica al usuario la cláusula de exención de responsabilidad, requiriendo la confirmación manual del usuario. ( Probemos el bloqueo de ventanas cuando aparezca la ventana de advertencia. )

15. Consideremos en detalle la impresión del nuevo archivo API.

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

A continuación, voy a recoger todos los errores o defectos encontrados y hacer una lista de tareas para la próxima versión.

Después de la próxima versión con correcciones y adiciones, me centraré en las tablas, en las que veo una de las principales direcciones de desarrollo futuro del motor.

[Реter Konow]

hini #:

He pasado la última semana aprendiendo cómo escribir una interfaz usando WinForm y construirla en los gráficos de MT5. Hoy por fin he descubierto cómo hacerlo.

¿Y cómo vas a hacer que la interfaz se comunique con tu código de programación?

[Реter Konow]

Реter Konow #:

¿Y cómo va a establecer una conexión entre la interfaz y su código de programación?

Algunas preguntas más:

• ¿cuántos formularios (ventanas) puedes "construir" en los gráficos de MT5?
• ¿Cómo traducirá los datos en tablas?
• ¿Puede utilizar plantillas ya preparadas para crear ventanas?
• ¿Puede crear su propia barra de tareas y menú contextual dentro de MT5?
• ¿Cómo va a implementar el software de retorno / propiedades de los elementos? ¿Por sondeo de la DLL de la función de temporizador?

Cuéntame más sobre la solución que encontraste. Esto es muy interesante. :)