Descargar MetaTrader 5

Archivo de registro alternativo con el uso de HTML y CSS

15 febrero 2016, 12:17
Antoniuk Oleg
0
216


¿Por qué debería usarlo? o ¿dónde está el problema?

Cualquier asesor experto se suministra con las funciones que permiten la salida de datos sobre su funcionamiento, estado actual, situaciones imprevistas y otros eventos. Al usar los datos generados por el asesor experto, podemos trazar la cronología de todos los eventos detectados, incluso sin lanzar Meta Trader. Podemos encontrar fácilmente el día necesario e intentar encontrar la información. Pero el problema es que los asesores expertos pueden generar una gran cantidad de mensajes y estos no puede ser organizados con facilidad por el desarrollador del asesor experto, sin mencionar a los usuarios que no saben cómo crear asesores expertos. Si abrimos un archivo de registro típico, veremos un montón de información homogénea presentada mediante cientos y miles de líneas.



Ahora imagine lo fácil que sería si el archivo de registro estuviera organizado de la siguiente forma: los errores y situaciones imprevistas estarían marcados con la fuente de mayor tamaño en color rojo, las alertas estarían en color melocotón de menor tamaño, la información del servicio estaría en color verde brillante, todas las transacciones de trading en azul, y así sucesivamente. En otras palabras, cuando vemos este archivo de registro, podemos saber fácilmente qué ha ocurrido y qué quiere decirnos el asesor experto sin leerlo ni tener que profundizar en los detalles. Estaremos viendo rápidamente las decenas de líneas y no veremos ninguna línea roja o color melocotón. Esto significa que no hay errores ni alertas y todo es correcto. Buscamos en los mensajes de color azul durante unos segundos y nos aseguramos de que las órdenes se han realizado correctamente. ¿Solo un sueño? En absoluto. Vamos a escribir una biblioteca para poner en práctica esta argucia.



Por tanto, en este artículo describiré el proceso de escritura de una sencilla pero muy potente biblioteca para la creación de archivos html, aprenderemos a ajustar su visualización y veremos cómo pueden implementarse y utilizarse fácilmente en nuestros expertos o en el script

¿Qué usaremos?

Usaremos el lenguaje de marcado de hipertexto (HTML) para crear los archivos y las hojas de estilo en cascada (CSS) para ajustar la vista externa según nuestras preferencias. ¿Qué es HTML? Es un lenguaje que describe las páginas web. Gracias a él, podemos leer este texto ahora. No estudiaremos el código HTML, tan solo tendrá que creer en mis palabras para aceptar las cosas tal como son. Veremos los registros con Internet Explorer, Opera o algún otro navegador, no hay muchas diferencias.


Creación de la biblioteca generateHTML

Ahora debemos lanzar MetaEditor e iniciar el procedimiento. Estamos creando una nueva biblioteca e insertamos este código:

//+------------------------------------------------------------------+
//|                                                 generateHTML.mq4 |
//|                                               banderassa@ukr.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, Antonio Banderass. All rights reserved" 
#property link      "banderassa@ukr.net"
#property library
//---- 
int htmlFileHandle=-1;
//+------------------------------------------------------------------+
//| CreateHtmlFile                                                   |
//+------------------------------------------------------------------+
int CreateHtmlFile(string fileName, string title, string style = 
                   "styles/default.css")
  {
   int handle = FileOpen(fileName, FILE_CSV|FILE_WRITE, " ");
   if(handle > 0)
     {
       htmlFileHandle = handle;
       FileWrite(handle,
                "<html><head><title>", title,
                "</title><link rel=stylesheet href=", style, " type=text/css>",
                "</head><body id=body><div align-center><h3 id=title>", title,
                "</h3></div><hr noshade id=hr>");   
     }
   else
       Print("generateHTML library: error while creating html file");
   return (handle);
  }
//+------------------------------------------------------------------+
//| CloseHtmlFile                                                    |
//+------------------------------------------------------------------+
void CloseHtmlFile()
  {
   if(htmlFileHandle > 0)
     {
       FileWrite(htmlFileHandle, "</body></html>");
       FileClose(htmlFileHandle);   
     }
  }
//+------------------------------------------------------------------+
//| WriteMsg                                                         |
//+------------------------------------------------------------------+
void WriteMsg(string text, string style = "text")
  {
   FileWrite(htmlFileHandle, "<font id=", style, ">", text, "</font>");
  }
//+------------------------------------------------------------------+
//| WriteMsgLn                                                       |
//+------------------------------------------------------------------+
void WriteMsgLn(string text, string style = "text")
  {
   FileWrite(htmlFileHandle, "<font id=", style, ">", text, "</font><br>");
  }
//+------------------------------------------------------------------+
//| WriteMsgTime                                                     |
//+------------------------------------------------------------------+
void WriteMsgTime(string text, string style = "text")
  {
   FileWrite(htmlFileHandle, "<font id=", style, ">" + TimeToStr(CurTime()) + 
             ": ", text, "</font>");
  }
