Simulación de mercado: Position View (I)

Introducción

Hola a todos y bienvenidos a un nuevo artículo de la serie sobre cómo construir un sistema de repetición/simulador.

En el artículo anterior, Simulación de mercado: Iniciando SQL en MQL5 (V), terminé la explicación de todo lo que consideramos necesario para que tú, querido lector, puedas comprender lo que veremos en los próximos artículos. Sé que todo este tema que hemos estado tratando en estos últimos artículos no es algo tan simple de comprender de un momento a otro. Y creo que muchos de ustedes ni siquiera imaginaban que era posible hacer ciertas cosas aquí en MQL5. Sin embargo, todo lo visto hasta ahora fue apenas la punta de un inmenso iceberg. Esto se debe a que solo presenté un poco sobre sockets y un poco sobre SQL.

A mi juicio, lo que se introdujo durante este tiempo te beneficiará en los próximos pasos. De ahora en adelante, empezaremos a tratar un tema todavía más denso y complejo. Aun así, intentaré al máximo no complicarte la vida, querido lector y entusiasta. Quiero, sí, motivarte a buscar estudiar y profundizar todavía más en lo que voy a mostrar a partir de este punto.

Así que toma aire. Respira hondo y prepárate, porque ahora vamos a sumergirnos todavía más en el sistema de repetición/simulador. Lo que me propuse mostrar sobre cómo desarrollar ese sistema ya está casi en su punto culminante. Es decir, falta muy poco por mostrar. Pero, como el contenido es mucho más complicado en términos de teorías y conceptos, intentaré dejarlo lo más simple posible. La parte referente a la programación en sí es incluso bastante simple y directa. Pero, si no comprendes toda la teoría que hay detrás, te quedarás completamente sin recursos para poder mejorar o incluso adaptar el sistema de repetición/simulador a algo diferente de lo que voy a mostrar.

Mi intención no es que simplemente compiles y uses el código que estoy mostrando. Quiero que aprendas, entiendas y, si es posible, puedas crear algo todavía mejor. No mostraré cómo hacer una serie de cosas. Esto se debe a que esas cosas son modelos que utilizo en la práctica y que fueron desarrollados especialmente para permitir generar, o mejor dicho, implementar un sistema de trading, el llamado Asesor Experto, que aprende con el tiempo. Y que crea su propio método de operación, acercándose a lo que haría un operador humano en la práctica.

En el último artículo, que fue Simulación de mercado (Parte 05): Iniciando la clase C_Orders (II), donde hablé sobre el sistema de repetición/simulador, hicimos un pequeño Asesor Experto capaz de comunicarse con Chart Trade, que se había desarrollado anteriormente. Eso fue hace ya algún tiempo. Así que, si no recuerdas cómo estaba el código, repasemos rápidamente cómo se dejaron las cosas. Partiremos de ese punto. Todo lo desarrollado desde aquel momento hasta el actual se utilizará muy pronto. Pero recordemos cómo se hacían las cosas.

Recordando lo que ya se desarrolló en el sistema de repetición/simulador

Este es un punto importante, porque, sin saber qué ya se ha desarrollado, acabarás volviendo sobre puntos que ya están plenamente operativos y no hace falta revisar. A pesar de todo, todavía pienso mostrar cómo hacer algo concreto. Pero eso queda para otro momento. Primero, repasemos lo que ya está en pleno funcionamiento.

El sistema de repetición/simulador cuenta con varias aplicaciones separadas entre sí. Sin embargo, cuando se combinan, te permiten interactuar con MetaTrader 5 de una manera muy parecida a la que tendrías al estar conectado a una cuenta demo o real. Entre esos elementos se encuentran un indicador de mouse, responsable de permitirnos generar estudios o interactuar con elementos en el gráfico, así como Chart Trade, que puede enviar órdenes o solicitudes de ejecución a mercado a través del Asesor Experto. Esto se debe a que, al usar el indicador de mouse y Chart Trade, que también es un indicador, podemos comunicarnos, mediante un protocolo de mensajes, con el Asesor Experto, que también se encuentra en el gráfico.

