Galería de interfaces de usuario escritas en MQL - página 65
Está perdiendo oportunidades comerciales:
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Registro
Entrada
Usted acepta la política del sitio web y las condiciones de uso
Si no tiene cuenta de usuario, regístrese
EstablecerestadoON, OFF, LOCK_ON, LOCK_OFF, LOCK, UNLOCK para diferentes elementos
¿Cómo obtener el estado on/off de un botón?
¿Cómo obtener el estado on/off del botón?
Este es el siguiente tema. Lo consideraremos hoy.
Debo añadir que los elementos de esta GUI están dibujados, por lo que el método estándar de obtener el estado ObjectGetInteger(0, "button1", OBJPROP_STATE); no funcionará.
Además, permítanme recordarles que los eventos de los elementos, incluidos los botones, se envían al archivo API.
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. Orientación en la lista de intellisense y selección del elemento correcto en la ventana correcta.
4. Navegando a través de listas de propiedades de elementos individuales.
5. 5. Análisis sintáctico del nombre de una función envolvente de elemento y ventana.
6. devolver el valor del parámetro de un elemento seleccionado a una variable de su tipo. Considerar tres tipos de varios elementos diferentes.
7. Estableciendo valores en los parámetros de diferentes tipos de elementos. Veamos cómo aparecerán los valores en las ventanas de interfaz de estos elementos.
8. Devolver los valores de los parámetros de un elemento, modificando y reenviando ese valor a otro elemento. Consideremos diferentes tipos de elementos y valores, y probemos 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. Probar la configuración de estados ON/OFF/LOCK_ON/LOCK_OFF/LOCK/UNLOCK para diferentes tipos de elementos.
11. Intentemos enlazar y sincronizar los cambios de valores de elementos de diferentes tipos: por ejemplo, campo de entrada con botones y deslizador. Supongamos que cuando el valor de un elemento (manual o software) cambia, el valor en el segundo elemento cambia en consecuencia.
12. Intentemos restablecer mediante programación los límites de rango del deslizador y del campo de entrada con botones a través de funciones wrapper. No he tenido tiempo de probarlo, pero algo me sugiere que funcionará. No obstante, vamos a ver.
13. Intentemos devolver estados de elementos a través de funciones wrapper. Está incluido en la funcionalidad, pero no he tenido tiempo de probarlo. Así que veremos... El resultado es desconocido.
14. Vamos a obtener y establecer colores para el texto y las bases de los elementos. Podemos intentar asociar estos colores con algunos eventos simples o límites de valores.
15. Te cuento más sobre cómo navegar y leer la nueva impresión del archivo API.
//------------------------------------------
Los temas que ya hemos cubierto están resaltados en amarillo.
Hoy repasaremos:
11. Sincronización (enlace) de valores cambiantes de elementos de diferentes tipos: por ejemplo campo de entrada con botones y deslizador. Para que al cambiar el valor de un elemento (manual o software), el valor en el segundo elemento cambie en consecuencia.
12. Intentemos restablecer mediante programación los límites de rango del deslizador y del campo de entrada con botones a través de funciones wrapper. No he tenido tiempo de probarlo, pero algo me sugiere que funcionará. No obstante, vamos a ver.
13. Intentemos devolver estados de elementos a través de funciones wrapper. Está incluido en la funcionalidad, pero no he tenido tiempo de probarlo. Así que veremos... El resultado es desconocido.
11. Vinculación de parámetros de elementos de diferentes tipos.
La persona observadora se habrá dado cuenta de que en una GUI multiventana, los distintos elementos suelen estar vinculados por valores de parámetros, propiedades y estados. Por ejemplo
//-------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------
Se podría pensar que hay una conexión de elementos invisible en alguna parte. Y realmente la hay. Pero es invisible sólo para un observador externo. Para un desarrollador es bastante obvio y hoy lo consideraremos en detalle.
1. La conexión de elementos tiene dos caras:
La realización técnica de las conexiones se simplifica gracias a la presencia de un motor gráfico.
Me explico:
En un Asesor Experto convencional, cada parámetro es inventado, nombrado, almacenado y procesado por elusuario. Se trata de un trabajo rutinario que no se puede eludir. Sin embargo, en caso de utilizar un motor gráfico, los elementos creados en el constructor reciben automáticamente el parámetro junto con la ubicación de almacenamiento y la función de procesamiento/devolución. Además, el usuario obtiene sus propiedades como tipo, rango, valor pasado, etc. Esto simplifica enormemente la labor. Teóricamente, es posible utilizar los parámetros listos de los elementos GUI como otros parámetros de usuario, vinculándolos directamente a la lógica de negociación. Por ejemplo, lote, trailing stop, toma de beneficios y otros, no desde sus propias variables, sino desde los campos de configuración responsables de sus valores.
Algunas conclusiones generales:
1. La presencia de un control gráfico en un programa = la presencia de un parámetro del programa preparado + sus propiedades + la función de devolver/establecer el valor.
2. 2. Cuantos más controles se coloquen en las ventanas del programa de interfaz, más parámetros intervienen en la lógica comercial y en la entrada/salida de información comercial.
3. Cuantos más parámetros y ventanas - mayor control y mayor ancho de banda de salida de datos de mercado (sin perjuicio de la automatización).
4. Cuanto mayor sea el control y más amplio sea el ancho de banda de salida de datos de mercado: mejor será el conocimiento del operador.
5. 5.Conocimiento multiplicado por automatización y control = aumento de las oportunidades para el operador.
Debo añadir que la automatización suele oponerse al control manual. Dicen que tener una interfaz gráfica significa operar manualmente. Pero no es así. La interfaz de software no excluye la automatización, sino que la amplía, añadiéndole un "gradiente": abre tres opciones: control manual, negociación semiautomática y modo autónomo.
Todo lo que tiene que hacer un operador es seleccionar una opción.
Es fácil crear una ventana para este fin.
//---------------------------------------------------------------------------------------------------
2. Pasemos a la aplicación técnica de la vinculación de los parámetros de los controles.
Veamos algunos ejemplos prácticos:
1. Abramos una ventana de configuración familiar:
2. Abramos el archivo API y encontremos los elementos de la ventana abierta dentro de la función On_Gui_Event():
Recordatorio: Todos los eventos de control entran en la función On_Gui_Event();
En este sentido, escribiremos algunos de los enlaces de los parámetros dentro de esta función, y otros fuera de su cuerpo.
1. Establezcamos una conexión entre el campo con botones (S_EDIT) "Girar el valor" y el deslizador (H_SLIDER) "Girar el valor":
Resultado: cambiamos el valor del campo con los botones, y el deslizador se mueve solo.
(*Importante - el deslizador sólo puede moverse dentro de su rango (en este caso, de 0 a 100). En caso de exceder el rango, el valor no cambia, pero se muestra un error en el registro).
//----------------------------------------------------------------------------------------------------------------
3. Vamos a invertir los papeles. El deslizador controlará el valor en el campo de entrada:
Resultado: Al mover el control deslizante, el campo con botones cambia el valor de forma sincronizada.
//----------------------------------------------------------------------------------------------------------------
4. Escribamos el control mutuo del deslizador y del campo con botones:
Resultado: El deslizador y los campos de entrada se controlan mutuamente de forma simultánea.
//---------------------------------------------------------------------------------------------------
Mañana publicaré la segunda parte de este tema con otros elementos.
Esto es increíble. Tengo la intención de comprobar este hilo con más detalle dado el tiempo. Pensé que mi trabajo estaba empujando el sobre de mt4 GUI pero su trabajo es el siguiente nivel.
Es un material impresionante. Tengo la intención de explorar este tema con más detalle cuando tengo tiempo. Pensé que mi trabajo estaba empujando los límites de mt4 GUI, pero su trabajo es el siguiente nivel.
¡Muchas gracias por sus amables palabras!
11. Parámetros vinculantes de elementos de diferentes tipos.
12. Continuación del tema.
Parte 2.
//--------------------------------------------------------------------------------------------------------------------------------
Veamos si podemos aplicar el método de vinculación mostrado a otros elementos. Por ejemplo, a las casillas de verificación.
1. Hagamos que el checkbox superior bloquee y desbloquee el checkbox que tiene debajo:
Para ello:
1. Busquemos la casilla de verificación"Establecer una opción" en el archivo API.
2. 2. Escribamos una llamada a una función para la casilla"Establecer otra opción" que bloquee/desbloquee.
Resultado: la casilla de verificación se bloquea y desbloquea según lo previsto:
//--------------------------------------------------------------------------------------------------------------------------------
2. Ahora, hagamos que la casilla de verificación bloquee y desbloquee las dos casillas de verificación situadas debajo de ella:
Resultado: la casilla de verificación bloquea y desbloquea las dos casillas de verificación que tiene debajo:
Así es como ocurrió en la dinámica:
//--------------------------------------------------------------------------------------------------------------------------------
3. Ahora vamos a resolver el problema que se muestra en el siguiente diagrama: las casillas de verificación deben bloquear y desbloquear las listas desplegables situadas frente a ellas.
Para ello:
Resultado: las casillas de verificación bloquean las listas desplegables y se bloquean a sí mismas con la casilla de verificación principal:
//--------------------------------------------------------------------------------------------------------------------------------
4. Pasemos a la siguiente tarea: las listas desplegables deben traducir el valor seleccionado por el usuario a un campo de otra ventana.
Para ello:
*Resultado: ambas listas desplegables envían con éxito sus valores a los campos de entrada de la ventana opuesta:
//--------------------------------------------------------------------------------------------------------------------------------
5. En este diagrama se muestra la siguiente tarea: Necesita que los botones de radio que están conmutados envíen su nombre a los campos de entrada de enfrente.
Para ello:
*Nota importante: los botones de radio se activan porque se les aplicó el operador SWITCH en el código KIB. Por lo tanto, tienen un parámetro común para todos ellos y están en el archivo API en el mismo caso.
Resultado: Al conmutar los botones cambia el texto del campo de entrada.*Hay un pequeño problema técnico con esta opción. Será corregido en la próxima versión.
La segunda parte está terminada.
En la tercera parte trabajaremos con la tabla.
La parte final del tema de la vinculación de parámetros.
Vamos a pasar los valores de los parámetros de los elementos a las celdas de la tabla.
Esquema:
Solución:
Resultado: los valores se colocan de forma segura en las celdas de la tabla seleccionadas.
Como se puede ver en los ejemplos anteriores, hemos desarrollado una solución simple y conveniente. Espero que la gente la encuentre útil.
Con esto concluimos el tema de la vinculación de parámetros de elementos.
Quedan por tratar los siguientes temas:
12. Obtener/establecer mediante programación los límites de valor del campo deslizante y del botón(_V_MIN, _V_MAX, _V_STEP, _DIGITS).
13. Consultar el estado de los elementos(_GET_STATE).
14. Vinculación de los colores del texto y del marco a los límites de los valores espaciados.
15. Orientación en el archivo API.
Adición de un tema:
16. Realización de la lógica del programa de aparición de ventanas de mensajes y avisos.