//+------------------------------------------------------------------+
//| WriteMsgTimeLn                                                   |
//+------------------------------------------------------------------+
void WriteMsgTimeLn(string text, string style = "text")
  {
   FileWrite(htmlFileHandle, "<font id=", style, ">" + TimeToStr(CurTime()) + 
             ": ", text, "</font><br>");
  }
//+------------------------------------------------------------------+

Guardamos este archivo con el nombre “generateHTML.mq4” en la carpeta “libraries”. La biblioteca solo utiliza las funciones incluidas del lenguaje mql4, por lo que no necesitamos añadir nada más. Pulse F5. Debo decir que la biblioteca solo crea archivos de texto y los rellena con código HTML usando las funciones FileOpen(), FileClose() y FileWrite(). No tiene sentido explicar cada etiqueta, tan solo crea en mis palabras.

Preparación del trabajo

Para el trabajo habitual debemos configurar la biblioteca. Vamos a “...MetaTrader/experts/files”, creamos la carpeta "logs", la abrimos y creamos una carpeta más llamada "styles". Luego vamos a la última carpeta, creamos el archivo "default.css" ahí e insertamos este texto:

#body
  { 
   background-color: dimgray;
  }
 
#title
  {
   font-size:200%;
   color: greenyellow;
  }
 
#text
  {
   font-size: 150%;
   color: greenyellow;
  }
 
#error
  {
   font-size: 180%;
   color: orangered;
  }
 
#warning
  {
   font-size: 120%;
   color: gold;
  }

Discutiremos esto en profundidad más tarde, ahora guardamos el archivo y cerramos el bloc de notas. La preparación de la biblioteca ha finalizado. Veamos cuáles son sus funciones.

Creación de nuestro primer archivo HTML.

Creamos un archivo de texto en blanco. Al comienzo del código añadimos la biblioteca usando la directiva “#include”:

#include "..\libraries\generateHTML.mq4"
Luego introducimos algo de código en la función start():
CreateHtmlFile("logs\log1.html","testing library generateHTML "+TimeToStr(CurTime()));

Esta función crea un archivo html con el nombre "log1.html" en la carpeta "logs". El segundo parámetro es un encabezado que será colocado al principio del archivo. Discutiremos el último parámetro más tarde, se omite en esta etapa porque usaremos el valor por defecto.
Ahora todo está listo para la salida de los mensajes. Allá vamos:

WriteMsgLn("WriteMsgLn(). Test message");

Esta función muestra un sencillo mensaje de texto. Como puede ver no hay nada complicado. El único parámetro es el texto del mensaje. La simpleza da lugar a algunas limitaciones: no podemos abrir ni trabajar con los distintos archivos simultáneamente. Pronto veremos cómo resolver este pequeño problema. El siguiente mensaje se mostrará en una nueva línea. El nombre de la función nos dice las acciones que realiza: Ln se toma de Line New, que significa nueva línea. Demos un paso más:

WriteMsgLn("WriteMsgLn(). Warning message","warning");

Acabamos de definir el segundo parámetro. Este dice que este mensaje debe mostrarse en estilo "warning". Esto significa que el texto tendrá el color melocotón y será un poco más grande que el texto normal. Estos parámetros de visualización se establecen en el archivo "default.css", que será descrito posteriormente. Establecemos el estilo "text2 por defecto, por ejemplo, las dos llamadas siguientes serán idénticas.

WriteMsgLn("WriteMsgLn(). Message");
WriteMsgLn("WriteMsgLn(). Message","text");

Estamos probando los distintos estilos:

WriteMsgLn("WriteMsgLn(). Error message","error");

Realmente los mismos, pero en el estilo "error". El texto será rojo y de mayor tamaño que el anterior. Ahora vamos a describir las funciones para la visualización simultánea de mensajes y tiempo:

WriteMsgTimeLn("WriteMsgTimeLn(). Message with time");

Además del mensaje, se mostrará el tiempo actual. Se colocará al comienzo de la línea. También podemos definir el estilo del mensaje de la misma forma que antes:

WriteMsgTimeLn("WriteMsgTimeLn(). Warning message with time","warning");
WriteMsgTimeLn("WriteMsgTimeLn(). Error message with time","error");

Si queremos visualizar un par de mensaje en una solo línea, usamos las funciones WriteMsg() y WriteMsgTime(). Son idénticas a las anteriores, pero muestran los mensajes en una solo línea:

WriteMsg("WriteMsg(). Text");
WriteMsgTime("WriteMsgTime(). Text with time");
WriteMsg("WriteMsg(). Warning","warning");
WriteMsgTime("WriteMsgTime(). Error","error");
Después de visualizar todos los mensajes, cerramos el archivo HTML:
CloseHtmlFile();
Ahora compilamos el script "html-file creation" y lo ejecutamos en Meta Trader. Vamos a la carpeta de los registros (logs), ...MetaTrader\experts\files\logs\ y abrimos un nuevo registro con nuestro navegador. Como podemos ver, este método de visualización de datos es más claro y fácil de entender. El problema puede aparecer si usted tiene un gusto distinto al mío. Veamos cómo podemos ajustar los colores y el tamaño de fuente usando las hojas de estilo en cascada (CSS).

Ajustar la vista.