Estas tres aplicaciones, por separado, no son muy prácticas. Sin embargo, una vez que estén en el gráfico, podrás interactuar muy fácilmente con MetaTrader 5 enviando solicitudes de ejecución a mercado. No obstante, cuando se abre o se cierra una posición, todavía no tenemos ninguna indicación en el gráfico al respecto. Aunque no es exactamente así. Podemos contar con la indicación que muestra MetaTrader 5. Pero, si quieres usar un sistema de órdenes cruzadas, te quedarás completamente sin una indicación adecuada. Esto se debe a que, cuando usamos órdenes cruzadas, el gráfico que tenemos es el de un símbolo que estamos observando. Sin embargo, la orden o solicitud de operación se hace sobre otro símbolo, cuyo gráfico no está abierto. Y, en ese punto, MetaTrader 5 no puede ayudarnos con el sistema de indicación que trae incorporado.

Lo mismo ocurre cuando usamos el servicio de repetición/simulador. Aunque podemos, y lo haremos en breve, implementar una forma de visualizar operaciones en el sistema de repetición/simulador, todavía no tenemos una manera adecuada de hacerlo. El motivo es simple: no tenemos un sistema de indicación gráfica que nos permita interactuar con las órdenes o posiciones que puedan existir en ese símbolo específico. Ya sea un símbolo real o un símbolo simulado. Es decir, un símbolo en el que estamos reproduciendo datos.

Así, aunque el sistema de repetición/simulador ya sea capaz de llevar a cabo la tarea que se le propuso, antes que nada necesitamos implementar alguna forma de visualizar e interactuar con cualquier posición u orden que pueda existir en el símbolo. Esto se debe a que, sin hacerlo, crear un sistema de órdenes para realizar estudios en el sistema de repetición/simulador es algo completamente inútil. Porque no podrás interactuar con las órdenes o posiciones que existan en el símbolo.

La creación de esta parte, entonces, se convierte en nuestra primera prioridad. Pero no te preocupes. Al principio vamos a crear un sistema bastante simple. Algo bastante simple, solo para permitirnos tener cierto control cuando trabajemos en el sistema de repetición/simulador. Así que empecemos a hacerlo ahora. Para ello, comienza un nuevo tema.

Creando un indicador simple de posiciones

Empecemos con lo siguiente: como nuestro indicador Chart Trade no es un sistema orientado a órdenes pendientes, sino solo al envío inmediato, vamos a empezar por crear un indicador básico que muestre las posiciones abiertas. Así que, en este momento, no vamos a tratar las órdenes pendientes. Solo nos centraremos en las posiciones abiertas y en cómo mostrarlas en el gráfico. Conviene recordar una vez más que la intención aquí no es mostrar algo que MetaTrader 5 ya hace. La idea es mostrar algo que MetaTrader 5 no nos muestra. Principalmente cuando usamos un sistema de órdenes cruzadas.

Antes de empezar a ver el código que vamos a implementar, me gustaría dejar claro que, en este momento, la idea es solo conseguir implementar algo que permita mostrar las líneas de precio. De ninguna manera estoy creando ahora algo que debas utilizar de forma intensiva. Es decir, primero debemos lograr que las líneas aparezcan cuando exista una, y solo una, posición abierta. No nos centraremos, por ahora, en gestionar varias posiciones abiertas. Así que, a los más impacientes, les pido un poco de paciencia. El objetivo aquí será explicar a los principiantes o entusiastas cómo hacer que las cosas funcionen.

Lo primero que haremos será crear un archivo nuevo. Puede que estés pensando que sería un archivo de tipo Expert Advisor, ya que vamos a trabajar con posiciones que puedan estar presentes en el servidor de trading. Pero no, no crearemos un Expert Advisor. Vamos a crear un indicador. Así que su código inicial puede verse a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "Indicator for tracking an open position on the server."
04. #property version   "1.00"
05. #property indicator_chart_window
06. #property indicator_plots 0
07. //+------------------------------------------------------------------+
08. int OnInit()
09. {
10.     return INIT_SUCCEEDED;
11. }
12. //+------------------------------------------------------------------+
13. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
14. {
15.     return rates_total;
16. }
17. //+------------------------------------------------------------------+
18. void OnDeinit(const int reason)
19. {
20. }
21. //+------------------------------------------------------------------+

