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

Nuevo comentario
[Eliminado]  
Puedes entenderlo.
 
Jin Rong Xia #:
Puedes entenderlo.
Sí, puedo entenderlo. El traductor funciona bien.
 

Tema 14.3: Indicación de valores peligrosos mediante el parpadeo de partes de elementos (marcos, bases, texto, deslizadores y paneles deslizantes).

El parpadeo de los elementos es un complemento excelente de la indicación por colores que señala el paso de los parámetros a la zona de valores peligrosos. La aplicación de la nueva solución es similar a la anterior, pero si la indicación de color funciona según el principio de que cuanto más se acerca el valor al valor crítico, más brillante es el color, el parpadeo sólo aumenta la frecuencia de cambio del color inicial con el color fijado para el parpadeo. El usuario puede ajustar programáticamente el retardo del parpadeo, disminuyéndolo gradualmente hasta 25 ms o aumentándolo hasta 2,5 segundos. En este caso, ambos mecanismos pueden funcionar simultáneamente. El color pasa del verde claro al rojo vivo y burdeos, y el parpadeo aumenta de velocidad. Un mecanismo no interfiere con el segundo. A continuación, veremos ejemplos prácticos.

*Importante: el parpadeo se activa independientemente de las funciones de indicación del color. Los dos mecanismos no están técnicamente relacionados y pueden funcionar en paralelo o por separado.

Para implementar el parpadeo, se han añadido nuevas propiedades a los elementos interactivos:

  • pn_BLINK_frame -. Parpadeo del marco Se añade a todos los controles que tienen marco. Se excluyen los siguientes elementos: H_SLIDER, V_SLIDER, VALUE , R_BUTTON, CHECKBOX.
  • pn_ BLINK_text - Texto intermitente Se añade a todos los elementos que tienen texto. Se excluyen los elementos P_BAR, D_BAR, H_SLIDER, V_SLIDER.
  • pn_BLINK_base - Base de parpadeo Se añade a todos los elementos que tienen base. Se excluyen los siguientes elementos: CHECKBOX, R_BUTTON, D_LIST, C_LIST, VALUE.
  • pn_BLINK_bar -Barra intermitenteSe añade a los elementos que tienen barra: P_BAR , D_BAR,H_SLIDER, V_SLIDER.
  • pn_BLINK_handle - Parpadeo del deslizador . Se añade a los deslizadores H_SLIDER, V_SLIDER.


Añadidas nuevas propiedades para controlar la velocidad y la parada del parpadeo:

  • pn_BLINK_DELAY - Retardo del parpadeo. Añadido a todos los elementos principales sin excepción. *Importante - el retardo se establece para todas las partes parpadeantes del elemento y no puede diferir de una parte a otra. Todas las partes del elemento con parpadeo habilitado por software (puede haber varias) parpadearán sincronizadamente. Sin embargo, la velocidad de parpadeo entre elementos puede diferir y esto queda totalmente a discreción del usuario.
  • pn_BLINK_STOP Elcomando que detiene completamente el parpadeo de todos los componentes del elemento.
  • En la fase actual, es posible habilitar el parpadeo del marco de la ventana de configuración. Para ello, es necesario llamar a la función ventana y pasarle el identificador de la propiedad pn_BLINK_frame. Y el color. Todo es exactamente igual que para los elementos.