Como puede ver no hay nada complicado. Después de aprender cómo usar la biblioteca, ajustemos al visualización de los registros a nuestro gusto. Vamos a la carpeta “...MetaTrader/experts/files/logs/styles”. Abrimos el único archivo que hay allí. Contiene la configuración de la visualización: CSS. Observe las primeras líneas:

#body

Es el nombre del estilo cuya visualización vamos a ajustar. El símbolo # viene primero y luego va el nombre. En este caso es el cuerpo del documento. Este estilo debe añadirse a cualquier archivo CSS.

{ 
    background-color: dimgray;
}
Ahora establecemos el color de la fuente. Escribimos los parámetros y sus valores entre paréntesis de la forma siguiente:

el nombre del parámetro: su valor;

En este caso tenemos: el nombre del parámetro, color de fondo (el color del archivo de registro) y el valor, gris pálido. Además:

#title
  {
    font - size:200%;
    color: greenyellow;
  }

Este estilo se asigna al encabezado que se coloca al principio del archivo. Establecemos el tamaño y color de la fuente. El primer parámetro va en valor porcentual. Además:

#text
{
   font-size: 150%;
   color: greenyellow;
}
 
#error
{
   font-size: 180%;
   color: orangered;
}
 
#warning
{
   font-size: 120%;
   color: gold;
}

Estos son tres estilos familiares que corresponden al texto común, un error y una alerta. También podemos establecer un parámetro adicional "background-color" que establece el color de fondo del texto. Para crear nuestro propio estilo y usarlo tenemos que escribirlo en el archivo y guardarlo. Por ejemplo, de esta forma:

#order
{
   font-size: 160%;
   color: Dodgerblue;
}
Para usar este estilo, lo establecemos como argumento durante la salida del mensaje:
WriteMsgTimeLn("WriteMsgTimeLn(). Order message with time","order");
Ahora podemos crear nuevos estilos y usarlos.

Colores.

Usando los enlaces siguientes podemos encontrar las tablas y colores. No creo que a todo el mundo le guste mi esquema de colores.

http://www.computerhope.com/htmcolor.htm
http://www.immigration-usa.com/html_colors.html
http://html-color-codes.com/
http://www.utexas.edu/learn/html/colors.html

Para usar los colores de las tablas que tienen la vista de 16-bit (p.ej. C34A2C), tenemos que usar el símbolo # antes de él, por ejemplo:

#body
{
   background-color: #C34A2C;
}

Crear nuestros propios archivos de estilos.

Para crear un nuevo archivo de estilo abrimos el archivo "default.css", lo modificamos y lo guardamos con un nuevo nombre. Durante la creación del archivo definimos el último parámetro que indica la ruta hacia el archivo de estilo que queremos usar, por ejemplo:


CreateHtmlFile("logs\log1.html","testing library generateHTML","logs\styles\myStyle.css ");

Crear y usar varios archivos de registro simultáneamente.

Nunca seleccionamos el archivo que vamos a usar mientras trabajamos con la biblioteca y con esto conseguimos simplificarlo. Pero surge una pregunta: ¿cómo debemos escribir el mensaje en varios archivos de registro simultáneamente? Todo es muy sencillo. La función para la creación de archivos html devuelve el valor "int". Este es el identificador del archivo. También tenemos una variable global “int htmlFileHandle”, que muestra qué archivo está en uso en ese momento. Todo lo que necesitamos es recordar los identificadores de todos los archivos de registro para asignar sus valores a la variable “htmlFileHandle” cuando sea necesario.

Esto es todo lo que le quería contar. Ahora tenemos una forma simple de crear y mostrar de forma efectiva los datos. Espero que sea de utilidad para muchos traders y que facilite su trabajo.


Traducción del inglés realizada por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/en/articles/1432

Archivos adjuntos |
generateHTML.mq4 (3.2 KB)
Secretos del terminal de cliente de MetaTrader 4: Biblioteca de archivos en MetaEditor Secretos del terminal de cliente de MetaTrader 4: Biblioteca de archivos en MetaEditor

Cuando se crean programas personalizados, el editor de código es de gran importancia. Cuantas más funciones hay disponibles en el editor, más rápida y cómoda es la creación del programa. Muchos programas se crean sobre la base de un código ya existente. ¿Utiliza un indicador o un script que no se ajusta completamente a su propósito? Descargue el código de este programa de nuestro sitio web y personalícelo.

Construcción de líneas fractales Construcción de líneas fractales

Este artículo describe la construcción de líneas fractales de distintos tipos usando las líneas de tendencia y los fractales.

Ejecutando el terminal de cliente de MetaTrader 4 en el escritorio de Linux Ejecutando el terminal de cliente de MetaTrader 4 en el escritorio de Linux

Descripción paso a paso de la configuración del escritorio de Linux usando un emulador de Windows (wine) no emulador para ejecutar el terminal de cliente de MetaTrader 4 en él.

¿Cómo no caer en las trampas de la optimización? ¿Cómo no caer en las trampas de la optimización?

El artículo describe los métodos para conocer mejor los resultados de la optimización del probador. También da algunos ejemplos que ayudan a evitar la "optimización perjudicial".