Código fuente inicial

Al ver esto, puede que estés pensando lo siguiente: ¿Estás loco o te volviste loco del todo? No hay forma de usar un indicador para algo así. Calma, querido lector, no seas tan impaciente. Ten paciencia. El hecho de que nunca hayas visto algo no significa que no pueda hacerse o que no exista. Hay algunas ventajas en usar un indicador para esta tarea. Aunque no sea algo que muchos recomendarían. Pero, a medida que vayas viendo cómo se construye el código, acabarás entendiendo por qué usaremos un indicador, y no un Expert Advisor, para esto. Como venimos diciendo desde hace algún tiempo, el material de esta serie sobre el sistema de repetición/simulador será cada vez más complejo. Pero estoy intentando dejar las cosas lo más simples y asequibles posible cuando se pueda.

El problema de usar un indicador es que, si no implementas el código de una forma adecuada, acabarás perjudicando por completo el funcionamiento del gráfico. Esto se debe a que MetaTrader 5 coloca todos los indicadores dentro de un único hilo de ejecución. Por lo tanto, si uno de los indicadores se bloquea o queda inoperativo durante un tiempo, el gráfico en el que se encuentre también sufrirá el mismo problema. Mucha gente, a veces, llena el gráfico de indicadores. Pero eso, aunque parezca aceptable, no es lo recomendable, debido a que todos están en el mismo hilo. Y un indicador puede perjudicar a otros, haciendo que el rendimiento general de la plataforma quede comprometido.

Sin embargo, nuestra idea aquí es justamente la siguiente: colocar el indicador en el gráfico y no tocarlo. Es decir, no sufrirá ninguna actualización. Aunque modifiques manualmente el precio del take profit o del stop loss, en este momento el indicador no reflejará ese cambio. Eso se hará después, cuando explique en detalle cómo se hará esa actualización. Así que vayamos con calma. Lo primero es mostrar las líneas de precio. Olvídate de todo lo demás por ahora. Porque implementaremos esto de la forma más simple y didáctica posible. Quiero que aprendas a hacerlo y que, así, consigas crear las modificaciones necesarias para atender tus necesidades personales. Y no que simplemente uses lo que te enseñaré a crear y te quedes totalmente limitado, sin saber hacia dónde ir después.

Muy bien, ahora vamos a modificar el código que vimos anteriormente para que podamos probar algunas cosas. Nuestro nuevo código puede verse a continuación:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "Indicator for tracking an open position on the server."
04. #property version   "1.00"
05. #property indicator_chart_window
06. #property indicator_plots 0
07. //+------------------------------------------------------------------+
08. #include <Market Replay\Auxiliar\C_Terminal.mqh>
09. //+------------------------------------------------------------------+
10. C_Terminal *Terminal;
11. //+------------------------------------------------------------------+
12. int OnInit()
13. {
14.     Terminal = new C_Terminal();
15.     if (!PositionSelect((*Terminal).GetInfoTerminal().szSymbol)) return INIT_FAILED;
16.     Print (
17.             "Position Ticket: ", PositionGetInteger(POSITION_TICKET), "   ",
18.             "Opening Price: ",PositionGetDouble(POSITION_PRICE_OPEN), "   ",
19.             "Stop Position: ", PositionGetDouble(POSITION_SL), "   ",
20.             "Take Position: ", PositionGetDouble(POSITION_TP)
21.           );
22.           
23.     return INIT_SUCCEEDED;
24. }
25. //+------------------------------------------------------------------+
26. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
27. {
28.     return rates_total;
29. }
30. //+------------------------------------------------------------------+
31. void OnDeinit(const int reason)
32. {
33.     delete Terminal;
34. }
35. //+------------------------------------------------------------------+