Resumamos lo anterior:

  • El retardo de parpadeo pn_BLINK_DELAY se establece mediante programación y se aplica a todas las partes parpadeantes del elemento a la vez. Parpadean de forma sincrónica.
  • La propiedad pn_BLINK_DELAY tiene un valor por defecto. A menos que el usuario lo especifique explícitamente, el retardo del parpadeo será 20, que es algo más de un segundo (20*25ms).
  • Un elemento puede tener parpadeos de varias partes a la vez, o de una parte a la vez. La decisión la toma el usuario.
  • En el proceso de parpadeo es posible cambiar programáticamente el color y ajustar la velocidad. Las funciones de parpadeo se tratarán a continuación.
  • Para hacer parpadear otra parte del elemento es necesario llamar a la función y pasar el identificador de la parte del elemento y el color. Pero si, por ejemplo, un marco está parpadeando y el usuario quiere que el texto parpadee al valor deseado, y el marco deja de parpadear, es necesario desactivar completamente el parpadeo utilizando el comando pn_BLINK_STOP, y luego activar el parpadeo del texto mediante una llamada al programa.
  • A petición del usuario, los componentes del elemento pueden parpadear en diferentes colores. Por ejemplo, el texto puede parpadear en verde, el marco en azul y la base en rojo. Existen diferentes variaciones. Pero te recuerdo que la velocidad de parpadeo de todas las partes de un elemento es la misma.
  • Si una ventana está minimizada y su pestaña está en la Barra de Tareas, y hay elementos parpadeando en la ventana, la pestaña seleccionará automáticamente el elemento que parpadee más rápido en la ventana cerrada (no hay redibujado real cuando la ventana está cerrada) y se ajustará a su frecuencia y color. Es decir, las pestañas de la barra de tareas parpadean con el color y la velocidad del elemento que parpadea más rápido en su ventana. Pero si los elementos cambian su velocidad de parpadeo mientras reciben valores, la pestaña se reconstruirá automáticamente buscando otro elemento y cambiando su velocidad y color de parpadeo.
  • En caso de desactivación completa del parpadeo de los elementos de la ventana, la pestaña deja de parpadear automáticamente.

Mañana pasaremos a los ejemplos prácticos.

Hoy sólo una pequeña demo para entender de qué estamos hablando.



Desafortunadamente, hay lags al grabar. El procesador se carga. Pero la demo muestra que los elementos parpadean de forma asíncrona y a diferentes velocidades. Diferentes partes de los elementos también parpadean. Todo esto se establece mediante programación. Y la pestaña de la barra de tareas encontró automáticamente el elemento que parpadeaba más rápido y se volvió azul. Luego, cuando el elemento empezó a parpadear con menos frecuencia, encontró el otro elemento que parpadeaba más rápido y se volvió rojo.

Mañana veremos esto con más detalle.

P.D. También hablaremos de las opciones para utilizar estas funciones tan útiles.

 


Continuación del tema de ayer...

Hoy resumiremos conceptualmente y terminaremos el tema de la intermitencia de los elementos.

Ayer sólo traté la intermitencia en el contexto de la señalización de valores peligrosos, pero la aplicación puede ser mucho más amplia que eso. He aquí un ejemplo:

Imaginemos un Asesor Experto multidivisa que analiza la situación de varios mercados. Supongamos que selecciona los puntos óptimos de entrada/salida según un conjunto de criterios complejos. El Asesor Experto funciona en modo semiautomático y el operador no puede o no quiere programar toda la lógica de la estrategia de negociación. Su robot supervisa los mercados, recopila datos e informa sobre los puntos importantes. El trabajo del experto se limita a analizar y mostrar los resultados en tablas y diagramas. La decisión final sobre las operaciones la toma una persona.

En esta variante, la actividad comercial consiste en observar flujos de datos en tiempo real y empaquetar la serie de valores en curso en parámetros personalizados. Estos últimos ayudan a escalar el conocimiento de la situación.

Sin embargo, el compromiso en vivo requiere decisiones oportunas. El problema surge cuando los resultados de los análisis se muestran en distintas ventanas a través de múltiples vistas gráficas. La cantidad de información que requiere atención crece y el foco de atención se divide. Como resultado, la perspectiva del mercado se nubla en la mente del operador y disminuye la eficacia de su trabajo. Llega la fatiga.

En este caso, los elementos intermitentes son una buena ayuda:

  • Señala la urgencia de tomar decisiones o emprender acciones.
  • Informa sobre la velocidad de los cambios entrantes.
  • Informa sobre la relevancia de los acontecimientos observados.
  • Informa sobre el significado de los resultados obtenidos: cifras, diferencias, rangos, sumas, límites, etc.

En resumen:
  • El parpadeo puede recordar, advertir, informar, señalar o indicar.
  • El parpadeo centra la atención y aumenta la concentración del operador.
  • La frecuencia y el color determinan la urgencia de las decisiones o acciones.
  • Combinado con el cambio de color, el parpadeo aumenta la interactividad de la interfaz gráfica de usuario y la eficacia del operador.

