Prueba CGraphic - preguntas y sugerencias - página 4

 
Roman Konopelko:

Incluso si los haces virtuales , no podrás hacer una sobrecarga normal sin acceso completo a los miembros de la clase CGraphics, por lo que todos (la mayoría) deberían ser declarados como protegidos.

y estas funciones ***Plot sólo están protegidas


 
o_O:

y estas funciones ***Plot están igualmente protegidas

class CGraphic
  {
private:
   CArrayObj         m_arr_curves;
   CCanvas           m_canvas;
   //--- parameters background
   int               m_height;
   int               m_width;
   //--- parameters work space
   int               m_left;
   int               m_right;
   int               m_up;
   int               m_down;
   //--- default parameters work space
   int               m_left0;
   int               m_right0;
   int               m_up0;
   int               m_down0;
   //--- size of dash on the axes
   int               m_mark_size;
   //--- scaling parameters
   double            m_dx;
   double            m_dy;
Me refería a los miembros de la clase CGraphic, ahora son todos privados, y sin acceso a m_canvas, m_dx, m_dy y otros miembros en la descendencia, la sobrecarga no funcionará.
 
Roman Konopelko:
Me refería a los miembros de la clase CGraphic, ahora son todos privados, y sin acceso a m_canvas, m_dx, m_dy y otros miembros en la descendencia, la sobrecarga no funcionará.

OK, entonces todo está en tus manos) esperaré.

Hasta ahora, lo he cambiado temporalmente a nivel local

 

En algunas funciones (no en todas) si hay una división, es sin comprobación de 0.

Por ejemplo

void CGraphic::CalculateXAxis(void)
  {
...
...
   double x_size=(m_x.Max()-m_x.Min());
   double xf_size=xf2-xf1;
//--- keep scaling parameters  
   m_dx=xf_size/x_size;

aquí se producirá zero_devide si x.Max() == Min()

también en Axis::CalcStepSize / CalcBoundedStepSize / SelectAxisScale etc.

 
o_O:

En algunas funciones (no en todas) si hay una división, es sin comprobación de 0.

por ejemplo

void CGraphic::CalculateXAxis(void)
  {
...
...
   double x_size=(m_x.Max()-m_x.Min());
   double xf_size=xf2-xf1;
//--- keep scaling parameters  
   m_dx=xf_size/x_size;

zero_devide ocurrirá si x.Max() == Min()

también en Axis::CalcStepSize / CalcBoundedStepSize / SelectAxisScale etc.

Gracias, lo corregiré.

Para no sobrecargar la biblioteca con numerosas comprobaciones, he intentado tener en cuenta todos los casos en el método Axis::SelectAxisScal.

Archivos adjuntos:
Axis.mqh  11 kb
 

1. este parece ser el archivo sin las ediciones de esta mañana en enum ENUM_AXIS_TYPE

---

2. probado ENUM_AXIS_TYPE de la página anterior

ya que estás haciendo ValuesFunctionFormat en estilo de función callback, tienes que devolver algún parámetro void* en la función.

typedef string(*DoubleToStringFunction)(double, void*);

en CAxis para añadir

   DoubleToStringFunction m_values_func;
   void* m_cbdata; // <---

...

// изменить
   void              ValuesFunctionFormat(DoubleToStringFunction func, void* cbdata) { m_values_func=func; m_cbdata=cbdata; }

// добавить получение этого void*
   void* ValuesFunctionFormatCBData(void)    const { return m_c bdata; }


en CGraphic::CalculateXAxis

   DoubleToStringFunction xfunc=m_x.ValuesFunctionFormat();
   void* cbdata=m_x.ValuesFunctionFormatCBData(); // <---

...

         case AXIS_TYPE_CUSTOM:
           {
            m_xvalues[i]=(xfunc==NULL) ? NULL : xfunc(x, cbdata); // <---


----

Este parámetro de devolución de llamada es necesario para pasar un puntero a un objeto que sepa dónde está el array arrX.

Como la función es esencialmente estática, es imposible saber qué la ha llamado exactamente.


ZS.

Y aquí está el resultado de la visualización de las series temporales ya (preguntaré más tarde sobre las líneas con lecturas, hay un inconveniente de conseguir coordenadas allí :)

 
o_O:

Y este es el resultado de la serie de tiempo que ya se ve en principio (luego preguntaré más sobre las líneas con lecturas, ahí está la torpeza de conseguir coordenadas :)

Por favor, haz un vídeo o una animación más larga del momento del gráfico vacío. Por el GIF no entiendo qué es.
 
fxsaber:
Por favor, haz un vídeo o una animación más larga del momento del gráfico vacío. No lo entiendo por el GIF.

¿es mejor?

este experto trabaja en el Lienzo + CGraphic de roma

En este caso estoy construyendo un P/L a partir de varias herramientas en él
 
o_O:

este experto trabaja en Roman's Canvas + CGraphic

En este caso, construyo P/L a partir de varios instrumentos en él

Más claro ahora. ¿Es la retícula (y probablemente otra interactividad) una funcionalidad integrada (necesaria) de la biblioteca de Roman, o la has heredado?

Quiero ver elementos de interactividad en los gráficos de SB: retícula, zoom (en ambas direcciones) y resaltado de los valores del cursor.

Es decir, hago GraphPlot a través de EA/indicador, y obtengo dicha funcionalidad de inmediato.

 
fxsaber:

Ahora para ser más claros. ¿Es la retícula (y posiblemente otra interactividad) una funcionalidad incorporada (necesaria) de la Biblia de Roman, o has añadido la herencia?

Sí, lo he heredado.

Quiero ver algunos elementos de interactividad en los gráficos de SB: retícula, zoom (en ambos sentidos) y resaltado de los valores del cursor.

Tendremos una charla con el principal. Yo también necesito algo.

- Es necesaria la retroiluminación (si no es ella, al menos la función GetNearY/X). De todos modos, es mejor que el resaltado se implemente por herencia. Es diferente en cada una de nuestras representaciones )

- todavía no necesita la retícula en sí, porque es el resultado de los eventos del gráfico que todavía no tienen nada que ver con la biblioteca.

- La obtención de los valores de escala -que se determinan por la coordenada del píxel- es imprescindible.

- Con zoomo es complicado. Como no hay barras de desplazamiento. Y para ser honesto, no me gustaría que se implementaran en esta clase. Ahora mismo sólo utiliza CCanvas y no pide ningún otro objeto. Y esto es muy bueno.
Tengo pensado implementar el zoom de forma independiente por herencia, poner barras de desplazamiento y reescalar cuando sea necesario.