Código fuente de un indicador de posición básico

Como este código es bastante simple, voy a repasarlo rápidamente, solo para que entiendas cómo funciona. Supongo que no lo sabrás con solo mirar el código. En la línea ocho, incluimos un archivo ya presente en el sistema de repetición/simulador. Este archivo no ha sufrido ningún cambio desde su última actualización mostrada aquí en esta serie. En la línea diez, indicamos que la clase presente en el archivo de cabecera será referenciada mediante un puntero. En la línea 14, inicializamos la clase. En la línea 15, pedimos a MetaTrader 5 que nos informe si existe o no una posición abierta en el símbolo. Si no existe, finalizaremos la ejecución del indicador indicando un fallo.

Ahora presta atención. Cuando la línea 15 haga su trabajo y devuelva verdadero, los datos referentes a la posición del símbolo que estamos pidiendo recuperar estarán disponibles para nuestro uso. Antes de hacerlo, no se nos proporcionará ningún dato válido. Presta atención a este detalle. Si la línea 15 tiene éxito, se ejecutará la línea 16. En esta línea, imprimiremos en el terminal los datos referentes a la posición que fue capturada por la llamada de la línea 15. Al final, en la línea 23, devolvemos un valor que indica que el indicador se inicializó correctamente.

Nada más ocurrirá dentro de este indicador hasta que se retire del gráfico por cualquier motivo. Cuando eso ocurra, en la línea 33 destruiremos la clase y devolveremos al sistema la memoria asignada.

Así de simple. Como resultado, verás los siguientes datos en el terminal, empezando por la posición que se ve en la siguiente imagen.

Una vez que el indicador haya ejecutado su tarea, podrás comprobar el resultado de la ejecución, como se muestra en la siguiente imagen.

Observa que logramos obtener los datos. A diferencia de lo que muchos creen, sí podemos obtener datos de posiciones u órdenes pendientes directamente desde un indicador. No necesitamos usar necesariamente un Expert Advisor para ello. Sin embargo, el hecho de que puedas obtener los datos de una posición u orden pendiente no significa que puedas usar un indicador para enviar o modificar una posición u orden pendiente. Por favor, no confundas las cosas. Quien se encarga de eso, es decir, de enviar o modificar una posición u orden pendiente, es el Expert Advisor. No intentes hacerlo mediante un indicador, porque no funcionará.

Bien. Todo muy bonito. Todo maravilloso. Pero todavía no hemos llegado ni de cerca a lo que realmente necesitamos implementar. Sin embargo, como muchos dicen:

A buen entendedor, pocas palabras bastan.

Así que quien ya sabe cómo añadir objetos al gráfico seguramente ya habrá captado la idea. Pero, si no ha sido tu caso, querido lector, no te desanimes. Porque ahora vamos al siguiente paso que debemos implementar. Es un paso un poco más largo. Aun así, intentaremos que al menos resulte divertido desarrollarlo. Esto se debe a las posibilidades que se abren a partir de aquí. Sin embargo, no iremos directamente al resultado final. Iremos despacio, porque hay algunos puntos que deben observarse, ppara que necesitemos programar lo menos posible. Recuerda: ya tenemos a nuestra disposición algunas aplicaciones que ya se desarrollaron, como Chart Trade, el Indicador de Mouse y un Asesor Experto básico.

Ahora tendremos que crear el indicador de posición. Pero, preferiblemente, deberá colocarse en el gráfico cuando esas otras tres aplicaciones también estén en él. Por ahora, sin embargo, no vamos a preocuparnos por eso. Primero, sigamos adelante y creemos algunos objetos para colocarlos en el gráfico, para que podamos ver la misma información que veríamos si MetaTrader 5 pudiera trabajar, de forma predeterminada, con órdenes cruzadas. Entonces, manos a la obra.

Colocando objetos en el gráfico