Pasemos ahora a un desglose práctico de la nueva funcionalidad:

  • 1. Prescribamos el orden de las acciones preparatorias.
  • 2. Activemos el parpadeo del marco del botón al pulsarlo y desactivemos el parpadeo al soltarlo.
  • 3. Activemos el parpadeo del texto del botón.
  • 4. Activemos el parpadeo de la base del botón.
  • 5. Conectemos otros elementos al parpadeo del botón: un campo con botones, un deslizador, una casilla de verificación y otros.
  • 6. Activemos el parpadeo del marco de la ventana.
  • 7. 7. Conectemos la velocidad de parpadeo de los elementos con el valor del deslizador y el campo con botones.

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

1. Orden de las acciones preparatorias:

  • En primer lugar, vamos a escribir los wrappers de las funciones Blink_start() y Blink_stop(), que deberán activar y desactivar el parpadeo de los elementos cuando sean llamados.
  • La función Blink_start() será responsable del encendido. Será llamada en el evento de pulsación. La función Blink_stop() será responsable de apagar el parpadeo. Será llamada cuando se pulse el botón "Start".
  • Busquemos el botón en el archivo API y escribamos la llamada de la función Blink_start( ) al pulsar el botón y la llamada de la función Blink_stop() al pulsarlo. 
//-----------------------------------------------------
//This function will start the blinking of the elements.
//-----------------------------------------------------
void Blink_start()
{

}
//-----------------------------------------------------
//This function will stop the blinking of the elements.
//-----------------------------------------------------
void Blink_stop()
{

}


Ahora encontremos el caso del botón "Start" en el archivo API y escribamos las llamadas de las funciones Blink_start() y Blink_stop() en el evento de pulsar y presionar el botón:

case Settings_example_1___Start:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the button is pressed or released?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                case pressed:    Blink_start();  break;
  
                case released:   Blink_stop();   break;
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;


Pasemos a llenar de contenido las funciones:

1. Necesitamos que el marco del botón "Start" parpadee. Escribamos una llamada para el parpadeo del marco como se muestra en el código siguiente. El identificador de la propiedad de parpadeo del marco del botón es p1_BLINK_frame. Especifiquemos el color del parpadeo y el objeto del parpadeo.

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
}


2. Ahora vamos a implementar la desactivación del parpadeo cuando se suelta el botón. El identificador p1_BLINK_STOP se encarga de desactivar el parpadeo . No hace falta poner nada entre paréntesis excepto él.

void Blink_stop()
{
 //Stopping the blinking of all of the parts of the element all together:
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
}


Vamos a comprobar el resultado:



3. Activemos el parpadeo del texto del botón en lugar del marco. El identificador de la propiedad pn_BLINK_text es el responsable del parpadeo del texto:

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
}

Resultado: el texto del botón parpadea en azul y deja de parpadear cuando se pulsa el botón.



4. Activemos el parpadeo de la base del botón. El identificador de la propiedad pn_BLINK_base es el responsable de la base:

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_base);
}

Resultado: la base del botón parpadea en rojo y deja de parpadear cuando se pulsa.



Ahora combinemos el parpadeo del marco del botón y de su texto:

void Blink_start()
{
 //Setting the blinking of the frame and the text of the button
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
 w_6_Settings_example_1((int)clrRed,p8_BLINK_text);
}

Resultado: elmarco del botón y el texto del botón parpadean sincrónicamente en colores diferentes, como estaba previsto.


5. 5. Conectemos otros elementos de esta ventana al parpadeo: 

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_frame);
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_text);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_handle);
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_bar);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option((int)C'255,50,0',p7_BLINK_text);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1((int)C'255,50,0',p6_BLINK_frame);
 //-------------------------------------------------------------
}

Escribamos también la desactivación del parpadeo dentro de la función Blink_stop( ) : 