Posiblemente estés pensando que colocar objetos directamente en el gráfico, mediante MQL5, es muy complicado o muy simple. En cierta manera, todo dependerá de cómo quieras trabajar y de lo que esperes en términos de funcionalidad. Pero colocar objetos en el gráfico, en el terminal de MetaTrader 5, no es algo complicado. Es incluso bastante simple, ya sea mediante código MQL5 o directamente desde MetaTrader 5, donde tenemos en el menú una opción llamada Insert, que contiene un submenú llamado Objects, y que nos permite colocar algunos objetos directamente en el gráfico, de una forma muy simple y directa. Puedes ver esto en la siguiente imagen.

Sin embargo, existe un problema. No estoy completamente seguro de si ya comenté esto antes. Pero, en cualquier caso, a partir de este momento, tú, querido lector, debes empezar a entender que no podemos hacer las cosas de cualquier manera. No debemos añadir objetos al gráfico solo porque eso hará más bonito el gráfico o incluso porque mostrará datos o información que consideramos necesarios. Hacer esto sin el debido cuidado es una enorme tontería. Por favor, no me entiendas mal. Pero hay algo de lo que muchos ni siquiera se dan cuenta. Y, tarde o temprano, terminan encontrándose con un gran problema que literalmente arruina por completo la experiencia que tú, querido lector, puedas llegar a tener al usar MetaTrader 5.

Aunque, en realidad, el problema no se debe a MetaTrader 5, sino a aplicaciones distintas que van lanzando objetos en el gráfico sin ningún control. Aunque esos objetos no lleguen a saturar el gráfico e impidan por completo leerlo correctamente, pueden convertirse en una auténtica pesadilla. Es como una piedra clavada en el suelo: imaginas que es una piedrecita y, cuando intentas sacarla, descubres que en realidad era una piedra enorme, mucho mayor de lo que imaginabas.

Tal vez estés pensando: Bien, ¿y qué? ¿En qué me afecta esto o por qué debería importarme? Bien, si piensas así, no tengo mucho más que decirte, salvo desearte buena suerte. Pero, si de verdad te interesa y quieres tener la mejor experiencia posible al usar aplicaciones que usan objetos en el gráfico, este tema puede interesarte mucho. El problema no es difícil de ver. Muy al contrario. Es bastante simple de observar. Y, si de verdad quieres ver cómo se produce el problema, bastará con usar un código que publiqué hace algún tiempo. En aquella época, no imaginaba cómo MetaTrader 5 manejaba ciertas situaciones. Pero, para lo que vamos a hacer, será imprescindible saber cómo MetaTrader 5 maneja algunas de ellas.

Si añades una imagen al gráfico de forma que cubra toda el área gráfica, el resultado será un fondo de pantalla, que podrá servirte como una forma de reconocer rápidamente qué símbolo está en pantalla. Además, usar una imagen en el gráfico resulta mucho más atractivo que usar un fondo monocromático. En fin, sobre gustos no hay nada escrito; como mucho, podemos lamentarlos. Bien. Puedes hacerlo colocando el objeto directamente en el gráfico o puedes usar una aplicación para ello. En el primer caso, no tendrás control sobre ciertas cosas. En el segundo, tendrás control total sobre cómo ocurrirán las cosas.