void Blink_stop()
{
 //Stopping the blinking
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value(p5_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value(p3_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option(p7_BLINK_STOP);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1(p6_BLINK_STOP);
 //-------------------------------------------------------------
}

Resultado: los nuevos elementos se incluyen en Blink_start() y Blink_stop() y parpadean según lo previsto.


6. Hagamos que el marco de la ventana parpadee cuando se pulse el botón. (Desactivemos temporalmente el parpadeo de los elementos retrasados).

void Blink_start()
{
//Setting the blinking of the frame of the window:
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
}

void Blink_stop()
{
//Stopping the blinking of the frame of the window:
 w_6_Settings_example_1(p8_BLINK_STOP);
}


Resultado: el marco de la ventana parpadea como debe.


*Importante: todos los elementos considerados y el marco de la ventana parpadean a la velocidad por defecto.

Más adelante regularemos la velocidad de parpadeo de los elementos con el tirador deslizante y el campo con botones.


7. Vinculemos la velocidad de parpadeo al valor del campo con botones y deslizador. Todos los elementos y el marco de la ventana parpadearán simultáneamente, y la velocidad de parpadeo será fijada manualmente por estos elementos.

Te recuerdo que la velocidad de parpadeo depende del retardo pn_BLINK_DELAY.

  • El retardo mínimo posible es 1, el máximo es 99.
  • Para calcular el tiempo de retardo del parpadeo, hay que multiplicar su valor por 25 (ms).
  • Por defecto, el retardo es igual a 20, es decir, 500 milisegundos (20*25ms).

Para resolver el problema, hagamos lo siguiente:

  • 1. Recuperemos el parpadeo de todos los elementos al pulsar/soltar el botón y añadámosles el parpadeo de la ventana de llamada/parada.
  • 2. Escribamos una nueva función Blink_delay() en la que colocaremos llamadas que establezcan una pausa en el parpadeo. La función aceptará el valor del retardo.
  • 3. Escribamos una llamada a la función Blink_delay() desde los casos de elementos deslizantes y campo de entrada en el archivo API, pasando el valor actual.

A ñadimos el parpadeo del marco de la ventana dentro de la función Blink_start(): . 

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 //-------------------------------------------------------------
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_frame);
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_text);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_handle);
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_bar);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option((int)C'255,50,0',p7_BLINK_text);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1((int)C'255,50,0',p6_BLINK_frame);
 //-------------------------------------------------------------
}

Añadimos la desactivación del parpadeo del marco de la ventana dentro de la función Blink_stop(): 