Muy bien. Quien viene siguiendo mis artículos sabe que, dentro de lo que ya se ha mostrado, en cierto momento creamos una clase llamada C_DrawImage. Su finalidad es permitirnos colocar objetos cuyo contenido son imágenes tipo bitmap. Al menos por ahora, ya que todavía no he mostrado cómo trabajar con otros formatos de imagen. Pero lo que nos interesa aquí no es eso, sino otro hecho. Así, usando todo el conjunto de códigos que vengo mostrando, podemos crear el siguiente archivo, que se muestra a continuación:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property description "This indicator allows you to add"
04. #property description "a wallpaper to the chart."
05. #property version   "1.00"
06. #property indicator_chart_window
07. #property indicator_plots 0
08. //+------------------------------------------------------------------+
09. #include <Market Replay\Auxiliar\C_DrawImage.mqh>
10. //+------------------------------------------------------------------+
11. input string    user00 = "WallPaper_1";         //WallPaper
12. input uchar     user01 = 60;                    //Transparency
13. //+------------------------------------------------------------------+
14. C_DrawImage *Draw;
15. C_Terminal *Terminal;
16. //+------------------------------------------------------------------+
17. int OnInit()
18. {
19.     Terminal = new C_Terminal();
20.     if (!Terminal.IndicatorCheckPass("Indicator WallPaper")) return INIT_FAILED;
21.     Draw = new C_DrawImage(Terminal, "WallPaper", 0, "WallPapers\\" + user00 + ".bmp", NULL);
22.     
23.     return INIT_SUCCEEDED;
24. }
25. //+------------------------------------------------------------------+
26. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
27. {
28.     return rates_total;
29. }
30. //+------------------------------------------------------------------+
31. void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
32. {
33.     switch (id)
34.     {
35.         case CHARTEVENT_CHART_CHANGE:
36.             (*Terminal).DispatchMessage(id, lparam, dparam, sparam);
37.             (*Draw).Paint(0, 0, (*Terminal).GetInfoTerminal().Width, (*Terminal).GetInfoTerminal().Height, user01, 0);
38.             break;
39.     }
40.     ChartRedraw((*Terminal).GetInfoTerminal().ID);
41. }
42. //+------------------------------------------------------------------+
43. void OnDeinit(const int reason)
44. {
45.     delete Draw;
46.     delete Terminal;
47. }
48. //+------------------------------------------------------------------+

Código fuente del Wallpaper.mq5

Observa que se trata de un indicador. Pero, ¿qué hace realmente este archivo? Bien, eso es simple. Este pequeño y modesto archivo es, en realidad, una actualización de otro archivo presente en uno de mis primeros artículos. Como ya había dicho, en aquella época no conocía algunas cosas de MetaTrader 5.

El artículo en cuestión es Haciendo el gráfico más interesante: Añadiendo un fondo de pantalla, para quienes tengan curiosidad por conocer la motivación y más detalles sobre la idea detrás de todo el trabajo. Si comparas los códigos, podrás decir que son completamente diferentes. Y sí, lo son, pero no tanto como puedas imaginar. El código presente en aquel artículo tiene un problema cuya solución es extremadamente simple. Después de compilar ese código y cargarlo en el gráfico como una aplicación de MetaTrader 5, el resultado será que aparecerá un fondo en el gráfico. De hecho, la imagen debería ser un fondo.

Sin embargo, aunque esto queda claro en el código, no es exactamente lo que ocurre cuando cambias el marco temporal. Aunque le indiques a MetaTrader 5 que quieres que las barras queden en primer plano, ese fondo de pantalla pasa al primer plano y puede ocultar por completo el gráfico. Pero es incluso peor que eso. El objeto creado allí, originalmente, tiene la prioridad predeterminada para recibir eventos de clic. A diferencia de este código actualizado que estoy mostrando aquí.

¿Pero cuál es el problema de eso? Ninguno, si tienes pocos objetos en el gráfico y están aislados unos de otros. Pero, ¿qué ocurre cuando colocamos un objeto, como un fondo de pantalla, que cubrirá todo el gráfico? ¿Y que tiene la misma prioridad para recibir eventos que otros objetos que también están presentes en el gráfico? Observa que esto empieza a complicarse un poco. Esto se debe a que MetaTrader 5 no sabrá a qué objeto enviar los eventos.

Ahora piensa en lo siguiente: ya tenemos en el gráfico varios objetos necesarios. Están en el indicador de mouse y en el indicador Chart Trade. Sin embargo, los objetos de mouse se rebajaron a la prioridad -1. Y los objetos del indicador Chart Trade están en prioridad cero. Es decir, aunque intentes enviar un evento de clic a un objeto creado en el indicador de mouse, no podrás recibir el evento si el puntero del mouse está sobre algún objeto de Chart Trade. Ya vimos esto durante la implementación de Chart Trade. Sin embargo, no sé si eso sigue fresco en tu memoria, querido lector.

Y ahora surge un nuevo agravante. Tendremos todavía más objetos creados y colocados en el gráfico. Esto se debe a que vamos a crear un indicador de órdenes y posiciones. Sin embargo, la cuestión sigue siendo la misma. ¿Qué deberemos hacer realmente al crear objetos en el indicador de órdenes y posiciones? Si tienen la misma prioridad para recibir eventos que Chart Trade, podremos tener problemas cuando uno se superponga al otro.

Puedes pensar: Pero es simple. El objeto que esté delante tendrá prioridad. Sí, pero vuelvo a repetir: ¿qué objeto? Esto se debe a que, si dos objetos se crean con la misma prioridad y ambos están en la misma posición, MetaTrader 5 los trazará en el orden en que fueron colocados. Es decir, el objeto que se colocó por último se superpondrá a los que se crearon antes. Pero el problema no es ese, sino lo que ocurre cuando se produce un evento en el que el gráfico necesita redibujarse, como sucede cuando tú, querido lector, cambias el marco temporal. En ese momento, el orden en que se crearán los objetos puede ser diferente del orden que existía antes, haciendo que todo resulte muy confuso y difícil de manejar. Si haces que todos los objetos sean creados por una sola aplicación, de acuerdo, problema resuelto. Sin embargo, hemos dado prioridad a no concentrarlo todo en un único archivo enorme. Por eso, necesitamos controlar un poco más cómo se crean las cosas.

Consideraciones finales

Para quien simplemente esperaba ver que las cosas ocurrieran de forma rápida y atropellada, este artículo tal vez haya sido un balde de agua fría. Aquí empecé a presentar la directriz que seguiremos en relación con la implementación del sistema de órdenes. Primero, necesitamos crear algún tipo de indicación para poder interactuar con el sistema. Segundo, la creación, o mejor dicho, la implementación, no debe hacerse de cualquier manera. Puesto que, si eso ocurre, podremos perder por completo el control sobre los objetos presentes en el gráfico. Tercero, como el indicador que tendremos que implementar añadirá todavía más objetos al gráfico, necesitamos encontrar alguna forma de evitar posibles fallos en la interacción. Ya que, si dos objetos están en el mismo lugar, uno podrá recibir eventos, aunque esté cubierto, solo por tener una prioridad mayor.

Sin embargo, no quiero tener problemas cuando estemos trabajando con más de una orden o posición en el gráfico. Esto se debe a que, si la implementación no se hace correctamente, podrías acabar cerrando algo que querías mantener abierto y dejando abierto algo que querías cerrar. Quiero mostrarte cómo eliminar este tipo de contratiempo. De esta manera, espero que tú, querido lector, realmente estés dispuesto a aprender, porque veremos muchas cosas antes de que el sistema de repetición/simulador quede concluido.

Archivo	Descripción
Experts\Expert Advisor.mq5	Demuestra la interacción entre Chart Trade y el Asesor Experto (es necesario el Mouse Study para la interacción)
Indicators\Chart Trade.mq5	Crea la ventana para configurar la orden a ser enviada (es necesario el Mouse Study para la interacción)
Indicators\Market Replay.mq5	Crea los controles para la interacción con el servicio de repetición/simulador (es necesario el Mouse Study para la interacción)
Indicators\Mouse Study.mq5	Permite la interacción entre los controles gráficos y el usuario (necesario tanto para operar el sistema de repetición/simulador como en el mercado real)
Indicators\Order Indicator.mq5	Responsable de la indicación de órdenes de mercado, permitiendo interactuar con ellas y controlarlas
Indicators\Position View.mq5	Responsable de la indicación de posiciones de mercado, permitiendo interactuar con ellas y controlarlas
Services\Market Replay.mq5	Crea y mantiene el servicio de repetición y simulación de mercado (archivo principal de todo el sistema)