void Blink_stop()
{
 //Stopping the blinking
 //-------------------------------------------------------------
 w_6_Settings_example_1(p8_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value(p5_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value(p3_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option(p7_BLINK_STOP);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1(p6_BLINK_STOP);
 //-------------------------------------------------------------
}

Escribimos la función Blink_delay():

Llamamos a la función Blink_delay() en el evento de los elementos slider y input field, y le pasamos el valor actual de los elementos:

void Blink_delay(uint delay)
{
 if(delay > 0 && delay < 100)
   {
    //-------------------------------------------------------------
    w_6_Settings_example_1(delay,p8_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_i_p1_BUTTON_Start(delay,p1_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_d_p5_S_EDIT_Spin_the_value(delay,p5_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_i_p3_H_SLIDER_Roll_the_value(delay,p3_BLINK_DELAY);
    //-------------------------------------------------------------
   }
else Print("Wrong value!");
}

*Nota importante: resultó que es imposible cambiar la velocidad de parpadeo de los elementos checkbox y lista desplegable. Esta velocidad es siempre igual a 20 (medio segundo). Esto se hizo intencionadamente, pero probablemente lo cambie en el futuro. Los otros elementos pueden cambiar la velocidad de parpadeo.

Escribamos una llamada a la función Blink_delay() desde el evento del elemento "Spin_the_value" (el campo con botones). El campo está conectado al deslizador, así que no hay necesidad de poner la llamada en el caso del deslizador. La conexión funcionará y el deslizador sin llamada directa cambiará la velocidad de parpadeo a través del campo con botones:

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
               //------------------------------------------------------------------------------------------------------
               w6_i_p3_H_SLIDER_Roll_the_value((int)value);
              
               //Сalling the blinking delay function
               Blink_delay((int)value);
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;


Resultado: el campo con botones y el deslizador cambian la velocidad de parpadeo de los elementos de la ventana.



Resultado:

  • Al implementar el parpadeo de los elementos, la interfaz es mucho más interactiva e informativa que antes.
  • Los métodos para activar, controlar y desactivar el parpadeo de los elementos son muy simples y se describen en detalle en dos entradas de esta página.
  • Los métodos se enumeran y demuestran con ejemplos de código y vídeos.
  • Probablemente algunos matices pueden ser refinados o añadidos en el futuro, pero en general las características básicas de parpadeo ya están añadidas y no requieren grandes cambios.
  • Se puede cambiar el color del parpadeo mientras se cambia el valor del parámetro del elemento.

Considero este tema agotado.


Siguiente en la lista - cancelación de los valores introducidos pulsando el botón "Cancelar".

 
La próxima versión saldrá el lunes o martes de la semana que viene. La actualización incluirá las funciones indicadas anteriormente, así como la cancelación/confirmación de la introducción de parámetros en las ventanas de configuración. Además, se traducirán los catálogos al inglés y se mejorará y corregirá el código a partir de la lista de problemas identificados.
 
Реter Konow #:
La próxima versión saldrá el lunes o martes de la semana que viene. La actualización incluirá las funciones indicadas anteriormente, así como la cancelación/confirmación de la introducción de parámetros en las ventanas de configuración. Además, los catálogos se traducirán al inglés, y el código sufrirá retoques y correcciones a partir de una lista recopilada de problemas identificados.
Esperemos que llegue a tiempo.
 
El trabajo se descuida, o simplemente tienes una "temporada de terciopelo", ¿unas vacaciones? Eso es sagrado.
 
Edgar Akhmadeev #:
El trabajo se descuida, o simplemente tienes una "temporada de terciopelo", ¿unas vacaciones? Eso es sagrado.
El trabajo no ha terminado, pero se han reestructurado las prioridades. Tal vez continúe, si hay demanda pública. De todos modos, necesito tablas dinámicas y generadas. Y también gráficos. Seguro que los haré. El resto - como resulta.
 
Реter Konow #:
Tal vez continúe si hay demanda pública.

Hay demanda. El hecho de que la mayoría de la gente guarde silencio sobre el tema es normal. La gente acecha y espera. Hasta ahora no se ha llevado a cabo ningún gran proyecto. Siempre es difícil sacarlo adelante solo y sin financiación. Hasta ahora sólo conozco un proyecto llevado a buen puerto por una sola persona: "VLADIK BRUTAL" en Steam.

 
Edgar Akhmadeev #:

La demanda está ahí. El hecho de que la mayoría guarde silencio sobre el tema es normal. La gente está al acecho. Hasta ahora no se ha llevado a cabo ningún gran proyecto. Siempre es difícil sacarlo adelante solo y sin financiación. Hasta ahora sólo conozco un proyecto llevado a buen puerto por una sola persona: "VLADIK BRUTAL" en Steam.

Es una táctica extraña acechar y esperar. :) Si la gente participara activamente, no habría cambiado las prioridades y muchas cosas ya estarían terminadas. Sin embargo, las tareas principales que he enumerado se completarán independientemente de la demanda, porque lo veo como un interés personal. Pero, no soy avaricioso, compartiré con la comunidad). Simplemente no estableceré un calendario claro.

Espero terminar todo antes del año nuevo. Necesitas tablas dinámicas, ¿verdad? Definitivamente así será.

También me gustaría recordaros que las tablas normales están disponibles en el montaje y funcionan bien. Y ahora, gracias a la presencia de la gestión de interfaces de programa, trabajar con ellas se ha vuelto fácil.

Hay un montón de lecciones sobre el lenguaje de marcado, porque el material se cubre menos de la mitad, pero de nuevo - ¿quién lo necesita? ¿Yo? Yo ya lo sé todo. ¿Y los demás? No oigo ninguna petición. Pero componer cada lección es un gran trabajo, y cada post del tutorial es un mini-artículo. Es mucho trabajo.

Estas son las preguntas. Creo que se pueden entender. Pero, las tablas dinámicas y los gráficos tienen mucho sentido práctico y aparecerán.
1...636465666768697071727374757677...83
Nuevo comentario