English Русский Português
preview
Tablas en el paradigma MVC en MQL5: Columnas de tabla personalizables y ordenables

Tablas en el paradigma MVC en MQL5: Columnas de tabla personalizables y ordenables

MetaTrader 5 — Ejemplos |
28 3
Artyom Trishkin
Artyom Trishkin

Índice



Introducción

En el artículo anterior, dedicado a la creación de tablas en MQL5 siguiendo el paradigma MVC, unimos los datos de la tabla (Model) con su representación gráfica (View) en un único control (TableView) y, a partir del objeto obtenido, creamos una tabla estática sencilla. Las tablas son una herramienta muy útil para clasificar y presentar diversos datos de una forma que resulte cómoda para el usuario. Por ello, la tabla debería ofrecer al usuario más opciones para gestionar la visualización de los datos.

Hoy añadiremos a las tablas la posibilidad de ajustar el ancho de las columnas, especificar los tipos de datos que se muestran y ordenar los datos de la tabla por sus columnas. Para ello, solo tendremos que modificar ligeramente las clases de controles que ya hemos creado anteriormente. Pero, al final, añadiremos una nueva clase que simplifica la creación de tablas. Esta clase permitirá crear tablas a partir de datos previamente preparados en tan solo unas pocas líneas.

En el paradigma MVC (Model — View — Controller), la interacción entre los tres componentes se organiza de modo que, al modificar el componente visual (View) mediante el controlador (Controller), se modifica el modelo (Model) y, a continuación, el componente visual (View) vuelve a mostrar el modelo modificado. Aquí organizaremos de la misma manera la interacción entre los tres componentes: al hacer clic con el ratón en el encabezado de una columna de la tabla (funcionamiento del componente Controller), se producirá un cambio en la disposición de los datos en el modelo de la tabla (reorganización del componente Model), lo que a su vez provocará un cambio en el aspecto de la tabla: la visualización del resultado por parte del componente View.



Mejoramos las clases de la biblioteca

Todos los archivos de la biblioteca que se está desarrollando se encuentran en la ruta \MQL5\Indicators\Tables\. El archivo de clases del modelo de tablas (Tables.mqh), junto con el archivo del indicador de prueba (iTestTable.mq5), se encuentra en la carpeta \MQL5\Indicators\Tables\.

Los archivos de la biblioteca gráfica (Base.mqh y Controls.mqh) se encuentran en la subcarpeta \MQL5\Indicators\Tables\Controls\. Todos los archivos necesarios para el trabajo se pueden descargar en un único archivo comprimido desde el artículo anterior.

Modificaremos las clases del modelo de tablas en el archivo \MQL5\Indicators\Tables\Tables.mqh.

Las filas del modelo de tabla se ordenan, por defecto, según el identificador (índice) de la fila. La primera fila tiene el índice 0. Y las celdas de la fila también empiezan con el índice cero. Para ordenar por los índices de las celdas, debemos establecer un número determinado que se sumará al índice de la celda y que nos permitirá determinar que se ha especificado la ordenación por el índice de la celda. Además, tenemos que indicar el sentido de la ordenación. Por lo tanto, necesitamos dos números: el primero indicará que hay que realizar una ordenación por el índice de la celda en orden ascendente, y el segundo indicará que hay que realizar una ordenación por el índice de la celda en orden descendente.

Vamos a definir las macros para estos números:

//+------------------------------------------------------------------+
//| Macros                                                          |
//+------------------------------------------------------------------+
#define  __TABLES__                 // Identificador de este archivo
#define  MARKER_START_DATA    -1    // Marcador de inicio de los datos en el archivo
#define  MAX_STRING_LENGTH    128   // Longitud máxima de la cadena en la celda
#define  CELL_WIDTH_IN_CHARS  19    // Ancho de la tabla en caracteres
#define  ASC_IDX_CORRECTION   10000 // Desplazamiento del índice de la columna para la ordenación ascendente
#define  DESC_IDX_CORRECTION  20000 // Desplazamiento del índice de la columna para la ordenación descendente

Al definir estas macros, hemos especificado que no puede haber más de 10 000 filas en la tabla ni más de 10 000 celdas en una misma fila. Parece que eso es más que suficiente para trabajar con tablas (100 millones de celdas).

Al método de ordenación le pasaremos, como parámetro mode, un número de 0 a 10 000; esto indicará una ordenación según los índices de las filas de la tabla. Los números comprendidos entre 10 000 (incluido) y 19 999 indicarán una ordenación por el índice de la columna de la tabla en orden ascendente. Los números a partir de 20 000 indicarán una ordenación por el índice de la columna en orden descendente:

/*
    Sort(0)                      -  según el índice de la fila
    
    Sort(ASC_IDX_CORRECTION)     -  en orden ascendente en la columna 0
    Sort(1+ASC_IDX_CORRECTION)   -  en orden ascendente en la columna 1
    Sort(2+ASC_IDX_CORRECTION)   -  en orden ascendente en la columna 2
    etc
    Sort(DESC_IDX_CORRECTION)    -  en orden descendente en la columna 0
    Sort(1+DESC_IDX_CORRECTION)  -  en orden descendente en la columna 1
    Sort(2+DESC_IDX_CORRECTION)  -  en orden descendente en la columna 2
    etc
*/  

Para que el método de ordenación de listas Sort() funcione correctamente, es necesario redefinir el método virtual Compare(), que compara dos objetos y está definido en el objeto base de la Biblioteca Estándar. Por defecto, este método devuelve 0, lo que significa que los objetos comparados son iguales.

Ya contamos con un método de comparación implementado en la clase de fila de la tabla CTableRow. Lo modificaremos para que sea posible ordenar las filas según los índices de las columnas de la tabla, teniendo en cuenta el sentido de la ordenación:

//+------------------------------------------------------------------+
//| Comparación de dos objetos                                       |
//+------------------------------------------------------------------+
int CTableRow::Compare(const CObject *node,const int mode=0) const
  {
   if(node==NULL)
      return -1;
   
//--- Ordenación por índice de fila
   if(mode==0)
     {
      const CTableRow *obj=node;
      return(this.Index()>obj.Index() ? 1 : this.Index()<obj.Index() ? -1 : 0);
     }
   
//--- Ordenación por índice de celda, de menor a mayor o de mayor a menor
//--- Indicador de la dirección de ordenación e índice de la celda para la ordenación
   bool asc=(mode>=ASC_IDX_CORRECTION && mode<DESC_IDX_CORRECTION);
   int  col= mode%(asc ? ASC_IDX_CORRECTION : DESC_IDX_CORRECTION);
      
//--- Eliminamos el carácter constante de node
   CTableRow *nonconst_this=(CTableRow*)&this;
   CTableRow *nonconst_node=(CTableRow*)node;

//--- Obtenemos la celda actual y la celda con la que se va a comparar mediante el índice «mode»
   CTableCell *cell_current =nonconst_this.GetCell(col);
   CTableCell *cell_compared=nonconst_node.GetCell(col);
   if(cell_current==NULL || cell_compared==NULL)
      return -1;
   
//--- Comparamos en función del tipo de celda
   int cmp=0;
   switch(cell_current.Datatype())
     {
      case TYPE_DOUBLE  :  cmp=(cell_current.ValueD()>cell_compared.ValueD() ? 1 : cell_current.ValueD()<cell_compared.ValueD() ? -1 : 0); break;
      case TYPE_LONG    :
      case TYPE_DATETIME:
      case TYPE_COLOR   :  cmp=(cell_current.ValueL()>cell_compared.ValueL() ? 1 : cell_current.ValueL()<cell_compared.ValueL() ? -1 : 0); break;
      case TYPE_STRING  :  cmp=::StringCompare(cell_current.ValueS(),cell_compared.ValueS());                                              break;
      default           :  break;
     }
//--- Devolvemos el resultado de la comparación de celdas teniendo en cuenta la dirección de ordenación
   return(asc ? cmp : -cmp);   
  }

El bloque de código resaltado en color compara dos celdas de la tabla en orden ascendente (mode >= 10000 && <20000) y descendente (mode>=20000). Como, para realizar la comparación, necesitamos obtener del objeto de fila los objetos de celda correspondientes y estos no son constantes (mientras que la fila que se va a comparar se pasa al método como un puntero constante), primero es necesario eliminar el carácter constante de *node, declarando objetos no constantes para la comparación. Y, a partir de ellos, obtener los objetos de celda para la comparación.

Se trata de conversiones peligrosas, ya que se elimina el carácter constante de los punteros y los objetos pueden modificarse accidentalmente. Pero aquí sabemos con certeza que este método solo compara los valores, sin modificarlos. Por eso, en este caso podemos permitirnos una pequeña libertad controlada para obtener el resultado deseado.

Añadiremos tres nuevos métodos a la clase del modelo de tabla CTableModel para facilitar el trabajo con las columnas de la tabla y la ordenación por dichas columnas:

public:
//--- Crea una nueva fila y (1) la añade al final de la lista, (2) la inserta en la posición indicada de la lista
   CTableRow        *RowAddNew(void);
   CTableRow        *RowInsertNewTo(const uint index_to);
//--- (1) Elimina, (2) desplaza una fila y (3) borra los datos de una fila
   bool              RowDelete(const uint index);
   bool              RowMoveTo(const uint row_index, const uint index_to);
   void              RowClearData(const uint index);
//--- (1) Devuelve, (2) muestra en el registro la descripción de la fila
   string            RowDescription(const uint index);
   void              RowPrint(const uint index,const bool detail);
   
//--- (1) Añade, (2) elimina, (3) mueve una columna, (4) borra los datos, establece (5) el tipo,
//--- (6) la precisión de los datos y los indicadores de visualización (7) de la hora y (8) de los nombres de colores de la columna
   bool              ColumnAddNew(const int index=-1);
   bool              ColumnDelete(const uint index);
   bool              ColumnMoveTo(const uint col_index, const uint index_to);
   void              ColumnClearData(const uint index);
   void              ColumnSetDatatype(const uint index,const ENUM_DATATYPE type);
   void              ColumnSetDigits(const uint index,const int digits);
   void              ColumnSetTimeFlags(const uint index, const uint flags);
   void              ColumnSetColorNamesFlag(const uint index, const bool flag);
  
//--- Ordena la tabla según la columna y la dirección indicadas
   void              SortByColumn(const uint column, const bool descending);
   
//--- (1) Devuelve, (2) muestra en el registro la descripción de la tabla
   virtual string    Description(void);
   void              Print(const bool detail);
   void              PrintTable(const int cell_width=CELL_WIDTH_IN_CHARS);

Escribiremos su implementación fuera del cuerpo de la clase.

Método que establece los indicadores de visualización de la hora de la columna:

//+------------------------------------------------------------------+
//| Establece los indicadores para mostrar la hora de la columna     |
//+------------------------------------------------------------------+
void CTableModel::ColumnSetTimeFlags(const uint index,const uint flags)
  {
//--- En un bucle que recorre todas las filas de la tabla
   for(uint i=0;i<this.RowsTotal();i++)
     {
      //--- obtenemos de cada fila la celda correspondiente al índice de la columna y establecemos los indicadores de visualización de la hora
      CTableCell *cell=this.GetCell(i, index);
      if(cell!=NULL)
         cell.SetDatetimeFlags(flags);
     }
  }

Método que establece el indicador para mostrar los nombres de los colores de la columna:

//+------------------------------------------------------------------+
//| Establece el indicador para mostrar los nombres de los colores de la columna    |
//+------------------------------------------------------------------+
void CTableModel::ColumnSetColorNamesFlag(const uint index,const bool flag)
  {
//--- En un bucle que recorre todas las filas de la tabla
   for(uint i=0;i<this.RowsTotal();i++)
     {
      //--- obtenemos de cada fila la celda correspondiente al índice de la columna y establecemos el indicador para mostrar los nombres de los colores
      CTableCell *cell=this.GetCell(i, index);
      if(cell!=NULL)
         cell.SetColorNameFlag(flag);
     }
  }

Ambos métodos, en un bucle simple que recorre las filas de la tabla, obtienen la celda deseada de cada fila sucesiva y le asignan el indicador especificado.

Método que ordena una tabla según la columna y la dirección indicadas:

//+------------------------------------------------------------------+
//| Ordena la tabla según la columna y la dirección indicadas        |
//+------------------------------------------------------------------+
void CTableModel::SortByColumn(const uint column,const bool descending)
  {
   if(this.m_list_rows.Total()==0)
      return;
   int mode=(int)column+(descending ? DESC_IDX_CORRECTION : ASC_IDX_CORRECTION);
   this.m_list_rows.Sort(mode);
   this.CellsPositionUpdate();   
  }

Al método se le pasan el índice de la columna cuyos valores se utilizarán para ordenar la tabla y el indicador de la dirección de ordenación. Si la lista de filas está vacía, salimos del método. A continuación, definimos el modo de ordenación (mode). Si la ordenación es descendente (descending == true), sumamos 20 000 al índice de la columna; si, por el contrario, la ordenación es ascendente, sumamos 10 000 al índice de la columna. Luego llamamos al método de ordenación indicando el modo y actualizamos todas las celdas de la tabla en cada fila.

Ahora añadiremos nuevos métodos a la clase de tabla CTable. Estos métodos tienen los mismos nombres que los que acabamos de añadir a la clase del modelo de la tabla:

public:
//--- (1) Devuelve, (2) muestra en el registro la descripción de la celda, (3) el objeto asignado a la celda
   string            CellDescription(const uint row, const uint col);
   void              CellPrint(const uint row, const uint col);
//---Devuelve (1) el objeto asignado a la celda y (2) el tipo del objeto asignado a la celda
   CObject          *CellGetObject(const uint row, const uint col);
   ENUM_OBJECT_TYPE  CellGetObjType(const uint row, const uint col);
   
//--- Crea una nueva fila y (1) la añade al final de la lista, (2) la inserta en la posición indicada de la lista
   CTableRow        *RowAddNew(void);
   CTableRow        *RowInsertNewTo(const uint index_to);
//--- (1) Elimina, (2) desplaza una fila y (3) borra los datos de una fila
   bool              RowDelete(const uint index);
   bool              RowMoveTo(const uint row_index, const uint index_to);
   void              RowClearData(const uint index);
//--- (1) Devuelve, (2) muestra en el registro la descripción de la fila
   string            RowDescription(const uint index);
   void              RowPrint(const uint index,const bool detail);
   
//--- (1) Añade una nueva columna, (2) elimina una columna, (3) desplaza una columna, (4) borra los datos de una columna
   bool              ColumnAddNew(const string caption,const int index=-1);
   bool              ColumnDelete(const uint index);
   bool              ColumnMoveTo(const uint index, const uint index_to);
   void              ColumnClearData(const uint index);
   
//--- Establece (1) el valor del encabezado indicado, (2) la precisión de los datos,
//--- indicadores de visualización (3) de la hora, (4) de los nombres de los colores en la columna indicada
   void              ColumnCaptionSetValue(const uint index,const string value);
   void              ColumnSetDigits(const uint index,const int digits);
   void              ColumnSetTimeFlags(const uint index,const uint flags);
   void              ColumnSetColorNamesFlag(const uint col, const bool flag);
   
//--- (1) Establece, (2) devuelve el tipo de datos de la columna indicada
   void              ColumnSetDatatype(const uint index,const ENUM_DATATYPE type);
   ENUM_DATATYPE     ColumnDatatype(const uint index);
   
//--- (1) Devuelve, (2) muestra en el registro la descripción del objeto
   virtual string    Description(void);
   void              Print(const int column_width=CELL_WIDTH_IN_CHARS);
  
//--- Ordena la tabla según la columna y la dirección indicadas
   void              SortByColumn(const uint column, const bool descending)
                       {
                        if(this.m_table_model!=NULL)
                           this.m_table_model.SortByColumn(column,descending);
                       }
   
//--- Métodos virtuales: (1) comparación, (2) guardado en un archivo, (3) carga desde un archivo, (4) tipo de objeto
   virtual int       Compare(const CObject *node,const int mode=0) const;
   virtual bool      Save(const int file_handle);
   virtual bool      Load(const int file_handle);
   virtual int       Type(void)                             const { return(OBJECT_TYPE_TABLE);           }

...

//+------------------------------------------------------------------+
//| Establece los indicadores para mostrar la hora en la columna especificada       |
//+------------------------------------------------------------------+
void CTable::ColumnSetTimeFlags(const uint index,const uint flags)
  {
   if(this.m_table_model!=NULL)
      this.m_table_model.ColumnSetTimeFlags(index,flags);
  }
//+------------------------------------------------------------------+
//| Establece los indicadores para mostrar los nombres de los colores en la columna especificada    |
//+------------------------------------------------------------------+
void CTable::ColumnSetColorNamesFlag(const uint index,const bool flag)
  {
   if(this.m_table_model!=NULL)
      this.m_table_model.ColumnSetColorNamesFlag(index,flag);
  }

Los métodos comprueban la validez del objeto del modelo de tabla y llaman a los métodos correspondientes del mismo nombre, que se han descrito anteriormente.

Vamos a modificar las clases del archivo \MQL5\Indicators\Tables\Controls\Base.mqh.

Añadiremos las declaraciones anticipadas de las clases que creamos la última vez, pero que no se añadieron a la lista, así como la de la nueva clase que vamos a crear hoy:

//+------------------------------------------------------------------+
//| Bibliotecas incluidas                                            |
//+------------------------------------------------------------------+
#include <Canvas\Canvas.mqh>              // Clase CB CCanvas
#include <Arrays\List.mqh>                // Clase CB CList
#include "..\Tables.mqh"

//--- Declaración anticipada de las clases de los controles
class    CBoundedObj;                     // Clase base que almacena las dimensiones del objeto
class    CCanvasBase;                     // Clase base del lienzo de elementos gráficos
class    CCounter;                        // Clase del contador de retardo
class    CAutoRepeat;                     // Clase de repetición automática de eventos
class    CImagePainter;                   // Clase de dibujo de imágenes
class    CVisualHint;                     // Clase de sugerencia
class    CLabel;                          // Clase de etiqueta de texto
class    CButton;                         // Clase de botón simple
class    CButtonTriggered;                // Clase de botón de dos posiciones
class    CButtonArrowUp;                  // Clase del botón con la flecha hacia arriba
class    CButtonArrowDown;                // Clase del botón con la flecha hacia abajo
class    CButtonArrowLeft;                // Clase del botón con la flecha hacia la izquierda
class    CButtonArrowRight;               // Clase del botón con la flecha hacia la derecha
class    CCheckBox;                       // Clase del control CheckBox
class    CRadioButton;                    // Clase del control RadioButton
class    CScrollBarThumbH;                // Clase del control deslizante de la barra de desplazamiento horizontal
class    CScrollBarThumbV;                // Clase del control deslizante de la barra de desplazamiento vertical
class    CScrollBarH;                     // Clase de barra de desplazamiento horizontal
class    CScrollBarV;                     // Clase de barra de desplazamiento vertical
class    CTableCellView;                  // Clase de representación visual de una celda de tabla
class    CTableRowView;                   // Clase de representación visual de una fila de una tabla
class    CColumnCaptionView;              // Clase de representación visual del encabezado de una columna de la tabla
class    CTableHeaderView;                // Clase de representación visual del encabezado de la tabla
class    CTableView;                      // Clase de representación visual de una tabla
class    CTableControl;                   // Clase de gestión de tablas
class    CPanel;                          // Clase del control «Panel»
class    CGroupBox;                       // Clase del control GroupBox
class    CContainer;                      // Clase del control Container

Añadiremos un nuevo tipo a la enumeración de tipos de elementos gráficos:

//+------------------------------------------------------------------+
//| Enumeraciones                                                    |
//+------------------------------------------------------------------+
enum ENUM_ELEMENT_TYPE                    // Enumeración de los tipos de elementos gráficos
  {
   ELEMENT_TYPE_BASE = 0x10000,           // Objeto base de los elementos gráficos
   ELEMENT_TYPE_COLOR,                    // Objeto de color
   ELEMENT_TYPE_COLORS_ELEMENT,           // Objeto de colores de un elemento del objeto gráfico
   ELEMENT_TYPE_RECTANGLE_AREA,           // Área rectangular del elemento
   ELEMENT_TYPE_IMAGE_PAINTER,            // Objeto para dibujar imágenes
   ELEMENT_TYPE_COUNTER,                  // Objeto del contador
   ELEMENT_TYPE_AUTOREPEAT_CONTROL,       // Objeto de repetición automática de eventos
   ELEMENT_TYPE_BOUNDED_BASE,             // Objeto base de las dimensiones de los elementos gráficos
   ELEMENT_TYPE_CANVAS_BASE,              // Objeto base del lienzo de elementos gráficos
   ELEMENT_TYPE_ELEMENT_BASE,             // Objeto base de los elementos gráficos
   ELEMENT_TYPE_HINT,                     // Sugerencia
   ELEMENT_TYPE_LABEL,                    // Etiqueta de texto
   ELEMENT_TYPE_BUTTON,                   // Botón sencillo
   ELEMENT_TYPE_BUTTON_TRIGGERED,         // Botón de dos posiciones
   ELEMENT_TYPE_BUTTON_ARROW_UP,          // Botón con una flecha hacia arriba
   ELEMENT_TYPE_BUTTON_ARROW_DOWN,        // Botón con una flecha hacia abajo
   ELEMENT_TYPE_BUTTON_ARROW_LEFT,        // Botón con una flecha hacia la izquierda
   ELEMENT_TYPE_BUTTON_ARROW_RIGHT,       // Botón con una flecha hacia la derecha
   ELEMENT_TYPE_CHECKBOX,                 // Control CheckBox
   ELEMENT_TYPE_RADIOBUTTON,              // Control RadioButton
   ELEMENT_TYPE_SCROLLBAR_THUMB_H,        // Control deslizante de la barra de desplazamiento horizontal
   ELEMENT_TYPE_SCROLLBAR_THUMB_V,        // Control deslizante de la barra de desplazamiento vertical
   ELEMENT_TYPE_SCROLLBAR_H,              // Control ScrollBarHorisontal
   ELEMENT_TYPE_SCROLLBAR_V,              // Control ScrollBarVertical
   ELEMENT_TYPE_TABLE_CELL_VIEW,          // Celda de la tabla (Vista)
   ELEMENT_TYPE_TABLE_ROW_VIEW,           // Fila de una tabla (Vista)
   ELEMENT_TYPE_TABLE_COLUMN_CAPTION_VIEW,// Encabezado de columna de la tabla (Vista)
   ELEMENT_TYPE_TABLE_HEADER_VIEW,        // Encabezado de la tabla (Vista)
   ELEMENT_TYPE_TABLE_VIEW,               // Tabla (Vista)
   ELEMENT_TYPE_TABLE_CONTROL_VIEW,       // Control de tablas (Vista)
   ELEMENT_TYPE_PANEL,                    // Control Panel
   ELEMENT_TYPE_GROUPBOX,                 // Control GroupBox
   ELEMENT_TYPE_CONTAINER,                // Control Container
  };

Ahora añadiremos un nuevo tipo de objeto a la función que devuelve el nombre abreviado de un elemento según su tipo:

//+------------------------------------------------------------------+
//|  Devuelve el nombre corto del elemento según su tipo             |
//+------------------------------------------------------------------+
string ElementShortName(const ENUM_ELEMENT_TYPE type)
  {
   switch(type)
     {
      case ELEMENT_TYPE_ELEMENT_BASE               :  return "BASE";    // Objeto base de los elementos gráficos
      case ELEMENT_TYPE_HINT                       :  return "HNT";     // Sugerencia
      case ELEMENT_TYPE_LABEL                      :  return "LBL";     // Etiqueta de texto
      case ELEMENT_TYPE_BUTTON                     :  return "SBTN";    // Botón sencillo
      case ELEMENT_TYPE_BUTTON_TRIGGERED           :  return "TBTN";    // Botón de dos posiciones
      case ELEMENT_TYPE_BUTTON_ARROW_UP            :  return "BTARU";   // Botón con una flecha hacia arriba
      case ELEMENT_TYPE_BUTTON_ARROW_DOWN          :  return "BTARD";   // Botón con una flecha hacia abajo
      case ELEMENT_TYPE_BUTTON_ARROW_LEFT          :  return "BTARL";   // Botón con una flecha hacia la izquierda
      case ELEMENT_TYPE_BUTTON_ARROW_RIGHT         :  return "BTARR";   // Botón con una flecha hacia la derecha
      case ELEMENT_TYPE_CHECKBOX                   :  return "CHKB";    // Control CheckBox
      case ELEMENT_TYPE_RADIOBUTTON                :  return "RBTN";    // Control RadioButton
      case ELEMENT_TYPE_SCROLLBAR_THUMB_H          :  return "THMBH";   // Control deslizante de la barra de desplazamiento horizontal
      case ELEMENT_TYPE_SCROLLBAR_THUMB_V          :  return "THMBV";   // Control deslizante de la barra de desplazamiento vertical
      case ELEMENT_TYPE_SCROLLBAR_H                :  return "SCBH";    // Control ScrollBarHorisontal
      case ELEMENT_TYPE_SCROLLBAR_V                :  return "SCBV";    // Control ScrollBarVertical
      case ELEMENT_TYPE_TABLE_CELL_VIEW            :  return "TCELL";   // Celda de la tabla (Vista)
      case ELEMENT_TYPE_TABLE_ROW_VIEW             :  return "TROW";    // Fila de una tabla (Vista)
      case ELEMENT_TYPE_TABLE_COLUMN_CAPTION_VIEW  :  return "TCAPT";   // Encabezado de columna de la tabla (Vista)
      case ELEMENT_TYPE_TABLE_HEADER_VIEW          :  return "THDR";    // Encabezado de la tabla (Vista)
      case ELEMENT_TYPE_TABLE_VIEW                 :  return "TABLE";   // Tabla (Vista)
      case ELEMENT_TYPE_TABLE_CONTROL_VIEW         :  return "TBLCTRL"; // Control de tablas (Vista)
      case ELEMENT_TYPE_PANEL                      :  return "PNL";     // Control Panel
      case ELEMENT_TYPE_GROUPBOX                   :  return "GRBX";    // Control GroupBox
      case ELEMENT_TYPE_CONTAINER                  :  return "CNTR";    // Control Container
      default                                      :  return "Unknown"; // Desconocido
     }
  }

Añadiremos a la clase base de elementos gráficos unos métodos que devuelvan las coordenadas del cursor:

//+------------------------------------------------------------------+
//| Clase base de los elementos gráficos                             |
//+------------------------------------------------------------------+
class CBaseObj : public CObject
  {
protected:
   int               m_id;                                     // Identificador
   ushort            m_name[];                                 // Denominación
   
public:
//--- Establece (1) el nombre y (2) el identificador
   void              SetName(const string name)                { ::StringToShortArray(name,this.m_name);          }
   virtual void      SetID(const int id)                       { this.m_id=id;                                    }
//--- Devuelve (1) el nombre y (2) el identificador
   string            Name(void)                          const { return ::ShortArrayToString(this.m_name);        }
   int               ID(void)                            const { return this.m_id;                                }

//--- Devuelve las coordenadas del cursor
   int               CursorX(void)                       const { return CCommonManager::GetInstance().CursorX();  }
   int               CursorY(void)                       const { return CCommonManager::GetInstance().CursorY();  }

//--- Métodos virtuales: (1) comparación, (2) guardado en un archivo, (3) carga desde un archivo, (4) tipo de objeto
   virtual int       Compare(const CObject *node,const int mode=0) const;
   virtual bool      Save(const int file_handle);
   virtual bool      Load(const int file_handle);
   virtual int       Type(void)                          const { return(ELEMENT_TYPE_BASE); }
   
//--- (1) Devuelve, (2) muestra en el registro la descripción del objeto
   virtual string    Description(void);
   virtual void      Print(void);
   
//--- Constructor/destructor
                     CBaseObj (void) : m_id(-1) { this.SetName(""); }
                    ~CBaseObj (void) {}
  };

Esto permitirá que cada elemento gráfico pueda acceder en cualquier momento a las coordenadas del cursor. La clase singleton CCommonManager realiza un seguimiento constante de las coordenadas del cursor, y al acceder a ella desde cualquier elemento gráfico, este obtiene acceso a dichas coordenadas.

En la clase de área rectangular, añadiremos un método que anule la asignación de un objeto al área:

//+------------------------------------------------------------------+
//| Clase de área rectangular                                        |
//+------------------------------------------------------------------+
class CBound : public CBaseObj
  {
protected:
   CBaseObj         *m_assigned_obj;                           // Objeto asignado a un área
   CRect             m_bound;                                  // Estructura de un área rectangular

public:
//--- Modifica (1) el ancho, (2) la altura y (3) el tamaño del rectángulo delimitador
   void              ResizeW(const int size)                   { this.m_bound.Width(size);                                    }
   void              ResizeH(const int size)                   { this.m_bound.Height(size);                                   }
   void              Resize(const int w,const int h)           { this.m_bound.Width(w); this.m_bound.Height(h);               }
   
//--- Establece (1) la coordenada X, (2) la coordenada Y y (3) ambas coordenadas del rectángulo delimitador
   void              SetX(const int x)                         { this.m_bound.left=x;                                         }
   void              SetY(const int y)                         { this.m_bound.top=y;                                          }
   void              SetXY(const int x,const int y)            { this.m_bound.LeftTop(x,y);                                   }
   
//--- (1) Sitúa el rectángulo delimitador en las coordenadas indicadas o (2) lo mueve según el desplazamiento especificado
   void              Move(const int x,const int y)             { this.m_bound.Move(x,y);                                      }
   void              Shift(const int dx,const int dy)          { this.m_bound.Shift(dx,dy);                                   }
   
//--- Devuelve las coordenadas, las dimensiones y los límites del objeto
   int               X(void)                             const { return this.m_bound.left;                                    }
   int               Y(void)                             const { return this.m_bound.top;                                     }
   int               Width(void)                         const { return this.m_bound.Width();                                 }
   int               Height(void)                        const { return this.m_bound.Height();                                }
   int               Right(void)                         const { return this.m_bound.right-(this.m_bound.Width()  >0 ? 1 : 0);}
   int               Bottom(void)                        const { return this.m_bound.bottom-(this.m_bound.Height()>0 ? 1 : 0);}

//--- Devuelve un indicador que señala si el cursor se encuentra dentro del área
   bool              Contains(const int x,const int y)   const { return this.m_bound.Contains(x,y);                           }
   
//--- (1) Asigna, (2) desasigna, (3) devuelve un puntero al elemento asignado
   void              AssignObject(CBaseObj *obj)               { this.m_assigned_obj=obj;                                     }
   void              UnassignObject(void)                      { this.m_assigned_obj=NULL;                                    }           
   CBaseObj         *GetAssignedObj(void)                      { return this.m_assigned_obj;                                  }
   
//--- Devuelve la descripción del objeto
   virtual string    Description(void);
   
//--- Métodos virtuales: (1) comparación, (2) guardado en un archivo, (3) carga desde un archivo, (4) tipo de objeto
   virtual int       Compare(const CObject *node,const int mode=0) const;
   virtual bool      Save(const int file_handle);
   virtual bool      Load(const int file_handle);
   virtual int       Type(void)                          const { return(ELEMENT_TYPE_RECTANGLE_AREA);                         }
   
//--- Constructores/destructor
                     CBound(void) { ::ZeroMemory(this.m_bound); }
                     CBound(const int x,const int y,const int w,const int h) { this.SetXY(x,y); this.Resize(w,h);             }
                    ~CBound(void) { ::ZeroMemory(this.m_bound); }
  };

Si se elimina mediante código un elemento gráfico asignado a un área de otro elemento gráfico, su puntero seguirá registrado para dicha área. Si se accede al elemento mediante este puntero, el programa finalizará con un error crítico. Por lo tanto, al eliminar cualquier objeto, es necesario desvincularlo del área si estaba vinculado a ella. Asignar el valor NULL al puntero nos permitirá comprobar la validez del puntero a un elemento gráfico ya eliminado.

Las clases de elementos gráficos de la biblioteca que se está desarrollando están diseñadas de tal forma que, si un objeto está vinculado a un contenedor, cuando el elemento se sale de los límites de dicho contenedor, se recorta según los bordes de este. Si el elemento se encuentra completamente fuera del contenedor, simplemente se oculta. Sin embargo, si se da al contenedor la orden de pasar al primer plano, este también lleva automáticamente al primer plano, mediante un bucle, todos los elementos vinculados a él. Por consiguiente, los elementos ocultos pasan a ser visibles, ya que llevar un objeto al primer plano consiste en ejecutar sucesivamente dos comandos: ocultar y mostrar. Para evitar que los elementos ocultos pasen al primer plano, hay que añadir a las propiedades del elemento gráfico un indicador que señale que está oculto por encontrarse fuera de su contenedor. Además, hay que comprobar este indicador en el método que lleva el objeto al primer plano.

En la clase base del lienzo de elementos gráficos, `CCanvasBase`, declararemos el siguiente indicador en la sección protegida:

protected:
   CCanvas          *m_background;                             // Lienzo para dibujar el fondo
   CCanvas          *m_foreground;                             // Lienzo para dibujar el primer plano
   CCanvasBase      *m_container;                              // Objeto contenedor padre
   CColorElement     m_color_background;                       // Objeto de control del color de fondo
   CColorElement     m_color_foreground;                       // Objeto de control del color del primer plano
   CColorElement     m_color_border;                           // Objeto de control del color del borde
   
   CColorElement     m_color_background_act;                   // Objeto de control del color de fondo del elemento activado
   CColorElement     m_color_foreground_act;                   // Objeto de control del color del primer plano del elemento activado
   CColorElement     m_color_border_act;                       // Objeto de control del color del borde del elemento activado
   
   CAutoRepeat       m_autorepeat;                             // Objeto de gestión de repeticiones automáticas de eventos
   
   ENUM_ELEMENT_STATE m_state;                                 // Estado del elemento (por ejemplo, un botón (encendido/apagado))
   long              m_chart_id;                               // Identificador del gráfico
   int               m_wnd;                                    // Número de subventana del gráfico
   int               m_wnd_y;                                  // Desplazamiento de la coordenada Y del cursor en la subventana
   int               m_obj_x;                                  // Coordenada X de un objeto gráfico
   int               m_obj_y;                                  // Coordenada Y de un objeto gráfico
   uchar             m_alpha_bg;                               // Transparencia del fondo
   uchar             m_alpha_fg;                               // Transparencia del primer plano
   uint              m_border_width_lt;                        // Ancho del borde izquierdo
   uint              m_border_width_rt;                        // Ancho del borde derecho
   uint              m_border_width_up;                        // Ancho del borde superior
   uint              m_border_width_dn;                        // Ancho del borde inferior
   string            m_program_name;                           // Nombre del programa
   bool              m_hidden;                                 // Indicador de objeto oculto
   bool              m_blocked;                                // Indicador de elemento bloqueado
   bool              m_movable;                                // Indicador de elemento desplazable
   bool              m_resizable;                              // Indicador de permiso para cambiar el tamaño
   bool              m_focused;                                // Indicador de elemento con el foco
   bool              m_main;                                   // Indicador del objeto principal
   bool              m_autorepeat_flag;                        // Indicador de repetición automática del envío de eventos
   bool              m_scroll_flag;                            // Indicador de desplazamiento del contenido mediante barras de desplazamiento
   bool              m_trim_flag;                              // Indicador de recorte del elemento según los límites del contenedor
   bool              m_cropped;                                // Indicador de que el objeto está oculto fuera de los límites del contenedor
   int               m_cursor_delta_x;                         // Distancia entre el cursor y el borde izquierdo del elemento
   int               m_cursor_delta_y;                         // Distancia entre el cursor y el borde superior del elemento
   int               m_z_order;                                // Orden Z de un objeto gráfico

En la sección pública, escribiremos un método que devuelve este indicador:

public:
//--- (1) Establece, (2) devuelve el estado
   void              SetState(ENUM_ELEMENT_STATE state)        { this.m_state=state; this.ColorsToDefault();                                       }
   ENUM_ELEMENT_STATE State(void)                        const { return this.m_state;                                                              }

//--- (1) Establece, (2) devuelve el orden Z
   bool              ObjectSetZOrder(const int value);
   int               ObjectZOrder(void)                  const { return this.m_z_order;                                                            }
   
//--- Devuelve (1) si el objeto pertenece al programa, el indicador (2) de si está oculto, (3) de si está bloqueado,
//--- (4) de si se puede mover, (5) de si se puede redimensionar, (6) de si es el elemento principal, (7) de si tiene el foco, (8, 9) el nombre del objeto gráfico (fondo, texto)
   bool              IsBelongsToThis(const string name)  const { return(::ObjectGetString(this.m_chart_id,name,OBJPROP_TEXT)==this.m_program_name);}
   bool              IsHidden(void)                      const { return this.m_hidden;                                                             }
   bool              IsBlocked(void)                     const { return this.m_blocked;                                                            }
   bool              IsMovable(void)                     const { return this.m_movable;                                                            }
   bool              IsResizable(void)                   const { return this.m_resizable;                                                          }
   bool              IsMain(void)                        const { return this.m_main;                                                               }
   bool              IsFocused(void)                     const { return this.m_focused;                                                            }
   bool              IsAutorepeat(void)                  const { return this.m_autorepeat_flag;                                                    }
   bool              IsScrollable(void)                  const { return this.m_scroll_flag;                                                        }
   bool              IsTrimmed(void)                     const { return this.m_trim_flag;                                                          }
   bool              IsCropped(void)                     const { return this.m_cropped;                                                            }
   string            NameBG(void)                        const { return this.m_background.ChartObjectName();                                       }
   string            NameFG(void)                        const { return this.m_foreground.ChartObjectName();                                       }

un método que establece un indicador y un método virtual que devuelve un indicador que señala que el elemento se encuentra completamente fuera de su contenedor:

//--- Devolución de los límites del objeto teniendo en cuenta el borde
   int               LimitLeft(void)                     const { return this.ObjectX()+(int)this.m_border_width_lt;                                }
   int               LimitRight(void)                    const { return this.ObjectRight()-(int)this.m_border_width_rt;                            }
   int               LimitTop(void)                      const { return this.ObjectY()+(int)this.m_border_width_up;                                }
   int               LimitBottom(void)                   const { return this.ObjectBottom()-(int)this.m_border_width_dn;                           }
   
//--- Establece en el objeto los indicadores (1) de movilidad, (2) de objeto principal, (3) de posibilidad de cambiar de tamaño,
//--- (4) repetición automática de eventos, (5) desplazamiento dentro del contenedor, (6) recorte según los límites del contenedor
   void              SetMovable(const bool flag)               { this.m_movable=flag;                                                              }
   void              SetAsMain(void)                           { this.m_main=true;                                                                 }
   virtual void      SetResizable(const bool flag)             { this.m_resizable=flag;                                                            }
   void              SetAutorepeat(const bool flag)            { this.m_autorepeat_flag=flag;                                                      }
   void              SetScrollable(const bool flag)            { this.m_scroll_flag=flag;                                                          }
   virtual void      SetTrimmered(const bool flag)             { this.m_trim_flag=flag;                                                            }
   void              SetCropped(const bool flag)               { this.m_cropped=flag;                                                              }
   
//--- Devuelve un indicador que señala que el objeto se encuentra fuera de su contenedor
   virtual bool      IsOutOfContainer(void);
//--- Limita el tamaño del objeto gráfico al del contenedor
   virtual bool      ObjectTrim(void);

Implementación de un método que devuelve un indicador que señala que el objeto se encuentra fuera de su contenedor:

//+------------------------------------------------------------------+
//| CCanvasBase::Devuelve un indicador de que el objeto              |
//| se encuentra fuera de su contenedor                              |
//+------------------------------------------------------------------+
bool CCanvasBase::IsOutOfContainer(void)
  {
//--- Devolvemos el resultado de comprobar si el objeto está completamente fuera de los límites del contenedor
   return(this.Right() <= this.ContainerLimitLeft() || this.X() >= this.ContainerLimitRight() ||
          this.Bottom()<= this.ContainerLimitTop()  || this.Y() >= this.ContainerLimitBottom());
  }

Este método comprueba las coordenadas de los límites del objeto con respecto a los límites del contenedor y devuelve un indicador que señala que el elemento se encuentra completamente fuera de su contenedor. En el caso de algunos elementos gráficos, este método puede realizar el cálculo de otra forma. Por eso, el método se ha declarado virtual.

En el método que recorta el objeto gráfico siguiendo el contorno del contenedor, gestionaremos un nuevo indicador:

//+------------------------------------------------------------------+
//| CCanvasBase::Recorta el objeto gráfico según el contorno del contenedor  |
//+------------------------------------------------------------------+
bool CCanvasBase::ObjectTrim()
  {
//--- Comprobamos el indicador de permiso de recorte del elemento y,
//--- si el elemento no debe recortarse según los límites del contenedor, devolvemos «false»
   if(!this.m_trim_flag)
      return false;
//--- Obtenemos los límites del contenedor
   int container_left   = this.ContainerLimitLeft();
   int container_right  = this.ContainerLimitRight();
   int container_top    = this.ContainerLimitTop();
   int container_bottom = this.ContainerLimitBottom();
   
//--- Obtenemos los límites actuales del objeto
   int object_left   = this.X();
   int object_right  = this.Right();
   int object_top    = this.Y();
   int object_bottom = this.Bottom();

//--- Comprobamos si el objeto se sale por completo del contorno del contenedor, y si es así, lo ocultamos
   if(this.IsOutOfContainer())
     {
      //--- Activamos el indicador de que el objeto se encuentra fuera del contenedor
      this.m_cropped=true;
      //--- Ocultamos el objeto y restauramos sus dimensiones
      this.Hide(false);
      if(this.ObjectResize(this.Width(),this.Height()))
         this.BoundResize(this.Width(),this.Height());
      return true;
     }
//--- El objeto se encuentra total o parcialmente dentro del área visible del contenedor
   else
     {
      //--- Desactivamos el indicador de que el objeto se encuentra fuera del contenedor
      this.m_cropped=false;
      //--- Si el elemento se encuentra completamente dentro del contenedor
      if(object_right<=container_right && object_left>=container_left &&
         object_bottom<=container_bottom && object_top>=container_top)
        {
         //--- Si el ancho o la altura de un objeto gráfico no coincide con el ancho o la altura del elemento,
         //--- modificamos el objeto gráfico según las dimensiones del elemento y devolvemos «true»
         if(this.ObjectWidth()!=this.Width() || this.ObjectHeight()!=this.Height())
           {
            if(this.ObjectResize(this.Width(),this.Height()))
               return true;
           }
        }
      //--- Si el elemento se encuentra parcialmente dentro del área visible del contenedor
      else
        {
         //--- Si el elemento se encuentra completamente dentro del área visible del contenedor en sentido vertical
         if(object_bottom<=container_bottom && object_top>=container_top)
           {
            //--- Si la altura del objeto gráfico no coincide con la altura del elemento,
            //--- Ajustamos la altura del objeto gráfico a la del elemento
            if(this.ObjectHeight()!=this.Height())
               this.ObjectResizeH(this.Height());
           }
         else
           {
            //--- Si el elemento se encuentra completamente dentro del área visible del contenedor en sentido horizontal
            if(object_right<=container_right && object_left>=container_left)
              {
               //--- Si el ancho del objeto gráfico no coincide con el ancho del elemento,
               //--- Ajustamos el ancho del objeto gráfico a la del elemento
               if(this.ObjectWidth()!=this.Width())
                  this.ObjectResizeW(this.Width());
              }
           }
        }
     }
     
//--- Comprobamos si el objeto se sale del contenedor en sentido horizontal y vertical
   bool modified_horizontal=false;     // Indicador de cambios en horizontal
   bool modified_vertical  =false;     // Indicador de cambios en vertical
   
//--- Recorte horizontal
   int new_left = object_left;
   int new_width = this.Width();
//--- Si el objeto sobresale por el borde izquierdo del contenedor
   if(object_left<=container_left)
     {
      int crop_left=container_left-object_left;
      new_left=container_left;
      new_width-=crop_left;
      modified_horizontal=true;
     }
//--- Si el objeto sobresale por el borde derecho del contenedor
   if(object_right>=container_right)
     {
      int crop_right=object_right-container_right;
      new_width-=crop_right;
      modified_horizontal=true;
     }
//--- Si ha habido cambios en la dirección horizontal
   if(modified_horizontal)
     {
      this.ObjectSetX(new_left);
      this.ObjectResizeW(new_width);
     }

//--- Recorte vertical
   int new_top=object_top;
   int new_height=this.Height();
//--- Si el objeto sobresale por el borde superior del contenedor
   if(object_top<=container_top)
     {
      int crop_top=container_top-object_top;
      new_top=container_top;
      new_height-=crop_top;
      modified_vertical=true;
     }
//--- Si el objeto sobresale por el borde inferior del contenedor 
   if(object_bottom>=container_bottom)
     {
      int crop_bottom=object_bottom-container_bottom;
      new_height-=crop_bottom;
      modified_vertical=true;
     }
//--- Si se han producido cambios en la dirección vertical
   if(modified_vertical)
     {
      this.ObjectSetY(new_top);
      this.ObjectResizeH(new_height);
     }

//--- Tras los cálculos, el objeto puede estar oculto, pero ahora se encuentra dentro del área del contenedor; lo mostramos.
   this.Show(false);
      
//--- Si se ha modificado el objeto, lo redibujamos
   if(modified_horizontal || modified_vertical)
     {
      this.Update(false);
      this.Draw(false);
      return true;
     }
   return false;
  }

Tras introducir esta modificación, los objetos que se encuentren completamente fuera del contenedor no pasarán al primer plano, por lo que no serán visibles si se envía la orden de llevar ese objeto al primer plano, ni tampoco si se envía directamente la orden de llevar al primer plano todo el contenedor con todo su contenido.

En el método que coloca el objeto en primer plano, comprobamos el indicador que se establece en el método analizado anteriormente:

//+------------------------------------------------------------------+
//| CCanvasBase::Coloca el objeto en primer plano                    |
//+------------------------------------------------------------------+
void CCanvasBase::BringToTop(const bool chart_redraw)
  {
   if(this.m_cropped)
      return;
   this.Hide(false);
   this.Show(chart_redraw);
  }

Si el indicador del objeto está activado, no es necesario llevar el elemento al primer plano; salimos del método.

Cada elemento gráfico cuenta con un manejador común para el desplazamiento con la rueda del ratón. Este manejador común invoca el método virtual de gestión del desplazamiento con la rueda del ratón. En este caso, se pasa a sparam el valor de sparam del manejador común. Esto es un error, ya que, en ese caso, ninguno de los controles puede determinar que la rueda del ratón está girando precisamente sobre él. La solución es la siguiente: en el manejador común conocemos el nombre del elemento activo —aquel sobre el que se encuentra el cursor—, por lo que, al llamar al manejador de desplazamiento con la rueda del ratón, hay que pasar a sparam el nombre del elemento activo. Y, en el propio manejador, comprobar el nombre del elemento y el valor de sparam. Si son iguales, se trata precisamente del objeto sobre el que gira la rueda del ratón. En el manejador común de eventos, escribiremos lo siguiente:

//--- Evento de desplazamiento con la rueda del ratón
   if(id==CHARTEVENT_MOUSE_WHEEL)
     {
      //--- Si se trata del elemento activo, llamamos a su manejador del evento de desplazamiento con la rueda del ratón
      if(this.IsCurrentActiveElement())
         this.OnWheelEvent(id,lparam,dparam,this.ActiveElementName());  // En sparam pasamos el nombre del elemento activo
     }

La comprobación de si el nombre del objeto y el valor de sparam son iguales la realizaremos en el manejador, que se encuentra en otro archivo junto con otras modificaciones.

Vamos a abrir el archivo \MQL5\Indicators\Tables\Controls\Controls.mqh, e introducir algunas modificaciones en él.

Añadiremos nuevas definiciones a la sección de macros:

//+------------------------------------------------------------------+
//| Sustituciones macro                                                 |
//+------------------------------------------------------------------+
#define  DEF_LABEL_W                50          // Ancho de la etiqueta de texto por defecto
#define  DEF_LABEL_H                16          // Altura de la etiqueta de texto por defecto
#define  DEF_BUTTON_W               60          // Ancho del botón por defecto
#define  DEF_BUTTON_H               16          // Altura del botón por defecto
#define  DEF_TABLE_ROW_H            16          // Altura de la fila de la tabla por defecto
#define  DEF_TABLE_HEADER_H         20          // Altura del encabezado de la tabla por defecto
#define  DEF_TABLE_COLUMN_MIN_W     12          // Ancho mínimo de la columna de la tabla
#define  DEF_PANEL_W                80          // Ancho del panel por defecto
#define  DEF_PANEL_H                80          // Altura del panel por defecto
#define  DEF_PANEL_MIN_W            60          // Ancho mínimo del panel
#define  DEF_PANEL_MIN_H            60          // Altura mínima del panel
#define  DEF_SCROLLBAR_TH           13          // Grosor de la barra de desplazamiento por defecto
#define  DEF_THUMB_MIN_SIZE         8           // Grosor mínimo del control deslizante de la barra de desplazamiento
#define  DEF_AUTOREPEAT_DELAY       500         // Retardo antes de comenzar la repetición automática
#define  DEF_AUTOREPEAT_INTERVAL    100         // Frecuencia de las repeticiones automáticas

#define  DEF_HINT_NAME_TOOLTIP      "HintTooltip"     // Nombre de la sugerencia "tooltip"
#define  DEF_HINT_NAME_HORZ         "HintHORZ"        // Nombre de la sugerencia "Flecha doble horizontal"
#define  DEF_HINT_NAME_VERT         "HintVERT"        // Nombre de la sugerencia "Flecha doble vertical"
#define  DEF_HINT_NAME_NWSE         "HintNWSE"        // Nombre de la sugerencia "Flecha doble de arriba a la izquierda" --- abajo a la derecha (NorthWest-SouthEast)
#define  DEF_HINT_NAME_NESW         "HintNESW"        // Nombre de la sugerencia "Flecha doble de abajo a la izquierda" --- arriba a la derecha (NorthEast-SouthWest)
#define  DEF_HINT_NAME_SHIFT_HORZ   "HintShiftHORZ"   // Nombre de la sugerencia "Flecha de desplazamiento horizontal"
#define  DEF_HINT_NAME_SHIFT_VERT   "HintShiftVERT"   // Nomobe de la sugerencia "Flecha de desplazamiento vertical"

El ancho de las columnas de la tabla no puede ser inferior a 12 píxeles, para que, al reducir el tamaño, las columnas no queden demasiado estrechas. Es más cómodo definir los nombres de las sugerencias mediante una directiva del compilador y utilizarlos como nombres, ya que, si es necesario cambiar el nombre de una sugerencia, solo hay que modificar la directiva y no hace falta buscar y cambiar todas las apariciones de ese nombre en las distintas partes del código. Ya tenemos dos nombres para dos nuevas sugerencias: serán las que aparecen al pasar el cursor por encima de un borde del objeto, del que se puede «tirar» para cambiar las dimensiones del objeto.

Añadiremos una nueva enumeración de modos de ordenación de columnas y nuevas constantes de enumeración:

//+------------------------------------------------------------------+
//| Enumeraciones                                                     |
//+------------------------------------------------------------------+
enum ENUM_ELEMENT_SORT_BY                       // Propiedades comparadas
  {
   ELEMENT_SORT_BY_ID   =  BASE_SORT_BY_ID,     // Comparación por identificador del elemento
   ELEMENT_SORT_BY_NAME =  BASE_SORT_BY_NAME,   // Comparación por nombre del elemento
   ELEMENT_SORT_BY_X    =  BASE_SORT_BY_X,      // Comparación según la coordenada X del elemento
   ELEMENT_SORT_BY_Y    =  BASE_SORT_BY_Y,      // Comparación por la coordenada Y del elemento
   ELEMENT_SORT_BY_WIDTH=  BASE_SORT_BY_WIDTH,  // Comparación en función del ancho del elemento
   ELEMENT_SORT_BY_HEIGHT= BASE_SORT_BY_HEIGHT, // Comparación en función de la altura del elemento
   ELEMENT_SORT_BY_ZORDER= BASE_SORT_BY_ZORDER, // Comparación según el orden Z del elemento
   ELEMENT_SORT_BY_TEXT,                        // Comparación según el texto del elemento
   ELEMENT_SORT_BY_COLOR_BG,                    // Comparación según el color de fondo del elemento
   ELEMENT_SORT_BY_ALPHA_BG,                    // Comparación según la transparencia del fondo del elemento
   ELEMENT_SORT_BY_COLOR_FG,                    // Comparación según el color del primer plano del elemento
   ELEMENT_SORT_BY_ALPHA_FG,                    // Comparación según la transparencia del primer plano del elemento
   ELEMENT_SORT_BY_STATE,                       // Comparación según el estado del elemento
   ELEMENT_SORT_BY_GROUP,                       // Comparación por el grupo del elemento
  };

enum ENUM_TABLE_SORT_MODE                       // Modos de ordenación de las columnas de las tablas
  {
   TABLE_SORT_MODE_NONE,                        // No hay ordenación
   TABLE_SORT_MODE_ASC,                         // Ordenación de menor a mayor
   TABLE_SORT_MODE_DESC,                        // Ordenación de mayor a menor
  };

enum ENUM_HINT_TYPE                             // Tipos de sugerencias
  {
   HINT_TYPE_TOOLTIP,                           // Sugerencia emergente
   HINT_TYPE_ARROW_HORZ,                        // Flecha doble horizontal
   HINT_TYPE_ARROW_VERT,                        // Flecha doble vertical
   HINT_TYPE_ARROW_NWSE,                        // Flecha doble de arriba a la izquierda a abajo a la derecha (noroeste-sureste)
   HINT_TYPE_ARROW_NESW,                        // Flecha doble de abajo a la izquierda a arriba a la derecha (noreste-suroeste)
   HINT_TYPE_ARROW_SHIFT_HORZ,                  // Flecha de desplazamiento horizontal
   HINT_TYPE_ARROW_SHIFT_VERT,                  // Flecha de desplazamiento vertical
  };

En la clase de dibujo de imágenes CImagePainter, declararemos dos nuevos métodos que dibujan flechas de desplazamiento horizontal y vertical:

//--- Limpia el área
   bool              Clear(const int x,const int y,const int w,const int h,const bool update=true);
//--- Dibuja una flecha rellena (1) hacia arriba, (2) hacia abajo, (3) hacia la izquierda y (4) hacia la derecha
   bool              ArrowUp(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   bool              ArrowDown(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   bool              ArrowLeft(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   bool              ArrowRight(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   
//--- Dibuja (1) una flecha doble horizontal de 17×7 y (2) una flecha doble vertical de 7×17
   bool              ArrowHorz(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true); 
   bool              ArrowVert(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true); 
   
//--- Dibuja una flecha doble diagonal de 17×17: (1) de arriba a la izquierda a abajo a la derecha o (2) de abajo a la izquierda a arriba a la derecha
   bool              ArrowNWSE(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   bool              ArrowNESW(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   
//--- Dibuja una flecha de desplazamiento de 18×18: (1) horizontal o (2) vertical
   bool              ArrowShiftHorz(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   bool              ArrowShiftVert(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   
//--- Dibuja una casilla de verificación (1) marcada o (2) desmarcada
   bool              CheckedBox(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   bool              UncheckedBox(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   
//--- Dibuja un botón de opción (1) marcado o (2) desmarcado
   bool              CheckedRadioButton(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);
   bool              UncheckedRadioButton(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true);

Fuera del cuerpo de la clase, escribiremos la implementación de los métodos declarados.

Método que dibuja una flecha de desplazamiento horizontal de 18×18:

//+------------------------------------------------------------------+
//| CImagePainter::Dibuja una flecha de desplazamiento horizontal de 18×18     |
//+------------------------------------------------------------------+
bool CImagePainter::ArrowShiftHorz(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true)
  {
//--- Si el área de la imagen no es válida, devolvemos false
   if(!this.CheckBound(__FUNCTION__))
      return false;

//--- Coordenadas de la figura
   int arrx[25]={0, 3, 4, 4, 7, 7, 10, 10, 13, 13, 14, 17, 17, 14, 13, 13, 10, 10,  7,  7,  4,  4,  3, 0, 0};
   int arry[25]={8, 5, 5, 7, 7, 0,  0,  7,  7,  5,  5,  8,  9, 12, 12, 10, 10, 17, 17, 10, 10, 12, 12, 9, 8};
   
//--- Dibujamos un fondo blanco
   this.m_canvas.Polyline(arrx,arry,::ColorToARGB(clrWhite,alpha));

//--- Dibujamos la línea de las flechas
   this.m_canvas.FillRectangle(1,8, 16,9,::ColorToARGB(clr,alpha));
//--- Dibujamos una línea divisoria
   this.m_canvas.FillRectangle(8,1, 9,16,::ColorToARGB(clr,alpha));
//--- Dibujamos el triángulo de la izquierda
   this.m_canvas.Line(2,7, 2,10,::ColorToARGB(clr,alpha));
   this.m_canvas.Line(3,6, 3,11,::ColorToARGB(clr,alpha));
//--- Dibujamos el triángulo de la derecha
   this.m_canvas.Line(14,6, 14,11,::ColorToARGB(clr,alpha));
   this.m_canvas.Line(15,7, 15,10,::ColorToARGB(clr,alpha));

   if(update)
      this.m_canvas.Update(false);
   return true;
  }

Método que dibuja una flecha de 18×18 para el desplazamiento vertical:

//+------------------------------------------------------------------+
//| CImagePainter::Dibuja una flecha de 18×18 para el desplazamiento vertical       |
//+------------------------------------------------------------------+
bool CImagePainter::ArrowShiftVert(const int x,const int y,const int w,const int h,const color clr,const uchar alpha,const bool update=true)
  {
//--- Si el área de la imagen no es válida, devolvemos false
   if(!this.CheckBound(__FUNCTION__))
      return false;

//--- Coordenadas de la figura
   int arrx[25]={0, 7, 7, 5, 5, 8, 9, 12, 12, 10, 10, 17, 17, 10, 10, 12, 12,  9,  8,  5,  5,  7,  7,  0, 0};
   int arry[25]={7, 7, 4, 4, 3, 0, 0,  3,  4,  4,  7,  7, 10, 10, 13, 13, 14, 17, 17, 14, 13, 13, 10, 10, 7};
   
//--- Dibujamos un fondo blanco
   this.m_canvas.Polyline(arrx,arry,::ColorToARGB(clrWhite,alpha));

//--- Dibujamos una línea divisoria
   this.m_canvas.FillRectangle(1,8, 16,9,::ColorToARGB(clr,alpha));
//--- Dibujamos la línea de las flechas
   this.m_canvas.FillRectangle(8,1, 9,16,::ColorToARGB(clr,alpha));
//--- Dibujamos el triángulo superior
   this.m_canvas.Line(7,2, 10,2,::ColorToARGB(clr,alpha));
   this.m_canvas.Line(6,3, 11,3,::ColorToARGB(clr,alpha));
//--- Dibujamos el triángulo inferior
   this.m_canvas.Line(6,14, 11,14,::ColorToARGB(clr,alpha));
   this.m_canvas.Line(7,15, 10,15,::ColorToARGB(clr,alpha));

   if(update)
      this.m_canvas.Update(false);

   return true;
  }

Ambos métodos dibujan sugerencias con flechas para el desplazamiento horizontal ( ) y vertical ( ) del borde del elemento, con el fin de modificar sus dimensiones.

En la clase base del elemento gráfico CElementBase, convertiremos los dos métodos AddHintsArrowed y ShowCursorHint en virtuales:

//--- Añade un objeto de sugerencia ya existente a la lista
   CVisualHint      *AddHint(CVisualHint *obj, const int dx, const int dy);
//--- (1) Añade a la lista, (2) elimina de la lista los objetos de sugerencia con flechas
   virtual bool      AddHintsArrowed(void);
   bool              DeleteHintsArrowed(void);
//--- Muestra el cursor de redimensionamiento
   virtual bool      ShowCursorHint(const ENUM_CURSOR_REGION edge,int x,int y);
   
//--- Manejador del arrastre de los bordes y las esquinas de un elemento
   virtual void      ResizeActionDragHandler(const int x, const int y);

En el destructor de la clase, limpiaremos la lista de sugerencias:

//--- Constructores/destructor
                     CElementBase(void) { this.m_painter.CanvasAssign(this.GetForeground()); this.m_visible_in_container=true; }
                     CElementBase(const string object_name, const string text, const long chart_id, const int wnd, const int x, const int y, const int w, const int h);
                    ~CElementBase(void) { this.m_list_hints.Clear(); }

Al añadir objetos a las listas, primero se busca si ya existe un objeto exactamente igual en la lista. Para que la búsqueda sea correcta, la lista se ordena según la propiedad que se compara. Sin embargo, inicialmente la lista puede estar ordenada según otra propiedad. Para no alterar la ordenación original de las listas, la guardaremos en memoria; a continuación, estableceremos la ordenación necesaria para la búsqueda y, al finalizar, volveremos a aplicar la ordenación guardada anteriormente.

En el método para añadir la sugerencia indicada a la lista, realizaremos la siguiente modificación:

//+------------------------------------------------------------------+
//| CElementBase::Añade el objeto de sugerencia especificado a la lista      |
//+------------------------------------------------------------------+
bool CElementBase::AddHintToList(CVisualHint *obj)
  {
//--- Si se pasa un puntero nulo, lo indicamos y devolvemos «false»
   if(obj==NULL)
     {
      ::PrintFormat("%s: Error. Empty element passed",__FUNCTION__);
      return false;
     }
//--- Guardamos el método de ordenación de la lista
   int sort_mode=this.m_list_hints.SortMode();
//--- Establecemos el indicador de ordenación por identificador en la lista
   this.m_list_hints.Sort(ELEMENT_SORT_BY_ID);
//--- Si ese elemento no aparece en la lista,
   if(this.m_list_hints.Search(obj)==NULL)
     {
      //--- rstablecemos la lista de ordenación inicial y el resultado de su adición a la lista
      this.m_list_hints.Sort(sort_mode);
      return(this.m_list_hints.Add(obj)>-1);
     }
//--- Restablecemos la ordenación original de la lista
   this.m_list_hints.Sort(sort_mode);
//--- Ya existe un elemento con ese identificador en la lista: devolvemos «false»
   return false;
  }

En los métodos que trabajan con nombres de objetos de sugerencia, a partir de ahora utilizaremos los nombres de los objetos especificados anteriormente mediante las directivas:

//+------------------------------------------------------------------+
//| CElementBase::Añade a la lista objetos de sugerencia con flechas  |
//+------------------------------------------------------------------+
bool CElementBase::AddHintsArrowed(void)
  {
//--- Arrays de nombres y tipos de sugerencias
   string array[4]={DEF_HINT_NAME_HORZ,DEF_HINT_NAME_VERT,DEF_HINT_NAME_NWSE,DEF_HINT_NAME_NESW};
   
   ENUM_HINT_TYPE type[4]={HINT_TYPE_ARROW_HORZ,HINT_TYPE_ARROW_VERT,HINT_TYPE_ARROW_NWSE,HINT_TYPE_ARROW_NESW};
   
//--- En el bucle creamos cuatro sugerencias con flechas
   bool res=true;
   for(int i=0;i<(int)array.Size();i++)
      res &=(this.CreateAndAddNewHint(type[i],array[i],0,0)!=NULL);
      
//--- Si se han producido errores durante la creación, devolvemos «false»
   if(!res)
      return false;
      
//--- En el bucle que recorre el array de nombres de los objetos de sugerencia
   for(int i=0;i<(int)array.Size();i++)
     {
      //--- obtenemos el siguiente objeto por su nombre,
      CVisualHint *obj=this.GetHint(array[i]);
      if(obj==NULL)
         continue;
      //--- ocultamos el objeto y dibujamos su aspecto exterior (flechas según el tipo de objeto)
      obj.Hide(false);
      obj.Draw(false);
     }
//--- Todo ha salido bien
   return true;
  }

...

//+------------------------------------------------------------------+
//| CElementBase::Muestra el cursor de redimensionamiento               |
//+------------------------------------------------------------------+
bool CElementBase::ShowCursorHint(const ENUM_CURSOR_REGION edge,int x,int y)
  {
   CVisualHint *hint=NULL;          // Puntero a la sugerencia
   int hint_shift_x=0;              // Desplazamiento de la sugerencia en el eje X
   int hint_shift_y=0;              // Desplazamiento de la sugerencia en el eje Y
   
//--- Dependiendo de la posición del cursor en los límites del elemento
//--- indicamos los desplazamientos de la sugerencia con respecto a las coordenadas del cursor,
//--- mostramos la sugerencia deseada en el gráfico y obtenemos un puntero a ese objeto
   switch(edge)
     {
      //--- El cursor en el borde derecho o izquierdo: una flecha doble horizontal
      case CURSOR_REGION_RIGHT         :
      case CURSOR_REGION_LEFT          :
         hint_shift_x=1;
         hint_shift_y=18;
         this.ShowHintArrowed(HINT_TYPE_ARROW_HORZ,x+hint_shift_x,y+hint_shift_y);
         hint=this.GetHint(DEF_HINT_NAME_HORZ);
        break;
    
      //--- El cursor en el borde superior o inferior: una flecha doble vertical
      case CURSOR_REGION_TOP           :
      case CURSOR_REGION_BOTTOM        :
         hint_shift_x=12;
         hint_shift_y=4;
         this.ShowHintArrowed(HINT_TYPE_ARROW_VERT,x+hint_shift_x,y+hint_shift_y);
         hint=this.GetHint(DEF_HINT_NAME_VERT);
        break;
    
      //--- El cursor en la esquina superior izquierda o inferior derecha: una flecha doble en diagonal desde la esquina superior izquierda hasta la esquina inferior derecha
      case CURSOR_REGION_LEFT_TOP      :
      case CURSOR_REGION_RIGHT_BOTTOM  :
         hint_shift_x=10;
         hint_shift_y=2;
         this.ShowHintArrowed(HINT_TYPE_ARROW_NWSE,x+hint_shift_x,y+hint_shift_y);
         hint=this.GetHint(DEF_HINT_NAME_NWSE);
        break;
    
      //--- El cursor en la esquina inferior izquierda o superior derecha: una flecha doble en diagonal desde la esquina inferior izquierda hasta la esquina superior derecha
      case CURSOR_REGION_LEFT_BOTTOM   :
      case CURSOR_REGION_RIGHT_TOP     :
         hint_shift_x=5;
         hint_shift_y=12;
         this.ShowHintArrowed(HINT_TYPE_ARROW_NESW,x+hint_shift_x,y+hint_shift_y);
         hint=this.GetHint(DEF_HINT_NAME_NESW);
        break;
      
      //--- Por defecto, no hacemos nada
      default: break;
     }

//--- Devolvemos el resultado del ajuste de la posición de la sugerencia con respecto al cursor
   return(hint!=NULL ? hint.Move(x+hint_shift_x,y+hint_shift_y) : false);
  }

etc.

En la clase del objeto de sugerencia declararemos dos nuevos métodos que dibujan dos nuevas sugerencias:

//+------------------------------------------------------------------+
//| Clase de sugerencia                                              |
//+------------------------------------------------------------------+
class CVisualHint : public CButton
  {
protected:
   ENUM_HINT_TYPE    m_hint_type;                              // Tipo de sugerencia

//--- Dibuja (1) una sugerencia emergente, (2) una flecha horizontal, (3) una flecha vertical,
//--- flechas (4) de la esquina superior izquierda a la inferior derecha, (5) de la esquina inferior izquierda a la superior derecha,
//--- flechas de desplazamiento en (6) horizontal, (7) vertical
   void              DrawTooltip(void);
   void              DrawArrHorz(void);
   void              DrawArrVert(void);
   void              DrawArrNWSE(void);
   void              DrawArrNESW(void);
   void              DrawArrShiftHorz(void);
   void              DrawArrShiftVert(void);
   
//--- Inicialización de colores para el tipo de sugerencia (1) Tooltip, (2) flechas
   void              InitColorsTooltip(void);
   void              InitColorsArrowed(void);
   
public:
//--- (1) Establece, (2) devuelve el tipo de sugerencia
   void              SetHintType(const ENUM_HINT_TYPE type);
   ENUM_HINT_TYPE    HintType(void)                      const { return this.m_hint_type;             }

//--- Dibuja el aspecto visual
   virtual void      Draw(const bool chart_redraw);

//--- Métodos virtuales: (1) comparación, (2) guardado en un archivo, (3) carga desde un archivo, (4) tipo de objeto
   virtual int       Compare(const CObject *node,const int mode=0) const;
   virtual bool      Save(const int file_handle)               { return CButton::Save(file_handle);   }
   virtual bool      Load(const int file_handle)               { return CButton::Load(file_handle);   }
   virtual int       Type(void)                          const { return(ELEMENT_TYPE_HINT);           }
   
//--- Inicialización (1) del objeto de la clase, (2) de los colores predeterminados del objeto
   void              Init(const string text);
   virtual void      InitColors(void);
   
//--- Constructores/destructor
                     CVisualHint(void);
                     CVisualHint(const string object_name, const long chart_id, const int wnd, const int x, const int y, const int w, const int h);
                    ~CVisualHint (void) {}
  };

Fuera del cuerpo de la clase, escribiremos su implementación:

//+------------------------------------------------------------------+
//| CVisualHint::Dibuja flechas de desplazamiento horizontal         |
//+------------------------------------------------------------------+
void CVisualHint::DrawArrShiftHorz(void)
  {
//--- Limpiamos el área de la imagen
   this.m_painter.Clear(this.AdjX(this.m_painter.X()),this.AdjY(this.m_painter.Y()),this.m_painter.Width(),this.m_painter.Height(),false);
//--- Dibujamos las flechas de desplazamiento horizontal
   this.m_painter.ArrowShiftHorz(this.AdjX(this.m_painter.X()),this.AdjY(this.m_painter.Y()),this.m_painter.Width(),this.m_painter.Height(),this.ForeColor(),this.AlphaFG(),true);
  }
//+------------------------------------------------------------------+
//| CVisualHint::Dibuja flechas de desplazamiento vertical           |
//+------------------------------------------------------------------+
void CVisualHint::DrawArrShiftVert(void)
  {
//--- Limpiamos el área de la imagen
   this.m_painter.Clear(this.AdjX(this.m_painter.X()),this.AdjY(this.m_painter.Y()),this.m_painter.Width(),this.m_painter.Height(),false);
//--- Dibujamos las flechas de desplazamiento horizontal
   this.m_painter.ArrowShiftVert(this.AdjX(this.m_painter.X()),this.AdjY(this.m_painter.Y()),this.m_painter.Width(),this.m_painter.Height(),this.ForeColor(),this.AlphaFG(),true);
  }

Añadiremos el procesamiento de los nuevos métodos de dibujo de sugerencias a los métodos de dibujo y de configuración del tipo de sugerencia:

//+------------------------------------------------------------------+
//| CVisualHint::Establece el tipo de sugerencia                     |
//+------------------------------------------------------------------+
void CVisualHint::SetHintType(const ENUM_HINT_TYPE type)
  {
//--- Si el tipo pasado coincide con el establecido, salimos
   if(this.m_hint_type==type)
      return;
//--- Configuramos un nuevo tipo de sugerencia
   this.m_hint_type=type;
//--- En función del tipo de sugerencia, establecemos las dimensiones del objeto
   switch(this.m_hint_type)
     {
      case HINT_TYPE_ARROW_HORZ        :  this.Resize(17,7);   break;
      case HINT_TYPE_ARROW_VERT        :  this.Resize(7,17);   break;
      case HINT_TYPE_ARROW_NESW        :
      case HINT_TYPE_ARROW_NWSE        :  this.Resize(13,13);  break;
      case HINT_TYPE_ARROW_SHIFT_HORZ  :
      case HINT_TYPE_ARROW_SHIFT_VERT  :  this.Resize(18,18);  break;
      default                          :  break;
     }
//--- Establecemos el desplazamiento y las dimensiones del área de la imagen,
//--- Inicializamos los colores según el tipo de sugerencia
   this.SetImageBound(0,0,this.Width(),this.Height());
   this.InitColors();
  }
//+------------------------------------------------------------------+
//| CVisualHint::Dibuja el aspecto visual                            |
//+------------------------------------------------------------------+
void CVisualHint::Draw(const bool chart_redraw)
  {
//--- Dependiendo del tipo de sugerencia, llamamos al método de dibujo correspondiente
   switch(this.m_hint_type)
     {
      case HINT_TYPE_ARROW_HORZ        :  this.DrawArrHorz();        break;
      case HINT_TYPE_ARROW_VERT        :  this.DrawArrVert();        break;
      case HINT_TYPE_ARROW_NESW        :  this.DrawArrNESW();        break;
      case HINT_TYPE_ARROW_NWSE        :  this.DrawArrNWSE();        break;
      case HINT_TYPE_ARROW_SHIFT_HORZ  :  this.DrawArrShiftHorz();   break;
      case HINT_TYPE_ARROW_SHIFT_VERT  :  this.DrawArrShiftVert();   break;
      default                          :  this.DrawTooltip();        break;
     }

//--- Si se indica, actualizamos el gráfico
   if(chart_redraw)
      ::ChartRedraw(this.m_chart_id);
  }

Vamos a perfeccionar la clase del panel CPanel.

Añadiremos métodos auxiliares para trabajar con las listas de elementos adjuntos:

//+------------------------------------------------------------------+
//| Clase del panel                                                  |
//+------------------------------------------------------------------+
class CPanel : public CLabel
  {
private:
   CElementBase      m_temp_elm;                // Objeto temporal para la búsqueda de elementos
   CBound            m_temp_bound;              // Objeto temporal para la búsqueda de áreas
protected:
   CListElm          m_list_elm;                // Lista de elementos asociados
   CListElm          m_list_bounds;             // Lista de áreas
//--- Añade un nuevo elemento a la lista
   bool              AddNewElement(CElementBase *element);

public:
//--- Devuelve un puntero a la lista de (1) elementos asociados o (2) áreas
   CListElm         *GetListAttachedElements(void)             { return &this.m_list_elm;                         }
   CListElm         *GetListBounds(void)                       { return &this.m_list_bounds;                      }
   
//--- Devuelve el elemento asociado según (1) el índice de la lista, (2) el identificador o (3) el nombre asignado al objeto
   CElementBase     *GetAttachedElementAt(const uint index)    { return this.m_list_elm.GetNodeAtIndex(index);    }
   CElementBase     *GetAttachedElementByID(const int id);
   CElementBase     *GetAttachedElementByName(const string name);
   
//--- Devuelve el número de elementos asociados
   int               AttachedElementsTotal(void)         const { return this.m_list_elm.Total();                  }

//--- Devuelve un área según (1) el índice de la lista, (2) el identificador o (3) el nombre asignado al área
   CBound           *GetBoundAt(const uint index)              { return this.m_list_bounds.GetNodeAtIndex(index); }
   CBound           *GetBoundByID(const int id);
   CBound           *GetBoundByName(const string name);
   
//--- Crea y añade (1) un elemento nuevo o (2) uno ya creado a la lista
   virtual CElementBase *InsertNewElement(const ENUM_ELEMENT_TYPE type,const string text,const string user_name,const int dx,const int dy,const int w,const int h);
   virtual CElementBase *InsertElement(CElementBase *element,const int dx,const int dy);
//--- Elimina el elemento indicado
   bool              DeleteElement(const int index)            { return this.m_list_elm.Delete(index);            }

//--- (1) Crea y añade una nueva área a la lista, (2) elimina el área indicada
   CBound           *InsertNewBound(const string name,const int dx,const int dy,const int w,const int h);
   bool              DeleteBound(const int index)              { return this.m_list_bounds.Delete(index);         }
   
//--- (1) Asigna el objeto al área indicada, (2) anula la asignación del objeto al área indicada
   bool              AssignObjectToBound(const int bound, CBaseObj *object);
   bool              UnassignObjectFromBound(const int bound);

//--- Modifica las dimensiones del objeto
   virtual bool      ResizeW(const int w);
   virtual bool      ResizeH(const int h);
   virtual bool      Resize(const int w,const int h);
//--- Dibuja el aspecto visual
   virtual void      Draw(const bool chart_redraw);
   
//--- Métodos virtuales: (1) comparación, (2) guardado en un archivo, (3) carga desde un archivo, (4) tipo de objeto
   virtual int       Compare(const CObject *node,const int mode=0) const;
   virtual bool      Save(const int file_handle);
   virtual bool      Load(const int file_handle);
   virtual int       Type(void)                          const { return(ELEMENT_TYPE_PANEL);                      }
  
//--- Inicialización (1) del objeto de la clase, (2) de los colores predeterminados del objeto
   void              Init(void);
   virtual void      InitColors(void);
   
//--- Asigna nuevas coordenadas XY al objeto
   virtual bool      Move(const int x,const int y);
//--- Desplaza el objeto por los ejes X e Y en la distancia indicada
   virtual bool      Shift(const int dx,const int dy);
//--- Establece simultáneamente las coordenadas y las dimensiones del elemento
   virtual bool      MoveXYWidthResize(const int x,const int y,const int w,const int h);
   
//--- (1) Oculta (2) muestra el objeto en todos los periodos del gráfico,
//--- (3) coloca el objeto en primer plano, (4) bloquea, (5) desbloquea el elemento,
   virtual void      Hide(const bool chart_redraw);
   virtual void      Show(const bool chart_redraw);
   virtual void      BringToTop(const bool chart_redraw);
   virtual void      Block(const bool chart_redraw);
   virtual void      Unblock(const bool chart_redraw);
   
//--- Muestra en el registro la descripción del objeto
   virtual void      Print(void);
   
//--- Imprime una lista de (1) los objetos asociados y (2) las áreas
   void              PrintAttached(const uint tab=3);
   void              PrintBounds(void);

//--- Manejador de eventos
   virtual void      OnChartEvent(const int id,const long& lparam,const double& dparam,const string& sparam);
   
//--- Manejador del evento del temporizador
   virtual void      TimerEventHandler(void);
   
//--- Constructores/destructor
                     CPanel(void);
                     CPanel(const string object_name, const string text, const long chart_id, const int wnd, const int x, const int y, const int w, const int h);
                    ~CPanel (void) { this.m_list_elm.Clear(); this.m_list_bounds.Clear(); }
  };

En el método para cambiar el ancho de un elemento, ResizeW(), hay un posible error:

//--- Obtenemos un puntero al elemento base y, si existe y es de tipo contenedor,
//--- comprobamos la relación entre las dimensiones del elemento actual y las del contenedor
//--- para mostrar las barras de desplazamiento en el contenedor cuando sea necesario
   CContainer *base=this.GetContainer();
   if(base!=NULL && base.Type()==ELEMENT_TYPE_CONTAINER)
      base.CheckElementSizes(&this);

En caso de que el contenedor obtenido mediante el método GetContainer() no sea de la clase CContainer, el programa se cerrará por un error crítico debido a la imposibilidad de convertir los tipos de los objetos.

Vamos a solucionar el problema:

//+------------------------------------------------------------------+
//| CPanel::Cambia el ancho del objeto                               |
//+------------------------------------------------------------------+
bool CPanel::ResizeW(const int w)
  {
   if(!this.ObjectResizeW(w))
      return false;
   this.BoundResizeW(w);
   this.SetImageSize(w,this.Height());
   if(!this.ObjectTrim())
     {
      this.Update(false);
      this.Draw(false);
     }
//--- Obtenemos un puntero al elemento base y, si existe y es de tipo contenedor,
//--- comprobamos la relación entre las dimensiones del elemento actual y las del contenedor
//--- para mostrar las barras de desplazamiento en el contenedor cuando sea necesario
   CContainer  *container=NULL;
   CCanvasBase *base=this.GetContainer();
   if(base!=NULL && base.Type()==ELEMENT_TYPE_CONTAINER)
     {
      container=base;
      container.CheckElementSizes(&this);
     }
      
//--- En el bucle de los elementos asociados, recortamos cada elemento según los límites del contenedor
   int total=this.m_list_elm.Total();
   for(int i=0;i<total;i++)
     {
      CElementBase *elm=this.GetAttachedElementAt(i);
      if(elm!=NULL)
         elm.ObjectTrim();
     }
//--- Todo ha salido bien
   return true;
  }

Ahora podemos asignar sin error un puntero al tipo correcto de objeto.

En el método para añadir un nuevo elemento a la lista, guardaremos la ordenación original de la lista y la restableceremos tras añadir el objeto a la lista:

//+------------------------------------------------------------------+
//| CPanel::Añade un nuevo elemento a la lista                       |
//+------------------------------------------------------------------+
bool CPanel::AddNewElement(CElementBase *element)
  {
//--- Si se pasa un puntero nulo, lo indicamos y devolvemos «false»
   if(element==NULL)
     {
      ::PrintFormat("%s: Error. Empty element passed",__FUNCTION__);
      return false;
     }
//--- Guardamos el método de ordenación de la lista
   int sort_mode=this.m_list_elm.SortMode();
//--- Establecemos el indicador de ordenación por identificador en la lista
   this.m_list_elm.Sort(ELEMENT_SORT_BY_ID);
//--- Si ese elemento no aparece en la lista,
   if(this.m_list_elm.Search(element)==NULL)
     {
      //--- devolvemos la lista de ordenación inicial y devolvemos el resultado de su adición a la lista
      this.m_list_elm.Sort(sort_mode);
      return(this.m_list_elm.Add(element)>-1);
     }
//--- Restablecemos la ordenación original de la lista
   this.m_list_elm.Sort(sort_mode);
//--- Ya existe un elemento con ese identificador en la lista: devolvemos «false»
   return false;
  }

Vamos a perfeccionar el método que crea y añade una nueva área a la lista:

//+------------------------------------------------------------------+
//| Crea y añade una nueva área a la lista                           |
//+------------------------------------------------------------------+
CBound *CPanel::InsertNewBound(const string name,const int dx,const int dy,const int w,const int h)
  {
//--- Comprobamos si existe en la lista un área con el nombre indicado y, si es así, lo indicamos y devolvemos NULL
   this.m_temp_bound.SetName(name);
//--- Guardamos el método de ordenación de la lista
   int sort_mode=this.m_list_bounds.SortMode();
//--- Establecemos en la lista el indicador de ordenación por nombre
   this.m_list_bounds.Sort(ELEMENT_SORT_BY_NAME);
   if(this.m_list_bounds.Search(&this.m_temp_bound)!=NULL)
     {
      //--- Restablecemos la lista de ordenación inicial, notificamos que ese objeto ya existe y devolvemos NULL
      this.m_list_bounds.Sort(sort_mode);
      ::PrintFormat("%s: Error. An area named \"%s\" is already in the list",__FUNCTION__,name);
      return NULL;
     }
//--- Restablecemos la ordenación original de la lista
   this.m_list_bounds.Sort(sort_mode);
//--- Creamos un nuevo objeto de área; si falla, lo notificamos y devolvemos NULL
   CBound *bound=new CBound(dx,dy,w,h);
   if(bound==NULL)
     {
      ::PrintFormat("%s: Error. Failed to create CBound object",__FUNCTION__);
      return NULL;
     }
//--- Establecemos el nombre y el identificador del área, y devolvemos un puntero al objeto
   bound.SetName(name);
   bound.SetID(this.m_list_bounds.Total());
//--- Si no se ha podido añadir el nuevo objeto a la lista, lo notificamos, eliminamos el objeto y devolvemos NULL
   if(this.m_list_bounds.Add(bound)==-1)
     {
      ::PrintFormat("%s: Error. Failed to add CBound object to list",__FUNCTION__);
      delete bound;
      return NULL;
     }
   return bound;
  }

En la clase hay dos métodos que se han declarado, pero que no se han implementado. Lo corregiremos.

Método que devuelve un área por su identificador:

//+------------------------------------------------------------------+
//| CPanel::Devuelve un área por su identificador                    |
//+------------------------------------------------------------------+
CBound *CPanel::GetBoundByID(const int id)
  {
   int total=this.m_list_bounds.Total();
   for(int i=0;i<total;i++)
     {
      CBound *bound=this.GetBoundAt(i);
      if(bound!=NULL && bound.ID()==id)
         return bound;
     }
   return NULL;
  }

En un bucle simple que recorre los objetos de las áreas del elemento, buscamos el área con el identificador indicado y devolvemos un puntero al objeto encontrado.

Método que devuelve un área por el nombre que se le ha asignado:

//+------------------------------------------------------------------+
//| CPanel::Devuelve un área por el nombre que se le ha asignado     |
//+------------------------------------------------------------------+
CBound *CPanel::GetBoundByName(const string name)
  {
   int total=this.m_list_bounds.Total();
   for(int i=0;i<total;i++)
     {
      CBound *bound=this.GetBoundAt(i);
      if(bound!=NULL && bound.Name()==name)
         return bound;
     }
   return NULL;
  }

En un bucle simple que recorre los objetos de las áreas del elemento, buscamos el área con el nombre indicado y devolvemos un puntero al objeto encontrado.

Escribamos la implementación de los dos métodos declarados.

Método que asigna un objeto al área indicada:

//+------------------------------------------------------------------+
//| CPanel::Asigna un objeto al área indicada                        |
//+------------------------------------------------------------------+
bool CPanel::AssignObjectToBound(const int bound,CBaseObj *object)
  {
   CBound *bound_obj=this.GetBoundAt(bound);
   if(bound_obj==NULL)
     {
      ::PrintFormat("%s: Error. Failed to get Bound at index %d",__FUNCTION__,bound);
      return false;
     }
   bound_obj.AssignObject(object);
   return true;
  }

Obtenemos el área mediante su identificador y llamamos al método del objeto del área que asigna el objeto a dicha área.

Método que anula la asignación de un objeto al área indicada:

//+------------------------------------------------------------------+
//| CPanel::Anula la asignación del objeto al área indicada          |
//+------------------------------------------------------------------+
bool CPanel::UnassignObjectFromBound(const int bound)
  {
   CBound *bound_obj=this.GetBoundAt(bound);
   if(bound_obj==NULL)
     {
      ::PrintFormat("%s: Error. Failed to get Bound at index %d",__FUNCTION__,bound);
      return false;
     }
   bound_obj.UnassignObject();
   return true;
  }

Obtenemos el área mediante su identificador y llamamos al método del objeto del área que anula la asignación previa del objeto a dicha área.

En las clases de barras de desplazamiento —tanto horizontales como verticales— existe un fallo que hace que, al desplazar el control deslizante, puedan desplazarse varias barras de desplazamiento a la vez si hay más de un contenedor en el gráfico. Para corregir este comportamiento, hay que leer del parámetro sparam el nombre del elemento activo y compararlo con el nombre del control deslizante. Si el nombre del control deslizante contiene una subcadena con el nombre del elemento activo, es precisamente ese control deslizante el que se está desplazando. Vamos a introducir modificaciones en los manejadores de desplazamiento con la rueda del ratón en ambas clases de controles deslizantes de las barras de desplazamiento:

//+------------------------------------------------------------------+
//| CScrollBarThumbH::Manejador de desplazamiento con la rueda       |
//+------------------------------------------------------------------+
void CScrollBarThumbH::OnWheelEvent(const int id,const long lparam,const double dparam,const string sparam)
  {
//--- Obtenemos un puntero al objeto base (el control «barra de desplazamiento horizontal»)
   CCanvasBase *base_obj=this.GetContainer();
   
//--- Obtenemos el nombre del objeto principal de la jerarquía a partir del valor de sparam
   string array_names[];
   string name_main=(GetElementNames(sparam,"_",array_names)>0 ? array_names[0] : "");
   
//--- Si el objeto principal de la jerarquía no es el nuestro, salimos
   if(::StringFind(this.NameFG(),name_main)!=0)
      return;
      
//--- Si el control deslizante no tiene activado el indicador que permite moverlo, o si no se ha obtenido el puntero al objeto base, salimos
   if(!this.IsMovable() || base_obj==NULL)
      return;
   
//--- Obtenemos el ancho del objeto base y calculamos los límites del espacio para el control deslizante
   int base_w=base_obj.Width();
   int base_left=base_obj.X()+base_obj.Height();
   int base_right=base_obj.Right()-base_obj.Height()+1;
   
//--- Establecemos la dirección del desplazamiento en función de la dirección de giro de la rueda del ratón
   int dx=(dparam<0 ? 2 : dparam>0 ? -2 : 0);
   if(dx==0)
      dx=(int)lparam;

//--- Si al desplazarlo el control deslizante sobrepasa el borde izquierdo de su área, lo colocamos en el borde izquierdo
   if(dx<0 && this.X()+dx<=base_left)
      this.MoveX(base_left);
//--- de lo contrario, si al desplazarlo el control deslizante sobrepasa el borde derecho de su área, lo colocamos en el borde derecho
   else if(dx>0 && this.Right()+dx>=base_right)
      this.MoveX(base_right-this.Width());
//--- De lo contrario, si el control deslizante se encuentra dentro de su área, lo movemos la distancia calculada
   else
     {
      this.ShiftX(dx);
     }

//--- Calculamos la posición del control deslizante
   int thumb_pos=this.X()-base_left;
   
//--- Obtenemos las coordenadas del cursor
   int x=CCommonManager::GetInstance().CursorX();
   int y=CCommonManager::GetInstance().CursorY();
   
//--- Si el cursor se sitúa sobre el control deslizante, cambiamos el color a «En foco»,
   if(this.Contains(x,y))
      this.OnFocusEvent(id,lparam,dparam,sparam);
//--- de lo contrario, restablecemos el color «Predeterminado»
   else
      this.OnReleaseEvent(id,lparam,dparam,sparam);
      
//--- Enviamos un evento de usuario al gráfico con la posición del control deslizante en lparam y el nombre del objeto en sparam
   ::EventChartCustom(this.m_chart_id, (ushort)CHARTEVENT_MOUSE_WHEEL, thumb_pos, dparam, this.NameFG());
//--- Redibujamos el gráfico
   if(this.m_chart_redraw)
      ::ChartRedraw(this.m_chart_id);
  }
//+------------------------------------------------------------------+
//| CScrollBarThumbV::Manejador de desplazamiento con la rueda del ratón                  |
//+------------------------------------------------------------------+
void CScrollBarThumbV::OnWheelEvent(const int id,const long lparam,const double dparam,const string sparam)
  {
//--- Obtenemos un puntero al objeto base (el control «barra de desplazamiento vertical»)
   CCanvasBase *base_obj=this.GetContainer();
   
//--- Obtenemos el nombre del objeto principal de la jerarquía a partir del valor de sparam
   string array_names[];
   string name_main=(GetElementNames(sparam,"_",array_names)>0 ? array_names[0] : "");
   
//--- Si el objeto principal de la jerarquía no es el nuestro, salimos
   if(::StringFind(this.NameFG(),name_main)!=0)
      return;
      
//--- Si el control deslizante no tiene activado el indicador que permite moverlo, o si no se ha obtenido el puntero al objeto base, salimos
   if(!this.IsMovable() || base_obj==NULL)
      return;
   
//--- Obtenemos la altura del objeto base y calculamos los límites del espacio para el control deslizante
   int base_h=base_obj.Height();
   int base_top=base_obj.Y()+base_obj.Width();
   int base_bottom=base_obj.Bottom()-base_obj.Width()+1;
   
//--- Establecemos la dirección del desplazamiento en función de la dirección de giro de la rueda del ratón
   int dy=(dparam<0 ? 2 : dparam>0 ? -2 : 0);
   if(dy==0)
      dy=(int)lparam;

//--- Si al desplazarlo el control deslizante sobrepasa el borde superior de su área, lo colocamos en el borde superior
   if(dy<0 && this.Y()+dy<=base_top)
      this.MoveY(base_top);
//--- de lo contrario, si al desplazarlo el control deslizante sobrepasa el borde inferior de su área, lo colocamos en el borde inferior
   else if(dy>0 && this.Bottom()+dy>=base_bottom)
      this.MoveY(base_bottom-this.Height());
//--- De lo contrario, si el control deslizante se encuentra dentro de su área, lo movemos la distancia calculada
   else
     {
      this.ShiftY(dy);
     }

//--- Calculamos la posición del control deslizante
   int thumb_pos=this.Y()-base_top;
   
//--- Obtenemos las coordenadas del cursor
   int x=CCommonManager::GetInstance().CursorX();
   int y=CCommonManager::GetInstance().CursorY();
   
//--- Si el cursor se sitúa sobre el control deslizante, cambiamos el color a «En foco»,
   if(this.Contains(x,y))
      this.OnFocusEvent(id,lparam,dparam,sparam);
//--- de lo contrario, restablecemos el color «Predeterminado»
   else
      this.OnReleaseEvent(id,lparam,dparam,sparam);
      
//--- Enviamos un evento de usuario al gráfico con la posición del control deslizante en lparam y el nombre del objeto en sparam
   ::EventChartCustom(this.m_chart_id, (ushort)CHARTEVENT_MOUSE_WHEEL, thumb_pos, dparam, this.NameFG());
//--- Redibujamos el gráfico
   if(this.m_chart_redraw)
      ::ChartRedraw(this.m_chart_id);
  }

En la clase CContainer, en el método que desplaza el contenido del contenedor horizontalmente, es importante tener en cuenta que, en el caso de una tabla, al desplazarla horizontalmente, también es necesario desplazar el encabezado de la tabla. Vamos a implementarlo:

//+-------------------------------------------------------------------+
//|CContainer::Desplaza el contenido horizontalmente en la cantidad indicada|
//+-------------------------------------------------------------------+
bool CContainer::ContentShiftHorz(const int value)
  {
//--- Obtenemos un puntero al contenido del contenedor
   CElementBase *elm=this.GetAttachedElement();
   if(elm==NULL)
      return false;
   
//--- Para el elemento CTableView, obtenemos el encabezado de la tabla
   CElementBase     *elm_container=elm.GetContainer();
   CTableHeaderView *table_header=NULL;
   if(elm_container!=NULL && ::StringFind(elm.Name(),"Table")==0)
     {
      CElementBase *obj=elm_container.GetContainer();
      if(obj!=NULL && obj.Type()==ELEMENT_TYPE_TABLE_VIEW)
        {
         CTableView *table_view=obj;
         table_header=table_view.GetHeader();
        }
     }
//--- Calculamos el valor del desplazamiento según la posición del control deslizante
   int content_offset=this.CalculateContentOffsetHorz(value);

//--- Desplazamos el encabezado
   bool res=true;
   if(table_header!=NULL)
     {
      res &=table_header.MoveX(this.X()-content_offset);
     }
     
//--- Devolvemos el resultado del desplazamiento del contenido en la cantidad calculada
   res &=elm.MoveX(this.X()-content_offset);
   return res;
  }

En el método que devuelve el tipo del elemento que ha enviado el evento, la búsqueda del elemento base se ha realizado de forma incorrecta en la clase del objeto contenedor:

//--- Obtenemos los nombres de todos los elementos de la jerarquía (en caso de error, devolvemos -1)
   string names[]={};
   int total = GetElementNames(name,"_",names);
   if(total==WRONG_VALUE)
      return WRONG_VALUE;
      
//--- Si el nombre del elemento base de la jerarquía no coincide con el nombre del contenedor, entonces no se trata de nuestro evento; salimos
   string base_name=names[0];
   if(base_name!=this.NameFG())
      return WRONG_VALUE;

El objeto base no siempre es el primero en la jerarquía de elementos gráficos del contenedor. Puede haber varios niveles de anidamiento de elementos; en ese caso, el objeto base de los últimos elementos de la jerarquía no será el primero en la lista de nombres de todos los elementos anidados del contenedor. Realicemos la búsqueda del objeto base correctamente:

//+------------------------------------------------------------------+
//| Devuelve el tipo del elemento que ha enviado el evento           |
//+------------------------------------------------------------------+
ENUM_ELEMENT_TYPE CContainer::GetEventElementType(const string name)
  {
//--- Obtenemos los nombres de todos los elementos de la jerarquía (en caso de error, devolvemos -1)
   string names[]={};
   int total = GetElementNames(name,"_",names);
   if(total==WRONG_VALUE)
      return WRONG_VALUE;
   
//--- Buscaremos en el array el nombre del contenedor más cercano al nombre del elemento que ha enviado el evento
   int    cntr_index=-1;      // Índice del nombre del contenedor en el array de nombres de la jerarquía de elementos
   string cntr_name="";       // Nombre del contenedor en el array de nombres de la jerarquía de elementos
   
//--- Buscamos en el bucle la primera aparición, contando desde el final, de la subcadena «CNTR»
   for(int i=total-1;i>=0;i--)
     {
      if(::StringFind(names[i],"CNTR")==0)
        {
         cntr_name=names[i];
         cntr_index=i;
         break;
        }
     }
//--- Si no se encuentra el nombre del contenedor en el array (el índice es -1), devolvemos -1
   if(cntr_index==WRONG_VALUE)
      return WRONG_VALUE;
   
//--- Si el nombre del elemento no contiene una subcadena con el nombre del elemento base, entonces no se trata de nuestro evento; salimos
   string base_name=names[cntr_index];
   if(::StringFind(this.NameFG(),base_name)==WRONG_VALUE)
      return WRONG_VALUE;

//--- Ignoramos los eventos que no provienen de las barras de desplazamiento
   string check_name=::StringSubstr(names[cntr_index+1],0,4);
   if(check_name!="SCBH" && check_name!="SCBV")
      return WRONG_VALUE;
      
//--- Obtenemos el nombre del elemento del que procede el evento e inicializamos el tipo del elemento
   string elm_name=names[names.Size()-1];
   ENUM_ELEMENT_TYPE type=WRONG_VALUE;
   
//--- Comprobamos y guardamos el tipo de elemento
//--- Botón con la flecha hacia arriba
   if(::StringFind(elm_name,"BTARU")==0)
      type=ELEMENT_TYPE_BUTTON_ARROW_UP;
//--- Botón con una flecha hacia abajo
   else if(::StringFind(elm_name,"BTARD")==0)
      type=ELEMENT_TYPE_BUTTON_ARROW_DOWN;
//--- Botón con una flecha hacia la izquierda
   else if(::StringFind(elm_name,"BTARL")==0)
      type=ELEMENT_TYPE_BUTTON_ARROW_LEFT;
//--- Botón con la flecha hacia la derecha
   else if(::StringFind(elm_name,"BTARR")==0)
      type=ELEMENT_TYPE_BUTTON_ARROW_RIGHT;
//--- Control deslizante de la barra de desplazamiento horizontal
   else if(::StringFind(elm_name,"THMBH")==0)
      type=ELEMENT_TYPE_SCROLLBAR_THUMB_H;
//--- Control deslizante de la barra de desplazamiento vertical
   else if(::StringFind(elm_name,"THMBV")==0)
      type=ELEMENT_TYPE_SCROLLBAR_THUMB_V;
//--- Control ScrollBarHorisontal
   else if(::StringFind(elm_name,"SCBH")==0)
      type=ELEMENT_TYPE_SCROLLBAR_H;
//--- Control ScrollBarVertical
   else if(::StringFind(elm_name,"SCBV")==0)
      type=ELEMENT_TYPE_SCROLLBAR_V;
      
//--- Devolvemos el tipo del elemento
   return type;
  }

Ahora vamos a mejorar la clase de representación visual de una celda de la tabla, CTableCellView. Las modificaciones se centrarán en la restricción del dibujo de las celdas: no es necesario dibujar una celda que se encuentre fuera de su contenedor, para no malgastar recursos dibujando fuera de los límites del objeto gráfico. Además, permitiremos cambiar el color del texto que se muestra en la celda y corregiremos la visualización del texto en la celda según los distintos tipos de puntos de anclaje del texto.

Declararemos nuevas variables y métodos:

//+------------------------------------------------------------------+
//| Clase de representación visual de una celda de tabla             |
//+------------------------------------------------------------------+
class CTableCellView : public CBoundedObj
  {
protected:
   CTableCell       *m_table_cell_model;                       // Puntero al modelo de la celda
   CImagePainter    *m_painter;                                // Puntero al objeto de dibujo
   CTableRowView    *m_element_base;                           // Puntero al elemento base (fila de la tabla)
   CCanvas          *m_background;                             // Puntero al lienzo de fondo
   CCanvas          *m_foreground;                             // Puntero al lienzo de primer plano
   int               m_index;                                  // Índice en la lista de celdas
   ENUM_ANCHOR_POINT m_text_anchor;                            // Punto de anclaje del texto (alineación en la celda)
   int               m_text_x;                                 // Coordenada X del texto (desplazamiento respecto al borde izquierdo del área del objeto)
   int               m_text_y;                                 // Coordenada Y del texto (desplazamiento respecto al borde superior del área del objeto)
   ushort            m_text[];                                 // Texto
   color             m_fore_color;                             // Color del primer plano
   
//--- Devuelve los desplazamientos de las coordenadas iniciales de dibujo en el lienzo con respecto al lienzo y a las coordenadas del elemento base
   int               CanvasOffsetX(void)     const { return(this.m_element_base.ObjectX()-this.m_element_base.X());  }
   int               CanvasOffsetY(void)     const { return(this.m_element_base.ObjectY()-this.m_element_base.Y());  }
   
//--- Devuelve la coordenada ajustada de un punto en el lienzo, teniendo en cuenta el desplazamiento del lienzo con respecto al elemento base
   int               AdjX(const int x)                            const { return(x-this.CanvasOffsetX());            }
   int               AdjY(const int y)                            const { return(y-this.CanvasOffsetY());            }

//--- Devuelve las coordenadas X e Y del texto en función del punto de anclaje
   bool              GetTextCoordsByAnchor(int &x, int &y, int &dir_x, int dir_y);

//--- Devuelve un puntero al contenedor del panel de filas de la tabla
   CContainer       *GetRowsPanelContainer(void);
   
public:
//--- Devuelve un puntero al lienzo asignado (1) del fondo y (2) del primer plano
   CCanvas          *GetBackground(void)                                { return this.m_background;                  }
   CCanvas          *GetForeground(void)                                { return this.m_foreground;                  }

//--- Obtención de los límites del objeto contenedor padre
   int               ContainerLimitLeft(void)   const { return(this.m_element_base==NULL ? this.X()      :  this.m_element_base.LimitLeft());   }
   int               ContainerLimitRight(void)  const { return(this.m_element_base==NULL ? this.Right()  :  this.m_element_base.LimitRight());  }
   int               ContainerLimitTop(void)    const { return(this.m_element_base==NULL ? this.Y()      :  this.m_element_base.LimitTop());    }
   int               ContainerLimitBottom(void) const { return(this.m_element_base==NULL ? this.Bottom() :  this.m_element_base.LimitBottom()); }

//--- Devuelve un indicador que señala que el objeto se encuentra fuera de su contenedor
   virtual bool      IsOutOfContainer(void);

//--- (1) Establece, (2) devuelve el texto de la celda
   void              SetText(const string text)                         { ::StringToShortArray(text,this.m_text);    }
   string            Text(void)                                   const { return ::ShortArrayToString(this.m_text);  }

//--- (1) Establece, (2) devuelve el color del texto de la celda
   void              SetForeColor(const color clr)                      { this.m_fore_color=clr;                     }
   color             ForeColor(void)                              const { return this.m_fore_color;                  }

//--- Establece el identificador
   virtual void      SetID(const int id)                                { this.m_index=this.m_id=id;                 }
//--- (1) Establece, (2) devuelve el índice de la celda
   void              SetIndex(const int index)                          { this.SetID(index);                         }
   int               Index(void)                                  const { return this.m_index;                       }

//--- (1) Establece, (2) devuelve el desplazamiento del texto en el eje X
   void              SetTextShiftX(const int shift)                     { this.m_text_x=shift;                       }
   int               TextShiftX(void)                             const { return this.m_text_x;                      }
   
//--- (1) Establece, (2) devuelve el desplazamiento del texto en el eje Y
   void              SetTextShiftY(const int shift)                     { this.m_text_y=shift;                       }
   int               TextShiftY(void)                             const { return this.m_text_y;                      }
   
//--- (1) Establece, (2) devuelve el punto de anclaje del texto
   void              SetTextAnchor(const ENUM_ANCHOR_POINT anchor,const bool cell_redraw,const bool chart_redraw);
   int               TextAnchor(void)                             const { return this.m_text_anchor;                 }
   
//--- Establece el punto de anclaje y los desplazamientos del texto
   void              SetTextPosition(const ENUM_ANCHOR_POINT anchor,const int shift_x,const int shift_y,const bool cell_redraw,const bool chart_redraw);

//--- Asigna el elemento base (fila de la tabla)
   void              RowAssign(CTableRowView *base_element);
   
//--- (1) Asigna, (2) devuelve el modelo de celda
   bool              TableCellModelAssign(CTableCell *cell_model,int dx,int dy,int w,int h);
   CTableCell       *GetTableCellModel(void)                            { return this.m_table_cell_model;            }

//--- Muestra en el registro el modelo de celda asignado
   void              TableCellModelPrint(void);
   
//--- (1) Rellena el objeto con el color de fondo, (2) actualiza el objeto para mostrar los cambios, (3) dibuja su aspecto visual
   virtual void      Clear(const bool chart_redraw);
   virtual void      Update(const bool chart_redraw);
   virtual void      Draw(const bool chart_redraw);
   
//--- Muestra el texto
   virtual void      DrawText(const int dx, const int dy, const string text, const bool chart_redraw);
   
//--- Métodos virtuales: (1) comparación, (2) guardado en un archivo, (3) carga desde un archivo, (4) tipo de objeto
   virtual int       Compare(const CObject *node,const int mode=0)const { return CBaseObj::Compare(node,mode);       }
   virtual bool      Save(const int file_handle);
   virtual bool      Load(const int file_handle);
   virtual int       Type(void)                                   const { return(ELEMENT_TYPE_TABLE_CELL_VIEW);      }
   
//--- Inicialización de un objeto de la clase
   void              Init(const string text);
   
//--- Devuelve la descripción del objeto
   virtual string    Description(void);
   
//--- Constructores/destructor
                     CTableCellView(void);
                     CTableCellView(const int id, const string user_name, const string text, const int x, const int y, const int w, const int h);
                    ~CTableCellView (void){}
  };

En el método que asigna a la celda una fila y los lienzos de fondo y de primer plano, estableceremos el color del texto igual al color de primer plano:

//+------------------------------------------------------------------+
//| CTableCellView::Asigna la fila y los lienzos de fondo y de primer plano |
//+------------------------------------------------------------------+
void CTableCellView::RowAssign(CTableRowView *base_element)
  {
   if(base_element==NULL)
     {
      ::PrintFormat("%s: Error. Empty element passed",__FUNCTION__);
      return;
     }
   this.m_element_base=base_element;
   this.m_background=this.m_element_base.GetBackground();
   this.m_foreground=this.m_element_base.GetForeground();
   this.m_painter=this.m_element_base.Painter();
   this.m_fore_color=this.m_element_base.ForeColor();
  }

En el método que devuelve las coordenadas X e Y del texto en función del punto de anclaje, añadiremos variables en las que se almacenarán los signos de la dirección del desplazamiento (+1 / -1) en los ejes X e Y:

//+------------------------------------------------------------------+
//| CTableCellView::Devuelve las coordenadas X e Y del texto         |
//| en función del punto de anclaje                                  |
//+------------------------------------------------------------------+
bool CTableCellView::GetTextCoordsByAnchor(int &x,int &y, int &dir_x,int dir_y)
  {
//--- Obtenemos las dimensiones del texto de una celda
   int text_w=0, text_h=0;
   this.m_foreground.TextSize(this.Text(),text_w,text_h);
   if(text_w==0 || text_h==0)
      return false;
//--- Dependiendo del punto de anclaje del texto en la celda
//--- calculamos sus coordenadas iniciales (esquina superior izquierda)
   switch(this.m_text_anchor)
     {
      //--- Punto de anclaje en el centro del lado izquierdo
      case ANCHOR_LEFT :
        x=0;
        y=(this.Height()-text_h)/2;
        dir_x=1;
        dir_y=1;
        break;
      //--- Punto de anclaje en la esquina inferior izquierda
      case ANCHOR_LEFT_LOWER :
        x=0;
        y=this.Height()-text_h;
        dir_x= 1;
        dir_y=-1;
        break;
      //--- Punto de anclaje en el centro del lado inferior
      case ANCHOR_LOWER :
        x=(this.Width()-text_w)/2;
        y=this.Height()-text_h;
        dir_x= 1;
        dir_y=-1;
        break;
      //--- Punto de anclaje en la esquina inferior derecha
      case ANCHOR_RIGHT_LOWER :
        x=this.Width()-text_w;
        y=this.Height()-text_h;
        dir_x=-1;
        dir_y=-1;
        break;
      //--- Punto de anclaje en el centro del lado derecho
      case ANCHOR_RIGHT :
        x=this.Width()-text_w;
        y=(this.Height()-text_h)/2;
        dir_x=-1;
        dir_y= 1;
        break;
      //--- Punto de anclaje en la esquina superior derecha
      case ANCHOR_RIGHT_UPPER :
        x=this.Width()-text_w;
        y=0;
        dir_x=-1;
        dir_y= 1;
        break;
      //--- Punto de anclaje en el centro de la parte superior
      case ANCHOR_UPPER :
        x=(this.Width()-text_w)/2;
        y=0;
        dir_x=1;
        dir_y=1;
        break;
      //--- Punto de anclaje exactamente en el centro del objeto
      case ANCHOR_CENTER :
        x=(this.Width()-text_w)/2;
        y=(this.Height()-text_h)/2;
        dir_x=1;
        dir_y=1;
        break;
      //--- Punto de anclaje en la esquina superior izquierda
      //---ANCHOR_LEFT_UPPER
      default:
        x=0;
        y=0;
        dir_x=1;
        dir_y=1;
        break;
     }
   return true;
  }

En el método que dibuja la apariencia, ahora utilizamos los valores obtenidos como multiplicador para desplazar el texto respecto a los ejes X e Y, y además no dibujamos la celda si se encuentra fuera de su contenedor:

//+------------------------------------------------------------------+
//| CTableCellView::Dibuja la apariencia                             |
//+------------------------------------------------------------------+
void CTableCellView::Draw(const bool chart_redraw)
  {
//--- Si la celda está fuera del contenedor de filas de la tabla, salimos
   if(this.IsOutOfContainer())
      return;
      
//--- Obtenemos las coordenadas del texto y la dirección del desplazamiento en función del punto de anclaje
   int text_x=0, text_y=0;
   int dir_horz=0, dir_vert=0;
   if(!this.GetTextCoordsByAnchor(text_x,text_y,dir_horz,dir_vert))
      return;
//--- Corregimos las coordenadas del texto
   int x=this.AdjX(this.X()+text_x);
   int y=this.AdjY(this.Y()+text_y);
   
//--- Establecemos las coordenadas de la línea divisoria
   int x1=this.AdjX(this.X());
   int x2=this.AdjX(this.X());
   int y1=this.AdjY(this.Y());
   int y2=this.AdjY(this.Bottom());
   
//--- Mostramos el texto en el lienzo de primer plano teniendo en cuenta la dirección del desplazamiento, sin actualizar el gráfico
   this.DrawText(x+this.m_text_x*dir_horz,y+this.m_text_y*dir_vert,this.Text(),false);
   
//--- Si no se trata de la celda situada más a la derecha, dibujamos una línea divisoria vertical a la derecha de la celda.
   if(this.m_element_base!=NULL && this.Index()<this.m_element_base.CellsTotal()-1)
     {
      int line_x=this.AdjX(this.Right());
      this.m_background.Line(line_x,y1,line_x,y2,::ColorToARGB(this.m_element_base.BorderColor(),this.m_element_base.AlphaBG()));
     }
//--- Actualizamos el lienzo de fondo con el indicador de redibujado del gráfico especificado
   this.m_background.Update(chart_redraw);
  }

Ahora el texto de la celda se colocará correctamente, independientemente del punto de anclaje del texto.

Método que devuelve un puntero al contenedor del panel de filas de la tabla:

//+------------------------------------------------------------------+
//| CTableCellView::Devuelve un puntero                              |
//| al contenedor del panel de filas de la tabla                     |
//+------------------------------------------------------------------+
CContainer *CTableCellView::GetRowsPanelContainer(void)
  {
//--- Comprobamos la fila
   if(this.m_element_base==NULL)
      return NULL;
//--- Obtenemos el panel para colocar las filas
   CPanel *rows_area=this.m_element_base.GetContainer();
   if(rows_area==NULL)
      return NULL;
//--- Devolvemos el contenedor del panel con las filas
   return rows_area.GetContainer();
  }

La celda se encuentra dentro de una fila. La fila, junto con otras filas, se encuentra en el panel. El panel, a su vez, está fijado al contenedor, en cuyo interior se puede desplazar mediante barras de desplazamiento. El método devuelve un puntero al contenedor con las barras de desplazamiento.

Método que devuelve un indicador de que el objeto se encuentra fuera de los límites de su contenedor:

//+------------------------------------------------------------------+
//| CTableCellView::Devuelve un indicador de que el objeto           |
//| se encuentra fuera de su contenedor                              |
//+------------------------------------------------------------------+
bool CTableCellView::IsOutOfContainer(void)
  {
//--- Comprobamos la fila
   if(this.m_element_base==NULL)
      return false;

//--- Obtenemos el contenedor del panel con las filas
   CContainer *container=this.GetRowsPanelContainer();
   if(container==NULL)
      return false;
  
//--- Obtenemos los límites de la celda por todos los lados
   int cell_l=this.m_element_base.X()+this.X();
   int cell_r=this.m_element_base.X()+this.Right();
   int cell_t=this.m_element_base.Y()+this.Y();
   int cell_b=this.m_element_base.Y()+this.Bottom();
   
//--- Devolvemos el resultado de comprobar si el objeto está completamente fuera de los límites del contenedor
   return(cell_r <= container.X() || cell_l >= container.Right() || cell_b <= container.Y() || cell_t >= container.Bottom());
  }

La celda se encuentra dentro de su área, situada en una fila. El método calcula las coordenadas de una celda con respecto a la fila y devuelve un indicador que señala si las coordenadas calculadas de la celda se salen de los límites del contenedor.

Ahora vamos a perfeccionar la clase de representación visual de una fila de la tabla, CTableRowView.

Declararemos nuevos métodos y en el destructor vaciaremos la lista de celdas:

//+------------------------------------------------------------------+
//| Clase de representación visual de una fila de una tabla          |
//+------------------------------------------------------------------+
class CTableRowView : public CPanel
  {
protected:
   CTableCellView    m_temp_cell;                                    // Objeto temporal de celda para la búsqueda
   CTableRow        *m_table_row_model;                              // Puntero al modelo de la fila
   CListElm          m_list_cells;                                   // Lista de celdas
   int               m_index;                                        // Índice en la lista de filas
//--- Crea un nuevo objeto de representación de celda y lo añade a la lista
   CTableCellView   *InsertNewCellView(const int index,const string text,const int dx,const int dy,const int w,const int h);
//--- Elimina el área especificada de la fila y la celda con el índice correspondiente
   bool              BoundCellDelete(const int index);
   
public:
//--- Devuelve (1) una lista, (2) el número de celdas, (3) una celda
   CListElm         *GetListCells(void)                                 { return &this.m_list_cells;                       }
   int               CellsTotal(void)                             const { return this.m_list_cells.Total();                }
   CTableCellView   *GetCellView(const uint index)                      { return this.m_list_cells.GetNodeAtIndex(index);  }
   
//--- Establece el identificador
   virtual void      SetID(const int id)                                { this.m_index=this.m_id=id;                       }
//--- (1) Establece, (2) devuelve el índice de la fila
   void              SetIndex(const int index)                          { this.SetID(index);                               }
   int               Index(void)                                  const { return this.m_index;                             }

//--- (1) Establece, (2) devuelve el modelo de fila
   bool              TableRowModelAssign(CTableRow *row_model);
   CTableRow        *GetTableRowModel(void)                             { return this.m_table_row_model;                   }
//--- Actualiza la fila con el modelo actualizado
   bool              TableRowModelUpdate(CTableRow *row_model);

//--- Recalcula las áreas de las celdas
   bool              RecalculateBounds(CListElm *list_bounds);

//--- Muestra en el registro el modelo de fila asignado
   void              TableRowModelPrint(const bool detail, const bool as_table=false, const int cell_width=CELL_WIDTH_IN_CHARS);
   
//--- Dibuja el aspecto visual
   virtual void      Draw(const bool chart_redraw);
   
//--- Métodos virtuales: (1) comparación, (2) guardado en un archivo, (3) carga desde un archivo, (4) tipo de objeto
   virtual int       Compare(const CObject *node,const int mode=0)const { return CLabel::Compare(node,mode);               }
   virtual bool      Save(const int file_handle);
   virtual bool      Load(const int file_handle);
   virtual int       Type(void)                                   const { return(ELEMENT_TYPE_TABLE_ROW_VIEW);             }
  
//--- Inicialización (1) del objeto de la clase, (2) de los colores predeterminados del objeto
   void              Init(void);
   virtual void      InitColors(void);

//--- Constructores/destructor
                     CTableRowView(void);
                     CTableRowView(const string object_name, const string text, const long chart_id, const int wnd, const int x, const int y, const int w, const int h);
                    ~CTableRowView (void){ this.m_list_cells.Clear(); }
  };

En el método para crear y añadir a la lista un nuevo objeto de representación de celda, guardaremos el modo de ordenación de la lista y, tras la adición, restableceremos su ordenación original:

//+------------------------------------------------------------------+
//| CTableRowView::Crea y añade a la lista                           |
//| un nuevo objeto de representación de celda                       |
//+------------------------------------------------------------------+
CTableCellView *CTableRowView::InsertNewCellView(const int index,const string text,const int dx,const int dy,const int w,const int h)
  {
//--- Comprobamos si hay algún objeto en la lista con el identificador indicado y, si lo hay, lo indicamos y devolvemos NULL
   this.m_temp_cell.SetIndex(index);
//--- Guardamos el método de ordenación de la lista
   int sort_mode=this.m_list_cells.SortMode();
//--- Establecemos el indicador de ordenación por identificador en la lista
   this.m_list_cells.Sort(ELEMENT_SORT_BY_ID);
   if(this.m_list_cells.Search(&this.m_temp_cell)!=NULL)
     {
      //--- Retornamos la lista de ordenación inicial, notificamos que ese objeto ya existe y devolvemos NULL
      this.m_list_cells.Sort(sort_mode);
      ::PrintFormat("%s: Error. The TableCellView object with index %d is already in the list",__FUNCTION__,index);
      return NULL;
     }
//--- Restablecemos la ordenación original de la lista
   this.m_list_cells.Sort(sort_mode);
//--- Creamos el nombre del objeto de celda
   string name="TableCellView"+(string)this.Index()+"x"+(string)index;

//--- Creamos un nuevo objeto TableCellView; si la creación falla, lo notificamos y devolvemos NULL
   CTableCellView *cell_view=new CTableCellView(index,name,text,dx,dy,w,h);
   if(cell_view==NULL)
     {
      ::PrintFormat("%s: Error. Failed to create CTableCellView object",__FUNCTION__);
      return NULL;
     }
//--- Si no se ha podido añadir el nuevo objeto a la lista, lo notificamos, eliminamos el objeto y devolvemos NULL
   if(this.m_list_cells.Add(cell_view)==-1)
     {
      ::PrintFormat("%s: Error. Failed to add CTableCellView object to list",__FUNCTION__);
      delete cell_view;
      return NULL;
     }
//--- Asignamos el elemento base (fila) y devolvemos un puntero al objeto
   cell_view.RowAssign(&this);
   return cell_view;
  }

En el método de configuración del modelo de fila, calcularemos el ancho de las columnas en función del ancho del panel de filas, y no del de la propia fila, ya que la fila es ligeramente más estrecha que el panel. El ancho del encabezado de la tabla también es igual al ancho del panel de filas, por lo que, para que el ancho de las celdas y de las columnas coincida, utilizamos el ancho del panel:

//+------------------------------------------------------------------+
//| CTableRowView::Establece el modelo de fila                       |
//+------------------------------------------------------------------+
bool CTableRowView::TableRowModelAssign(CTableRow *row_model)
  {
//--- Si se pasa un objeto vacío, lo indicamos y devolvemos false
   if(row_model==NULL)
     {
      ::PrintFormat("%s: Error. Empty object passed",__FUNCTION__);
      return false;
     }
//--- Si el modelo de fila recibido no contiene ninguna celda, lo indicamos y devolvemos false
   int total=(int)row_model.CellsTotal();
   if(total==0)
     {
      ::PrintFormat("%s: Error. Row model does not contain any cells",__FUNCTION__);
      return false;
     }
//--- Guardamos un puntero al modelo de fila recibido
   this.m_table_row_model=row_model;
//--- calculamos el ancho de la celda en función del ancho del panel de filas
   CCanvasBase *base=this.GetContainer();
   int w=(base!=NULL ? base.Width() : this.Width());
   int cell_w=(int)::fmax(::round((double)w/(double)total),DEF_TABLE_COLUMN_MIN_W);

//--- En un bucle según el número de celdas del modelo de la fila
   for(int i=0;i<total;i++)
     {
      //--- obtenemos el modelo de la siguiente celda,
      CTableCell *cell_model=this.m_table_row_model.GetCell(i);
      if(cell_model==NULL)
         return false;
      //--- calculamos la coordenada y creamos un nombre para el área de la celda
      int x=cell_w*i;
      string name="CellBound"+(string)this.m_table_row_model.Index()+"x"+(string)i;
      //--- Creamos una nueva área de celda
      CBound *cell_bound=this.InsertNewBound(name,x,0,cell_w,this.Height());
      if(cell_bound==NULL)
         return false;
      //--- Creamos un nuevo objeto de representación visual de una celda
      CTableCellView *cell_view=this.InsertNewCellView(i,cell_model.Value(),x,0,cell_w,this.Height());
      if(cell_view==NULL)
         return false;
      //--- Asignamos al área actual de la celda el objeto de representación visual correspondiente a dicha celda
      cell_bound.AssignObject(cell_view);
     }
//--- Todo ha salido bien
   return true;
  }

Las celdas de una fila de la tabla pueden actualizar su aspecto, por ejemplo, al añadir o eliminar una columna de la tabla. Estos cambios, realizados en el modelo de la tabla, deben reflejarse también en la representación visual de la tabla.

Creemos un método específico para ello.

Método que actualiza la fila con el modelo actualizado:

//+------------------------------------------------------------------+
//| CTableRowView::Actualiza la fila con el modelo actualizado       |
//+------------------------------------------------------------------+
bool CTableRowView::TableRowModelUpdate(CTableRow *row_model)
  {
//--- Si se pasa un objeto vacío, lo indicamos y devolvemos «false»
   if(row_model==NULL)
     {
      ::PrintFormat("%s: Error. Empty object passed",__FUNCTION__);
      return false;
     }
//--- Si el modelo de fila recibido no contiene ninguna celda, lo indicamos y devolvemos false
   int total_model=(int)row_model.CellsTotal(); // Número de celdas en el modelo de fila
   if(total_model==0)
     {
      ::PrintFormat("%s: Error. Row model does not contain any cells",__FUNCTION__);
      return false;
     }
//--- Guardamos un puntero al modelo de fila recibido
   this.m_table_row_model=row_model;

//--- Calculamos el ancho de la celda en función del ancho del panel de filas
   CCanvasBase *base=this.GetContainer();
   int w=(base!=NULL ? base.Width() : this.Width());
   int cell_w=(int)::fmax(::round((double)w/(double)total_model),DEF_TABLE_COLUMN_MIN_W);
   
   CBound *cell_bound=NULL;
   int total_bounds=this.m_list_bounds.Total(); // Número de áreas
   int diff=total_model-total_bounds;           // La diferencia entre el número de áreas de la fila y el número de celdas del modelo de la fila
   
//--- Si el modelo tiene más celdas que áreas en la lista, crearemos las áreas y celdas que falten al final de las listas
   if(diff>0)
     {
      //--- En un bucle según el número de áreas que faltan
      for(int i=total_bounds;i<total_bounds+diff;i++)
        {
         //--- creamos y añadimos a la lista una cantidad de áreas de celdas de la fila igual a diff.
         //--- Obtenemos el modelo de la siguiente celda,
         CTableCell *cell_model=this.m_table_row_model.GetCell(i);
         if(cell_model==NULL)
            return false;
         //--- calculamos la coordenada y creamos un nombre para el área de la celda
         int x=cell_w*i;
         string name="CellBound"+(string)this.m_table_row_model.Index()+"x"+(string)i;
         //--- Creamos una nueva área de celda
         CBound *cell_bound=this.InsertNewBound(name,x,0,cell_w,this.Height());
         if(cell_bound==NULL)
            return false;
            
         //--- Creamos un nuevo objeto de representación visual de una celda
         CTableCellView *cell_view=this.InsertNewCellView(i,cell_model.Value(),x,0,cell_w,this.Height());
         if(cell_view==NULL)
            return false;
        }
     }
 
//--- Si en la lista hay más áreas que celdas en el modelo, eliminaremos las áreas sobrantes al final de la lista
   if(diff<0)
     {
      int  start=total_bounds-1;
      int  end=start-diff;
      bool res=true;
      for(int i=start;i>end;i--)
        {
         if(!this.BoundCellDelete(i))
            return false;
        }
     }
   
//--- En un bucle según el número de celdas del modelo de la fila
   for(int i=0;i<total_model;i++)
     {
      //--- obtenemos el modelo de la siguiente celda,
      CTableCell *cell_model=this.m_table_row_model.GetCell(i);
      if(cell_model==NULL)
         return false;
      
      //--- calculamos la coordenada de la celda
      int x=cell_w*i;
      //--- Obtenemos la siguiente área de la celda
      CBound *cell_bound=this.GetBoundAt(i);
      if(cell_bound==NULL)
         return false;
      
      //--- Obtenemos de la lista el objeto de representación visual de la celda
      CTableCellView *cell_view=this.m_list_cells.GetNodeAtIndex(i);
      if(cell_view==NULL)
         return false;
      
      //--- Asignamos al área actual de la celda el objeto de representación visual correspondiente y su texto
      cell_bound.AssignObject(cell_view);
      cell_view.SetText(cell_model.Value());
     }
//--- Todo ha salido bien
   return true;
  }

La lógica del método se explica en los comentarios del código. Si se han añadido o eliminado columnas en el modelo de la tabla, también se añade o elimina el número correspondiente de celdas en la representación visual de la fila. A continuación, en un bucle que recorre las celdas de la fila en el modelo de la tabla, asignamos al área de cada celda el objeto de representación visual correspondiente.

Método que elimina el área especificada de la fila y la celda con el índice correspondiente:

//+------------------------------------------------------------------+
//| CTableRowView::Elimina el área especificada de la fila           |
//| y la celda con el índice correspondiente                         |
//+------------------------------------------------------------------+
bool CTableRowView::BoundCellDelete(const int index)
  {
   if(!this.m_list_cells.Delete(index))
      return false;
   return this.m_list_bounds.Delete(index);
  }

Si el objeto de la celda se ha eliminado correctamente de la lista, eliminamos también el área correspondiente de la lista de áreas.

En el método que dibuja el aspecto de la fila, comprobamos si la fila se sale de los límites del contenedor:

//+------------------------------------------------------------------+
//| CTableRowView::Dibuja la apariencia                              |
//+------------------------------------------------------------------+
void CTableRowView::Draw(const bool chart_redraw)
  {
//--- Si la fila queda fuera del contenedor, salimos
   if(this.IsOutOfContainer())
      return;

//--- Rellenamos el objeto con el color de fondo, dibujamos la línea de la fila y actualizamos el lienzo de fondo
   this.Fill(this.BackColor(),false);
   this.m_background.Line(this.AdjX(0),this.AdjY(this.Height()-1),this.AdjX(this.Width()-1),this.AdjY(this.Height()-1),::ColorToARGB(this.BorderColor(),this.AlphaBG()));
  
//--- Dibujamos las celdas de la fila
   int total=this.m_list_bounds.Total();
   for(int i=0;i<total;i++)
     {
      //--- Obtenemos el área de la siguiente celda
      CBound *cell_bound=this.GetBoundAt(i);
      if(cell_bound==NULL)
         continue;
      
      //--- A partir del área de la celda obtenemos el objeto de celda asociado
      CTableCellView *cell_view=cell_bound.GetAssignedObj();
      //--- Dibujamos la representación visual de la celda
      if(cell_view!=NULL)
         cell_view.Draw(false);
     }
//--- Actualizamos los lienzos de fondo y primer plano con el indicador de redibujado del gráfico especificado
   this.Update(chart_redraw);
  }

Una fila que no se encuentre en el área visible del contenedor no debe dibujarse.

Al modificar el ancho de una columna, es necesario modificar el ancho de todas las celdas que pertenecen a dicha columna y desplazar las celdas adyacentes a las nuevas coordenadas. Escribamos un nuevo método para ello.

Método que recalcula las áreas de las celdas:

//+------------------------------------------------------------------+
//| CTableRowView::Recalcula las áreas de las celdas                 |
//+------------------------------------------------------------------+
bool CTableRowView::RecalculateBounds(CListElm *list_bounds)
  {
//--- Revisamos la lista
   if(list_bounds==NULL)
      return false;

//--- En un bucle según el número de áreas de la lista
   for(int i=0;i<list_bounds.Total();i++)
     {
      //--- obtenemos la siguiente área del encabezado y el área de la celda correspondiente
      CBound *capt_bound=list_bounds.GetNodeAtIndex(i);
      CBound *cell_bound=this.GetBoundAt(i);
      if(capt_bound==NULL || cell_bound==NULL)
         return false;

      //--- En el área de la celda, establecemos la coordenada y el tamaño del área del encabezado
      cell_bound.SetX(capt_bound.X());
      cell_bound.ResizeW(capt_bound.Width());
      
      //--- A partir del área de la celda obtenemos el objeto de celda asociado
      CTableCellView *cell_view=cell_bound.GetAssignedObj();
      if(cell_view==NULL)
         return false;

      //--- En el objeto de representación visual de la celda, establecemos la coordenada y el tamaño del área de la celda
      cell_view.BoundSetX(cell_bound.X());
      cell_view.BoundResizeW(cell_bound.Width());
     }
//--- Todo ha salido bien
   return true;
  }

Al método se le pasa una lista de las áreas de los encabezados de las columnas. En función de las propiedades de las áreas de las columnas de la lista proporcionada, se modifican las dimensiones y las coordenadas de las áreas de las celdas de la tabla. Tanto las nuevas dimensiones como las coordenadas de las áreas se establecen en los objetos de celda correspondientes.

En el paradigma MVC, el encabezado de la tabla no es simplemente una parte de la tabla, sino que constituye un control independiente mediante el cual se puede modificar y gestionar el aspecto de las columnas de la tabla. El encabezado de columna, en este contexto, también es un elemento de control. En el contexto de este proyecto, el encabezado de la columna permite cambiar el tamaño de la columna, aplicar las mismas propiedades a todas las celdas de la columna, etc.

De este modo, en la clase de encabezado de columna y en la clase de encabezado de la tabla se han reunido las principales mejoras que permiten «dar vida» a la tabla.

Vamos a perfeccionar la clase de representación visual del encabezado de columna de la tabla, CColumnCaptionView.

El encabezado de la columna, como elemento de control, permitirá controlar el tamaño (ancho) de la columna y el sentido de la ordenación, o la ausencia de esta. Al hacer clic en el encabezado, aparecerá una flecha que indica la dirección de ordenación. Si no hay ninguna ordenación (al hacer clic en otro encabezado), la flecha no aparece. Si se sitúa el cursor sobre el borde derecho del encabezado, aparecerá junto al cursor una flecha de sugerencia que indica la dirección del desplazamiento. En ese caso, si se mantiene pulsado el botón del ratón y se arrastra el borde, el ancho de la columna cambiará y la posición de las columnas de la derecha se ajustará: se desplazarán siguiendo el borde derecho de la columna que se está modificando.

Declararemos nuevas variables y métodos:

//+------------------------------------------------------------------+
//| Clase de representación visual del encabezado de la columna de la tabla        |
//+------------------------------------------------------------------+
class CColumnCaptionView : public CButton
  {
protected:
   CColumnCaption   *m_column_caption_model;                         // Puntero al modelo del encabezado de columna
   CBound           *m_bound_node;                                   // Puntero al área del encabezado
   int               m_index;                                        // Índice en la lista de columnas
   ENUM_TABLE_SORT_MODE m_sort_mode;                                 // Modo de ordenación de una columna de la tabla
   
//--- Añade a la lista los objetos de sugerencia con flechas
   virtual bool      AddHintsArrowed(void);
//--- Muestra el cursor de redimensionamiento
   virtual bool      ShowCursorHint(const ENUM_CURSOR_REGION edge,int x,int y);
   
public:
//--- Establece el identificador
   virtual void      SetID(const int id)                                { this.m_index=this.m_id=id;                 }
//--- (1) Establece, (2) devuelve el índice de la celda
   void              SetIndex(const int index)                          { this.SetID(index);                         }
   int               Index(void)                                  const { return this.m_index;                       }
   
//--- (1) Asigna, (2) devuelve el área del encabezado a la que se ha asignado el objeto
   void              AssignBoundNode(CBound *bound)                     { this.m_bound_node=bound;                   }
   CBound           *GetBoundNode(void)                                 { return this.m_bound_node;                  }

//--- (1) Asigna, (2) devuelve el modelo del encabezado de columna
   bool              ColumnCaptionModelAssign(CColumnCaption *caption_model);
   CColumnCaption   *ColumnCaptionModel(void)                           { return this.m_column_caption_model;        }

//--- Muestra en el registro el modelo de encabezado de columna asignado
   void              ColumnCaptionModelPrint(void);

//--- (1) Establece, (2) devuelve el modo de ordenación
   void              SetSortMode(const ENUM_TABLE_SORT_MODE mode)       { this.m_sort_mode=mode;                     }
   ENUM_TABLE_SORT_MODE SortMode(void)                            const { return this.m_sort_mode;                   }
   
//--- Establece la dirección de ordenación opuesta
   void              SetSortModeReverse(void);
   
//--- Dibuja (1) el aspecto general y (2) la flecha que indica la dirección de la ordenación
   virtual void      Draw(const bool chart_redraw);
protected:
   void              DrawSortModeArrow(void);
public:  
//--- Manejador del cambio de tamaño del elemento por el lado derecho
   virtual bool      ResizeZoneRightHandler(const int x, const int y);
   
//--- Manejadores del cambio de tamaño del elemento por los lados y las esquinas
   virtual bool      ResizeZoneLeftHandler(const int x, const int y)       { return false;                           }
   virtual bool      ResizeZoneTopHandler(const int x, const int y)        { return false;                           }
   virtual bool      ResizeZoneBottomHandler(const int x, const int y)     { return false;                           }
   virtual bool      ResizeZoneLeftTopHandler(const int x, const int y)    { return false;                           }
   virtual bool      ResizeZoneRightTopHandler(const int x, const int y)   { return false;                           }
   virtual bool      ResizeZoneLeftBottomHandler(const int x, const int y) { return false;                           }
   virtual bool      ResizeZoneRightBottomHandler(const int x, const int y){ return false;                           }
   
//--- Modifica el ancho del objeto
   virtual bool      ResizeW(const int w);
   
//--- Manejador de eventos de pulsación de botones del ratón (Press)
   virtual void      OnPressEvent(const int id, const long lparam, const double dparam, const string sparam);
   
//--- Métodos virtuales: (1) comparación, (2) guardado en un archivo, (3) carga desde un archivo, (4) tipo de objeto
   virtual int       Compare(const CObject *node,const int mode=0)const { return CButton::Compare(node,mode);        }
   virtual bool      Save(const int file_handle);
   virtual bool      Load(const int file_handle);
   virtual int       Type(void)                                   const { return(ELEMENT_TYPE_TABLE_COLUMN_CAPTION_VIEW);}
  
//--- Inicialización (1) del objeto de la clase, (2) de los colores predeterminados del objeto
   void              Init(const string text);
   virtual void      InitColors(void);
   
//--- Devuelve la descripción del objeto
   virtual string    Description(void);
   
//--- Constructores/destructor
                     CColumnCaptionView(void);
                     CColumnCaptionView(const string object_name, const string text, const long chart_id, const int wnd, const int x, const int y, const int w, const int h); 
                    ~CColumnCaptionView (void){}
  };

Analicemos las modificaciones de los métodos ya escritos y la implementación de nuevos métodos de la clase.

En el constructor, estableceremos que, por defecto, no se aplique ninguna ordenación:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Constructor por defecto. Crea el objeto      |
//| en la ventana principal del gráfico actual, en las coordenadas 0,0|
//| con las dimensiones predeterminadas                              |
//+------------------------------------------------------------------+
CColumnCaptionView::CColumnCaptionView(void) : CButton("ColumnCaption","Caption",::ChartID(),0,0,0,DEF_PANEL_W,DEF_TABLE_ROW_H), m_index(0), m_sort_mode(TABLE_SORT_MODE_NONE)
  {
//--- Inicialización
   this.Init("Caption");
   this.SetID(0);
   this.SetName("ColumnCaption");
  }
//+------------------------------------------------------------------+
//| CColumnCaptionView::Constructor parametrizado.                   |
//| Crea el objeto en la ventana indicada del gráfico indicado con   |
//| el texto, las coordenadas y las dimensiones especificados        |
//+------------------------------------------------------------------+
CColumnCaptionView::CColumnCaptionView(const string object_name, const string text, const long chart_id, const int wnd, const int x, const int y, const int w, const int h) :
   CButton(object_name,text,chart_id,wnd,x,y,w,h), m_index(0), m_sort_mode(TABLE_SORT_MODE_NONE)
  {
//--- Inicialización
   this.Init(text);
   this.SetID(0);
  }

En el método de inicialización, permitiremos cambiar las dimensiones, impediremos mover el objeto y definiremos el área de imagen para la flecha que indica la dirección de la ordenación:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Inicialización                               |
//+------------------------------------------------------------------+
void CColumnCaptionView::Init(const string text)
  {
//--- Desplazamientos predeterminados del texto
   this.m_text_x=4;
   this.m_text_y=2;
//--- Configuramos los colores de los distintos estados
   this.InitColors();
//--- Se pueden modificar las dimensiones
   this.SetResizable(true);
   this.SetMovable(false);
   this.SetImageBound(this.ObjectWidth()-14,4,8,11);
  }

En el método que dibuja la apariencia del objeto, comprobaremos que el objeto no se encuentre fuera del contenedor y llamaremos al método que dibuja la flecha que indica la dirección de la ordenación:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Dibuja la apariencia                         |
//+------------------------------------------------------------------+
void CColumnCaptionView::Draw(const bool chart_redraw)
  {
//--- Si el objeto está fuera de su contenedor, salimos
   if(this.IsOutOfContainer())
      return;

//--- Rellenamos el objeto con el color de fondo, dibujamos una línea vertical clara a la izquierda y otra oscura a la derecha
   this.Fill(this.BackColor(),false);
   color clr_dark =this.BorderColor();                                                       // "Color oscuro"
   color clr_light=this.GetBackColorControl().NewColor(this.BorderColor(), 100, 100, 100);   // "Color claro"
   this.m_background.Line(this.AdjX(0),this.AdjY(0),this.AdjX(0),this.AdjY(this.Height()-1),::ColorToARGB(clr_light,this.AlphaBG()));                          // La línea de la izquierda
   this.m_background.Line(this.AdjX(this.Width()-1),this.AdjY(0),this.AdjX(this.Width()-1),this.AdjY(this.Height()-1),::ColorToARGB(clr_dark,this.AlphaBG())); // La línea de la derecha
//--- Actualizamos el lienzo de fondo
   this.m_background.Update(false);
   
//--- Mostramos el texto del encabezado
   CLabel::Draw(false);
      
//--- Dibujamos las flechas que indican la dirección de la ordenación
   this.DrawSortModeArrow();

//--- Si se indica, actualizamos el gráfico
   if(chart_redraw)
      ::ChartRedraw(this.m_chart_id);
  }

Método que dibuja la flecha que indica la dirección de la ordenación:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Dibuja la flecha que indica la dirección de la ordenación|
//+------------------------------------------------------------------+
void CColumnCaptionView::DrawSortModeArrow(void)
  {
//--- Establecemos el color de la flecha para los estados normal y bloqueado del objeto
   color clr=(!this.IsBlocked() ? this.GetForeColorControl().NewColor(this.ForeColor(),90,90,90) : this.ForeColor());
   switch(this.m_sort_mode)
     {
      //--- Ordenación de menor a mayor
      case TABLE_SORT_MODE_ASC   :  
         //--- Limpiamos el área del dibujo y dibujamos una flecha hacia abajo
         this.m_painter.Clear(this.AdjX(this.m_painter.X()),this.AdjY(this.m_painter.Y()),this.m_painter.Width(),this.m_painter.Height(),false);
         this.m_painter.ArrowDown(this.AdjX(this.m_painter.X()),this.AdjY(this.m_painter.Y()),this.m_painter.Width(),this.m_painter.Height(),clr,this.AlphaFG(),true);
         break;
      //--- Ordenación de mayor a menor
      case TABLE_SORT_MODE_DESC  :  
         //--- Limpiamos el área del dibujo y dibujamos una flecha hacia arriba
         this.m_painter.Clear(this.AdjX(this.m_painter.X()),this.AdjY(this.m_painter.Y()),this.m_painter.Width(),this.m_painter.Height(),false);
         this.m_painter.ArrowUp(this.AdjX(this.m_painter.X()),this.AdjY(this.m_painter.Y()),this.m_painter.Width(),this.m_painter.Height(),clr,this.AlphaFG(),true);
         break;
      //--- Sin ordenación
      default : 
         //--- Limpiamos el área de la imagen
         this.m_painter.Clear(this.AdjX(this.m_painter.X()),this.AdjY(this.m_painter.Y()),this.m_painter.Width(),this.m_painter.Height(),false);
         break;
     }
  }

Dependiendo de la dirección de la ordenación, dibujamos la flecha correspondiente:

  • en orden ascendente: la flecha hacia abajo,
  • en orden descendente: la flecha hacia arriba,
  • sin ordenación: simplemente borramos el dibujo de la flecha.

Método que invierte la dirección de la ordenación:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Invierte la dirección de la ordenación       |
//+------------------------------------------------------------------+
void CColumnCaptionView::SetSortModeReverse(void)
  {
   switch(this.m_sort_mode)
     {
      case TABLE_SORT_MODE_ASC   :  this.m_sort_mode=TABLE_SORT_MODE_DESC; break;
      case TABLE_SORT_MODE_DESC  :  this.m_sort_mode=TABLE_SORT_MODE_ASC;  break;
      default                    :  break;
     }
  }

Si la ordenación actual está configurada en orden ascendente, la cambiamos a orden descendente, y viceversa. El estado sin ordenación se establece en otro método, ya que este solo sirve para alternar el sentido de la ordenación al hacer clic en el encabezado de una columna.

Método que añade a la lista objetos de sugerencia con flechas:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Añade a la lista                             |
//| objetos de sugerencia con flechas                                |
//+------------------------------------------------------------------+
bool CColumnCaptionView::AddHintsArrowed(void)
  {
//--- Creamos una sugerencia con una flecha de desplazamiento horizontal
   CVisualHint *hint=this.CreateAndAddNewHint(HINT_TYPE_ARROW_SHIFT_HORZ,DEF_HINT_NAME_SHIFT_HORZ,18,18);
   if(hint==NULL)
      return false;

//--- Establecemos el tamaño del área de la imagen de la sugerencia
   hint.SetImageBound(0,0,hint.Width(),hint.Height());
   
//--- ocultamos la sugerencia y dibujamos su aspecto
   hint.Hide(false);
   hint.Draw(false);
   
//--- Todo ha salido bien
   return true;
  }

Se crea una nueva sugerencia y se añade a la lista. Después, se puede obtener de la lista por su nombre.

Método que muestra el cursor de redimensionamiento:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Muestra el cursor de redimensionamiento      |
//+------------------------------------------------------------------+
bool CColumnCaptionView::ShowCursorHint(const ENUM_CURSOR_REGION edge,int x,int y)
  {
   CVisualHint *hint=NULL;          // Puntero a la sugerencia
   int hint_shift_x=0;              // Desplazamiento de la sugerencia en el eje X
   int hint_shift_y=0;              // Desplazamiento de la sugerencia en el eje Y
   
//--- Dependiendo de la posición del cursor en los límites del elemento
//--- indicamos los desplazamientos de la sugerencia con respecto a las coordenadas del cursor,
//--- mostramos la sugerencia deseada en el gráfico y obtenemos un puntero a ese objeto
   if(edge!=CURSOR_REGION_RIGHT)
      return false;
   
   hint_shift_x=-8;
   hint_shift_y=-12;
   this.ShowHintArrowed(HINT_TYPE_ARROW_SHIFT_HORZ,x+hint_shift_x,y+hint_shift_y);
   hint=this.GetHint(DEF_HINT_NAME_SHIFT_HORZ);

//--- Devolvemos el resultado del ajuste de la posición de la sugerencia con respecto al cursor
   return(hint!=NULL ? hint.Move(x+hint_shift_x,y+hint_shift_y) : false);
  }

El método solo funciona cuando el cursor se encuentra sobre el borde derecho del elemento. Muestra la sugerencia y la desplaza hasta la posición del cursor con el desplazamiento establecido.

Manejador del cambio de tamaño mediante el borde derecho:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Manejador del cambio de tamaño mediante el borde derecho|
//+------------------------------------------------------------------+
bool CColumnCaptionView::ResizeZoneRightHandler(const int x,const int y)
  {
//--- Calculamos y establecemos el nuevo ancho del elemento
   int width=::fmax(x-this.X()+1,DEF_TABLE_COLUMN_MIN_W);
   if(!this.ResizeW(width))
      return false;
//--- Obtenemos un puntero a la sugerencia
   CVisualHint *hint=this.GetHint(DEF_HINT_NAME_SHIFT_HORZ);
   if(hint==NULL)
      return false;
//--- Desplazamos la sugerencia las cantidades indicadas con respecto al cursor
   int shift_x=-8;
   int shift_y=-12;
   
   CTableHeaderView *header=this.m_container;
   if(header==NULL)
      return false;
   
   bool res=header.RecalculateBounds(this.GetBoundNode(),this.Width());
   res &=hint.Move(x+shift_x,y+shift_y);
   if(res)
      ::ChartRedraw(this.m_chart_id);
   return res;
  }

Al arrastrar el borde derecho del elemento, este debe cambiar su ancho en función de la dirección del desplazamiento del cursor. Primero se modifica el ancho del elemento, después se muestra una sugerencia y, a continuación, se invoca el método RecalculateBounds() del encabezado de la tabla para recalcular las áreas de los encabezados de las columnas. Este método establece un nuevo tamaño para el área del encabezado modificado y desplaza todas las áreas de los encabezados de columna adyacentes a él a las nuevas coordenadas.

Método virtual que modifica el ancho de un objeto:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Cambia el ancho del objeto                   |
//+------------------------------------------------------------------+
bool CColumnCaptionView::ResizeW(const int w)
  {
   if(!CCanvasBase::ResizeW(w))
      return false;
//--- Borramos el área de dibujo en su ubicación anterior
   this.m_painter.Clear(this.AdjX(this.m_painter.X()),this.AdjY(this.m_painter.Y()),this.m_painter.Width(),this.m_painter.Height(),false);
//--- Establecemos una nueva área de dibujo
   this.SetImageBound(this.Width()-14,4,8,11);
   return true;
  }

Al cambiar el tamaño del encabezado de una columna, es necesario desplazar el área de dibujo (la flecha de dirección de ordenación) para que la flecha se dibuje en el lugar adecuado, junto al borde derecho del elemento.

Manejador de eventos de pulsación de botones del ratón:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Manejador de eventos de pulsación de botones del ratón      |
//+------------------------------------------------------------------+
void CColumnCaptionView::OnPressEvent(const int id,const long lparam,const double dparam,const string sparam)
  {
//--- Si se suelta el botón del ratón dentro del área de arrastre del borde derecho del elemento, salimos
   if(this.ResizeRegion()==CURSOR_REGION_RIGHT)
      return;
//--- Invertimos la dirección de la flecha de ordenación y llamamos al manejador de clics del ratón
   this.SetSortModeReverse();
   CCanvasBase::OnPressEvent(id,lparam,dparam,sparam);
  }

Si el evento de clic se debe a que se ha soltado el botón del ratón en el área de arrastre —lo que significa que acaba de completarse el cambio de tamaño del encabezado—, salimos del método. A continuación, invertimos la dirección de la flecha de ordenación y llamamos al manejador de eventos de los botones del ratón del objeto base.

En los métodos de gestión de archivos, guardamos y cargamos el valor de la dirección de ordenación:

//+------------------------------------------------------------------+
//| CColumnCaptionView::Guardar en un archivo                        |
//+------------------------------------------------------------------+
bool CColumnCaptionView::Save(const int file_handle)
  {
//--- Guardamos los datos del objeto padre
   if(!CButton::Save(file_handle))
      return false;
  
//--- Guardamos el número del encabezado
   if(::FileWriteInteger(file_handle,this.m_index,INT_VALUE)!=INT_VALUE)
      return false;
//--- Guardamos la dirección de ordenación
   if(::FileWriteInteger(file_handle,this.m_sort_mode,INT_VALUE)!=INT_VALUE)
      return false;
      
//--- Todo ha salido bien
   return true;
  }
//+------------------------------------------------------------------+
//| CColumnCaptionView::Carga desde archivo                          |
//+------------------------------------------------------------------+
bool CColumnCaptionView::Load(const int file_handle)
  {
//--- Cargamos los datos del objeto padre
   if(!CButton::Load(file_handle))
      return false;
      
//--- Cargamos el número del encabezado
   this.m_id=this.m_index=::FileReadInteger(file_handle,INT_VALUE);
//--- Cargamos el sentido de ordenación
   this.m_id=this.m_sort_mode=(ENUM_TABLE_SORT_MODE)::FileReadInteger(file_handle,INT_VALUE);
   
//--- Todo ha salido bien
   return true;
  }

Ahora vamos a perfeccionar la clase de representación visual del encabezado de la tabla, CTableHeaderView.

Un objeto de esta clase contiene una lista de los encabezados de las columnas que gestiona y proporciona al usuario un elemento de control para modificar el aspecto de las columnas de la tabla y ordenar por cualquiera de ellas.

Declararemos los nuevos métodos de la clase:

//+------------------------------------------------------------------+
//| Clase de representación visual del encabezado de la tabla        |
//+------------------------------------------------------------------+
class CTableHeaderView : public CPanel
  {
protected:
   CColumnCaptionView m_temp_caption;                                // Objeto temporal del encabezado de columna para la búsqueda
   CTableHeader     *m_table_header_model;                           // Puntero al modelo del encabezado de la tabla

//--- Crea y añade a la lista un nuevo objeto de representación del encabezado de columna
   CColumnCaptionView *InsertNewColumnCaptionView(const string text, const int x, const int y, const int w, const int h);
   
public:
//--- (1) Establece, (2) devuelve el modelo del encabezado de la tabla
   bool              TableHeaderModelAssign(CTableHeader *header_model);
   CTableHeader     *GetTableHeaderModel(void)                          { return this.m_table_header_model;    }

//--- Recalcula las áreas de los encabezados
   bool              RecalculateBounds(CBound *bound,int new_width);

//--- Muestra en el registro el modelo asignado al encabezado de la tabla
   void              TableHeaderModelPrint(const bool detail, const bool as_table=false, const int cell_width=CELL_WIDTH_IN_CHARS);
   
//--- Dibuja el aspecto visual
   virtual void      Draw(const bool chart_redraw);
   
//--- Establece un indicador de ordenación en el encabezado de la columna
   void              SetSortedColumnCaption(const uint index);

//--- Obtiene el encabezado de la columna (1) por índice, (2) con el indicador de ordenación
   CColumnCaptionView *GetColumnCaption(const uint index);
   CColumnCaptionView *GetSortedColumnCaption(void);
//--- Devuelve el índice del encabezado de la columna con el indicador de ordenación
   int               IndexSortedColumnCaption(void);
   
//--- Métodos virtuales: (1) comparación, (2) guardado en un archivo, (3) carga desde un archivo, (4) tipo de objeto
   virtual int       Compare(const CObject *node,const int mode=0)const { return CPanel::Compare(node,mode);      }
   virtual bool      Save(const int file_handle)                        { return CPanel::Save(file_handle);       }
   virtual bool      Load(const int file_handle)                        { return CPanel::Load(file_handle);       }
   virtual int       Type(void)                                   const { return(ELEMENT_TYPE_TABLE_HEADER_VIEW); }
   
//--- Manejador del evento de usuario del elemento al hacer clic en el área del objeto
   virtual void      MousePressHandler(const int id, const long lparam, const double dparam, const string sparam);
  
//--- Inicialización (1) del objeto de la clase, (2) de los colores predeterminados del objeto
   void              Init(void);
   virtual void      InitColors(void);

//--- Constructores/destructor
                     CTableHeaderView(void);
                     CTableHeaderView(const string object_name, const string text, const long chart_id, const int wnd, const int x, const int y, const int w, const int h);
                    ~CTableHeaderView (void){}
  };

Analicemos las mejoras de los métodos existentes y la implementación de los métodos declarados.

En el método que establece el modelo del encabezado, calcularemos el ancho de los encabezados teniendo en cuenta el ancho mínimo de cada uno, estableceremos correctamente el identificador del encabezado, asignaremos al encabezado el área que le corresponde y para el primer encabezado estableceremos el indicador de ordenación ascendente:

//+------------------------------------------------------------------+
//| CTableHeaderView::Establece el modelo del encabezado             |
//+------------------------------------------------------------------+
bool CTableHeaderView::TableHeaderModelAssign(CTableHeader *header_model)
  {
//--- Si se pasa un objeto vacío, lo indicamos y devolvemos false
   if(header_model==NULL)
     {
      ::PrintFormat("%s: Error. Empty object passed",__FUNCTION__);
      return false;
     }
//--- Si en el modelo de encabezado facilitado no hay ningún encabezado de columna, lo indicamos y devolvemos «false»
   int total=(int)header_model.ColumnsTotal();
   if(total==0)
     {
      ::PrintFormat("%s: Error. Header model does not contain any columns",__FUNCTION__);
      return false;
     }
//--- Guardamos un puntero al modelo de encabezado de la tabla que se nos ha pasado y calculamos el ancho de cada encabezado de columna
   this.m_table_header_model=header_model;
   int caption_w=(int)::fmax(::round((double)this.Width()/(double)total),DEF_TABLE_COLUMN_MIN_W);

//--- En un bucle que recorre los encabezados de columna del modelo de encabezado de la tabla
   for(int i=0;i<total;i++)
     {
      //--- obtenemos el modelo del siguiente encabezado de columna,
      CColumnCaption *caption_model=this.m_table_header_model.GetColumnCaption(i);
      if(caption_model==NULL)
         return false;
      //--- calculamos la coordenada y creamos un nombre para el área del encabezado de la columna
      int x=caption_w*i;
      string name="CaptionBound"+(string)i;
      //--- Creamos una nueva área de encabezado de columna
      CBound *caption_bound=this.InsertNewBound(name,x,0,caption_w,this.Height());
      if(caption_bound==NULL)
         return false;
      caption_bound.SetID(i);
      //--- Creamos un nuevo objeto de representación visual del encabezado de la columna
      CColumnCaptionView *caption_view=this.InsertNewColumnCaptionView(caption_model.Value(),x,0,caption_w,this.Height());
      if(caption_view==NULL)
         return false;
         
      //--- Asignamos al área actual del encabezado de columna el objeto de representación visual del encabezado de columna correspondiente
      caption_bound.AssignObject(caption_view);
      caption_view.AssignBoundNode(caption_bound);
      
      //--- Para el primer encabezado, activamos el indicador de ordenación ascendente
      if(i==0)
         caption_view.SetSortMode(TABLE_SORT_MODE_ASC);
     }
//--- Todo ha salido bien
   return true;
  }

Método que recalcula las áreas de los encabezados:

//+------------------------------------------------------------------+
//| CTableHeaderView::Recalcula las áreas de los encabezados         |
//+------------------------------------------------------------------+
bool CTableHeaderView::RecalculateBounds(CBound *bound,int new_width)
  {
//--- Si se ha pasado un objeto de área vacío o si su ancho no ha cambiado, devolvemos «false»
   if(bound==NULL || bound.Width()==new_width)
      return false;
      
//--- Obtenemos el índice del área en la lista
   int index=this.m_list_bounds.IndexOf(bound);
   if(index==WRONG_VALUE)
      return false;

//--- Calculamos el desplazamiento y, si es nulo, devolvemos «false»
   int delta=new_width-bound.Width();
   if(delta==0)
      return false;

//--- Modificamos el ancho del área actual y del objeto asignado a dicha área
   bound.ResizeW(new_width);
   CElementBase *assigned_obj=bound.GetAssignedObj();
   if(assigned_obj!=NULL)
      assigned_obj.ResizeW(new_width);

//--- Obtenemos el área siguiente a la actual
   CBound *next_bound=this.m_list_bounds.GetNextNode();
//--- Recalculamos las coordenadas X para todas las áreas siguientes
   while(!::IsStopped() && next_bound!=NULL)
     {
      //--- Desplazamos el área una distancia igual a delta
      int new_x = next_bound.X()+delta;
      int prev_width=next_bound.Width();
      next_bound.SetX(new_x);
      next_bound.Resize(prev_width,next_bound.Height());
      
      //--- Si hay un objeto asignado en el área, actualizamos su posición
      CElementBase *assigned_obj=next_bound.GetAssignedObj();
      if(assigned_obj!=NULL)
        {
         assigned_obj.Move(assigned_obj.X()+delta,assigned_obj.Y());
         
         //--- Este fragmento de código forma parte de las medidas para detectar y eliminar artefactos al arrastrar encabezados
         CCanvasBase *base_obj=assigned_obj.GetContainer();
         if(base_obj!=NULL)
           {
            if(assigned_obj.X()>base_obj.ContainerLimitRight())
               assigned_obj.Hide(false);
            else
               assigned_obj.Show(false);
           }
        }
      //--- Pasamos a la siguiente área
      next_bound=this.m_list_bounds.GetNextNode();
     }
     
//--- Calcularemos el nuevo ancho del encabezado de la tabla en función del ancho de los encabezados de las columnas
   int header_width=0;
   for(int i=0;i<this.m_list_bounds.Total();i++)
     {
      CBound *bound=this.GetBoundAt(i);
      if(bound!=NULL)
         header_width+=bound.Width();
     }

//--- Si el ancho calculado del encabezado de la tabla difiere del actual, modificamos el ancho
   if(header_width!=this.Width())
     {
      if(!this.ResizeW(header_width))
         return false;
     }

//--- Obtenemos un puntero al objeto de la tabla (View)
   CTableView *table_view=this.GetContainer();
   if(table_view==NULL)
      return false;

//--- A partir del objeto de la tabla, obtenemos un puntero al panel de filas de la tabla
   CPanel *table_area=table_view.GetTableArea();
   if(table_area==NULL)
      return false;
   
//--- Ajustamos el tamaño del panel de filas de la tabla al tamaño total de los encabezados de las columnas
   if(!table_area.ResizeW(header_width))
      return false;
   
//--- Obtenemos la lista de filas de la tabla y recorremos todas las filas en un bucle
   CListElm *list=table_area.GetListAttachedElements();
   int total=list.Total();
   for(int i=0;i<total;i++)
     {
      //--- Obtenemos la siguiente fila de la tabla
      CTableRowView *row=table_area.GetAttachedElementAt(i);
      if(row!=NULL)
        {
         //--- Ajustamos el tamaño de la fila al tamaño del panel y recalculamos las áreas de las celdas
         row.ResizeW(table_area.Width());
         row.RecalculateBounds(&this.m_list_bounds);
        }
     }
//--- Redibujamos todas las filas de la tabla
   table_area.Draw(false);
   return true;
  }

La lógica del método se explica en los comentarios. Al método se le pasa un puntero al área modificada del encabezado y su nuevo ancho. Se modifican los tamaños del área y del encabezado que tiene asignado y, a partir de la siguiente área de la lista, cada área posterior se desplaza a una nueva coordenada junto con su encabezado asignado. Una vez finalizado el desplazamiento de todas las áreas, se calcula el nuevo tamaño del encabezado de la tabla en función de los anchos de todas las áreas de los encabezados de las columnas que lo componen. A partir de ese momento, este nuevo tamaño influye en el ancho de la barra de desplazamiento horizontal de la tabla. En función del nuevo tamaño del encabezado de la tabla, se establece el ancho del panel de filas de la tabla; todas las filas se ajustan al nuevo tamaño del panel y se recalculan todas las áreas de las celdas según la lista de áreas del encabezado de la tabla. Como resultado, la tabla se vuelve a dibujar (la parte visible dentro del contenedor).

Método que establece un indicador de ordenación en el encabezado de una columna:

//+------------------------------------------------------------------+
//| CTableHeaderView::Establece el indicador de ordenación en el encabezado de una columna|
//+------------------------------------------------------------------+
void CTableHeaderView::SetSortedColumnCaption(const uint index)
  {
   int total=this.m_list_bounds.Total();
   for(int i=0;i<total;i++)
     {
      //--- Obtenemos el área del siguiente encabezado de columna y
      //--- a partir de ella obtenemos el objeto de encabezado de columna asociado
      CColumnCaptionView *caption_view=this.GetColumnCaption(i);
      if(caption_view==NULL)
         continue;
      
      //--- Si el índice del bucle es igual al índice requerido, activamos el indicador de ordenación ascendente
      if(i==index)
        {
         caption_view.SetSortMode(TABLE_SORT_MODE_ASC);
         caption_view.Draw(false);
        }
      //--- De lo contrario, desactivamos el indicador de ordenación
      else
        {
         caption_view.SetSortMode(TABLE_SORT_MODE_NONE);
         caption_view.Draw(false);
        }
     }
   this.Draw(true);
  }

En el bucle que recorre la lista de las áreas de los encabezados de columna, obtenemos el objeto del encabezado. Si se trata del encabezado buscado por su índice, activamos su indicador de ordenación ascendente; en caso contrario, desactivamos el indicador de ordenación. De este modo, se desactivará el indicador de ordenación en todos los encabezados de columna, y para el indicado por índice se establecerá la ordenación ascendente. En otras palabras: al hacer clic en el encabezado de una columna, se aplicará una ordenación ascendente a dicha columna. Al hacer clic de nuevo en ese mismo encabezado, se activará su indicador de ordenación descendente, pero esta vez en el manejador del evento de clic sobre el elemento.

Método que devuelve el encabezado de una columna según su índice:

//+------------------------------------------------------------------+
//| CTableHeaderView::Obtiene el encabezado de una columna por su índice          |
//+------------------------------------------------------------------+
CColumnCaptionView *CTableHeaderView::GetColumnCaption(const uint index)
  {
//--- Obtenemos el área del encabezado de la columna por índice
   CBound *capt_bound=this.GetBoundAt(index);
   if(capt_bound==NULL)
      return NULL;
//--- Devolvemos el puntero al objeto de encabezado de columna asociado al área del encabezado
   return capt_bound.GetAssignedObj();
  }

Método que devuelve el encabezado de la columna con el indicador de ordenación:

//+------------------------------------------------------------------+
//| CTableHeaderView::Obtiene el encabezado de una columna con el indicador de ordenación |
//+------------------------------------------------------------------+
CColumnCaptionView *CTableHeaderView::GetSortedColumnCaption(void)
  {
   int total=this.m_list_bounds.Total();
   for(int i=0;i<total;i++)
     {
      //--- Obtenemos el área del siguiente encabezado de columna y
      //--- a partir de ella obtenemos el objeto de encabezado de columna asociado
      CColumnCaptionView *caption_view=this.GetColumnCaption(i);
      
      //--- Si se ha obtenido el objeto y tiene activado el indicador de ordenación, devolvemos un puntero al mismo
      if(caption_view!=NULL && caption_view.SortMode()!=TABLE_SORT_MODE_NONE)
         return caption_view;
     }
   return NULL;
  }

Método que devuelve el índice de la columna ordenada:

//+------------------------------------------------------------------+
//| CTableHeaderView::Devuelve el índice de la columna ordenada      |
//+------------------------------------------------------------------+
int CTableHeaderView::IndexSortedColumnCaption(void)
  {
   int total=this.m_list_bounds.Total();
   for(int i=0;i<total;i++)
     {
      //--- Obtenemos el área del siguiente encabezado de columna y
      //--- a partir de ella obtenemos el objeto de encabezado de columna asociado
      CColumnCaptionView *caption_view=this.GetColumnCaption(i);
     
      //--- Si se ha obtenido el objeto y tiene activado el indicador de ordenación, devolvemos el índice del área
      if(caption_view!=NULL && caption_view.SortMode()!=TABLE_SORT_MODE_NONE)
         return i;
     }
   return WRONG_VALUE;
  }

Los tres métodos presentados anteriormente buscan, mediante un bucle simple, el encabezado de columna que tiene el indicador buscado o que corresponde al índice especificado, y devuelven los datos correspondientes a cada método.

Manejador del evento personalizado del elemento al hacer clic en el área del objeto:

//+------------------------------------------------------------------+
//| CTableHeaderView::Manejador del evento personalizado del elemento  |
//| al hacer clic en el área del objeto                              |
//+------------------------------------------------------------------+
void CTableHeaderView::MousePressHandler(const int id,const long lparam,const double dparam,const string sparam)
  {
//--- Obtenemos de sparam el nombre del objeto del encabezado de la tabla
   int len=::StringLen(this.NameFG());
   string header_str=::StringSubstr(sparam,0,len);
//--- Si el nombre obtenido no coincide con el nombre de este objeto, no es nuestro evento, salimos
   if(header_str!=this.NameFG())
      return;
   
//--- Buscaremos en sparam el índice del encabezado de la columna
   string capt_str=::StringSubstr(sparam,len+1);
   string index_str=::StringSubstr(capt_str,5,capt_str.Length()-7);
//--- No se ha encontrado el índice en la cadena; salimos
   if(index_str=="")
      return;
//--- Anotamos el índice del encabezado de la columna
   int index=(int)::StringToInteger(index_str);
   
//--- Obtenemos el encabezado de la columna por su índice
   CColumnCaptionView *caption=this.GetColumnCaption(index);
   if(caption==NULL)
      return;
   
//--- Si el encabezado no tiene el indicador de ordenación, activamos el indicador de ordenación ascendente
   if(caption.SortMode()==TABLE_SORT_MODE_NONE)
     {
      this.SetSortedColumnCaption(index);
     }
//--- Enviamos un evento de usuario al gráfico con el índice del encabezado en lparam, el modo de ordenación en dparam y el nombre del objeto en sparam
//--- Dado que en el evento estándar OBJECT_CLICK se pasan las coordenadas del cursor en lparam y dparam, aquí pasaremos valores negativos
   ::EventChartCustom(this.m_chart_id, (ushort)CHARTEVENT_OBJECT_CLICK, -(1000+index), -(1000+caption.SortMode()), this.NameFG());
   ::ChartRedraw(this.m_chart_id);
  }

El método envía un evento de usuario que indica que se ha activado la ordenación por columna. Dado que en el evento de clic sobre un objeto se pasan las coordenadas del cursor en lparam y dparam, para identificarlo como un evento de activación de la ordenación, pasaremos valores negativos en ambos parámetros:

  • En lparam (-1000) + índice de columna,
  • En dparam (-1000) + tipo de ordenación.

Vamos a modificar la clase de representación visual de la tabla CTableView.

La clase constituye un elemento de control completo denominado «Tabla». Las mejoras consistirán en incorporar la funcionalidad para modificar el ancho de las columnas y realizar la ordenación de los datos según la columna seleccionada de la tabla.

Declararemos los nuevos métodos de la clase:

//+------------------------------------------------------------------+
//| Clase de representación visual de la tabla                       |
//+------------------------------------------------------------------+
class CTableView : public CPanel
  {
protected:
//--- Datos recibidos de la tabla
   CTable           *m_table_obj;                  // Puntero al objeto de la tabla (incluye los modelos de la tabla y del encabezado)
   CTableModel      *m_table_model;                // Puntero al modelo de tabla (obtenido de CTable)
   CTableHeader     *m_header_model;               // Puntero al modelo del encabezado de la tabla (obtenido de CTable)
   
//--- Datos del componente View
   CTableHeaderView *m_header_view;                // Puntero al encabezado de la tabla (View)
   CPanel           *m_table_area;                 // Panel para alojar las filas de la tabla
   CContainer       *m_table_area_container;       // Contenedor para alojar el panel con las filas de la tabla
   
//--- (1) Establece, (2) devuelve el modelo de tabla
   bool              TableModelAssign(CTableModel *table_model);
   CTableModel      *GetTableModel(void)                                { return this.m_table_model;           }
   
//--- (1) Establece, (2) devuelve el modelo del encabezado de la tabla
   bool              HeaderModelAssign(CTableHeader *header_model);
   CTableHeader     *GetHeaderModel(void)                               { return this.m_header_model;          }

//--- Crea a partir del modelo el objeto (1) del encabezado, (2) de la tabla; (3) actualiza la tabla modificada
   bool              CreateHeader(void);
   bool              CreateTable(void);
   bool              UpdateTable(void);
   
public:
//--- (1) Establece, (2) devuelve el objeto de la tabla
   bool              TableObjectAssign(CTable *table_obj);
   CTable           *GetTableObj(void)                                  { return this.m_table_obj;             }

//--- Devuelve (1) el encabezado de la tabla, (2) el área de ubicación de la tabla y (3) el contenedor del área de la tabla
   CTableHeaderView *GetHeader(void)                                    { return this.m_header_view;           }
   CPanel           *GetTableArea(void)                                 { return this.m_table_area;            }
   CContainer       *GetTableAreaContainer(void)                        { return this.m_table_area_container;  }

//--- Muestra en el registro el modelo asignado (1) de la tabla, (2) del encabezado, (3) del objeto de la tabla
   void              TableModelPrint(const bool detail);
   void              HeaderModelPrint(const bool detail, const bool as_table=false, const int cell_width=CELL_WIDTH_IN_CHARS);
   void              TablePrint(const int column_width=CELL_WIDTH_IN_CHARS);
   
//--- Obtiene el encabezado de la columna (1) por índice, (2) con el indicador de ordenación
   CColumnCaptionView *GetColumnCaption(const uint index)
                       { return(this.GetHeader()!=NULL ? this.GetHeader().GetColumnCaption(index) : NULL);     }
   CColumnCaptionView *GetSortedColumnCaption(void)
                       { return(this.GetHeader()!=NULL ? this.GetHeader().GetSortedColumnCaption(): NULL);     }

//--- Devuelve el objeto de representación visual de (1) la fila especificada, (2) la celda especificada
   CTableRowView    *GetRowView(const uint index)
                       { return(this.GetTableArea()!=NULL ? this.GetTableArea().GetAttachedElementAt(index) : NULL); }
   CTableCellView   *GetCellView(const uint row,const uint col)
                       { return(this.GetRowView(row)!=NULL ? this.GetRowView(row).GetCellView(col) : NULL);    }
                       
//--- Devuelve el número de filas de la tabla
   int               RowsTotal(void)
                       { return(this.GetTableArea()!=NULL ? this.GetTableArea().AttachedElementsTotal() : 0);  }

//--- Dibuja el aspecto visual
   virtual void      Draw(const bool chart_redraw);
   
//--- Métodos virtuales: (1) comparación, (2) guardado en un archivo, (3) carga desde un archivo, (4) tipo de objeto
   virtual int       Compare(const CObject *node,const int mode=0)const { return CPanel::Compare(node,mode);   }
   virtual bool      Save(const int file_handle);
   virtual bool      Load(const int file_handle);
   virtual int       Type(void)                                   const { return(ELEMENT_TYPE_TABLE_VIEW);     }
   
//--- Manejador del evento de usuario del elemento al hacer clic en el área del objeto
   virtual void      MousePressHandler(const int id, const long lparam, const double dparam, const string sparam);
   
//--- Ordena la tabla según el valor de la columna y el sentido de ordenación
   bool              Sort(const uint column,const ENUM_TABLE_SORT_MODE sort_mode);
  
//--- Inicialización (1) del objeto de la clase, (2) de los colores predeterminados del objeto
   void              Init(void);

//--- Constructores/destructor
                     CTableView(void);
                     CTableView(const string object_name, const string text, const long chart_id, const int wnd, const int x, const int y, const int w, const int h);
                    ~CTableView (void){}
  };

Analicemos los métodos declarados.

Método que actualiza la tabla modificada:

//+------------------------------------------------------------------+
//| CTableView::Actualiza la tabla modificada                        |
//+------------------------------------------------------------------+
bool CTableView::UpdateTable(void)
  {
   if(this.m_table_area==NULL)
      return false;
   
   int total_model=(int)this.m_table_model.RowsTotal();        // Número de filas en el modelo
   int total_view =this.m_table_area.AttachedElementsTotal();  // Número de filas en la representación visual
   int diff=total_model-total_view;                            // Diferencia en el número de filas de los dos componentes
   int y=1;                                                    // Desplazamiento vertical
   int table_height=0;                                         // Altura calculada del panel
   CTableRowView *row=NULL;                                    // Puntero al objeto de representación visual de la fila
   
//--- Si el modelo tiene más filas que la representación visual, crearemos las filas que faltan en la representación visual al final de la lista
   if(diff>0)
     {
      //--- Obtenemos la última fila de la representación visual de la tabla (las filas que se vayan añadiendo se colocarán en función de sus coordenadas)
      row=this.m_table_area.GetAttachedElementAt(total_view-1);
      //--- En un bucle que se repite tantas veces como filas faltan
      for(int i=total_view;i<total_view+diff;i++)
        {
         //--- creamos y añadimos al panel tantos objetos de representación visual de fila de la tabla como indique diff
         row=this.m_table_area.InsertNewElement(ELEMENT_TYPE_TABLE_ROW_VIEW,"","TableRow"+(string)i,0,y+(row!=NULL ? row.Height()*i : 0),this.m_table_area.Width()-1,DEF_TABLE_ROW_H);
         if(row==NULL)
            return false;
        }
     }
 
//--- Si en la representación visual hay más filas que en el modelo, eliminaremos las filas sobrantes de la representación visual al final de la lista.
   if(diff<0)
     {
      CListElm *list=this.m_table_area.GetListAttachedElements();
      if(list==NULL)
         return false;
      
      int  start=total_view-1;
      int  end=start-diff;
      bool res=true;
      for(int i=start;i>end;i--)
         res &=list.Delete(i);
      if(!res)
         return false;
     }
   
//--- En un bucle que recorre la lista de filas del modelo de la tabla
   for(int i=0;i<total_model;i++)
     {
      //--- obtenemos de la lista del panel de filas el siguiente objeto de representación visual de una fila de la tabla
      row=this.m_table_area.GetAttachedElementAt(i);
      if(row==NULL)
         return false;
      //--- Comprobamos el tipo de objeto
      if(row.Type()!=ELEMENT_TYPE_TABLE_ROW_VIEW)
         continue;
         
      //--- Establecemos el identificador de la fila
      row.SetID(i);
      //--- En función del número de fila (par/impar), establecemos el color de su fondo
      if(row.ID()%2==0)
         row.InitBackColorDefault(clrWhite);
      else
         row.InitBackColorDefault(C'242,242,242');
      row.BackColorToDefault();
      row.InitBackColorFocused(row.GetBackColorControl().NewColor(row.BackColor(),-4,-4,-4));
      
      //--- Obtenemos el modelo de fila a partir del objeto de tabla
      CTableRow *row_model=this.m_table_model.GetRow(i);
      if(row_model==NULL)
         return false;

      //--- Actualizamos las celdas de un objeto de fila de la tabla según el modelo de fila
      row.TableRowModelUpdate(row_model);
      //--- Calculamos el nuevo valor de la altura del panel
      table_height+=row.Height();
     }
//--- Devolvemos el resultado del cambio de tamaño del panel al valor calculado en el bucle
   return this.m_table_area.ResizeH(table_height+y);
  }

La lógica del método se explica en el código. Se compara el número de filas del modelo de la tabla con el de la representación visual. Si hay alguna diferencia, en la representación visual se añaden las filas que faltan o se eliminan las que sobran de la tabla. A continuación, en un bucle que recorre las filas del modelo de la tabla, se actualizan las celdas de la representación visual de la tabla. Una vez finalizada la actualización de todas las filas de la representación visual, se devuelve el resultado del ajuste del tamaño de la tabla al nuevo número de filas.

Manejador del evento personalizado del elemento al hacer clic en el área del objeto:

//+------------------------------------------------------------------+
//| CTableView::Manejador de un evento personalizado de un elemento  |
//| al hacer clic en el área del objeto                              |
//+------------------------------------------------------------------+
void CTableView::MousePressHandler(const int id,const long lparam,const double dparam,const string sparam)
  {
   if(id==CHARTEVENT_OBJECT_CLICK && lparam>=0 && dparam>=0)
      return;
      
//--- Obtenemos de sparam el nombre del objeto del encabezado de la tabla
   int len=::StringLen(this.NameFG());
   string header_str=::StringSubstr(sparam,0,len);
//--- Si el nombre obtenido no coincide con el nombre de este objeto, no es nuestro evento, salimos
   if(header_str!=this.NameFG())
      return;
   
//--- Anotamos el índice del encabezado de la columna
//--- Dado que en el evento estándar OBJECT_CLICK se pasan las coordenadas del cursor en lparam y dparam,
//--- se pasa a este manejador el valor negativo del índice del encabezado en el que se produjo el evento
   int index=(int)::fabs(lparam+1000);
   
//--- Obtenemos el encabezado de la columna por su índice
   CColumnCaptionView *caption=this.GetColumnCaption(index);
   if(caption==NULL)
      return;
   
//--- Ordenamos la lista de filas según el valor de ordenación del encabezado de la columna y actualizamos la tabla
   this.Sort(index,caption.SortMode());
   if(this.UpdateTable())
      this.Draw(true);
  }

El método no procesa los eventos si lparam y dparam no son menores que cero. A continuación, obtenemos de lparam el índice de la columna y ordenamos la tabla según el modo de ordenación indicado en el encabezado de la columna obtenido, tras lo cual se actualiza la tabla.

Hemos terminado de perfeccionar las clases. Ahora vamos a crear una nueva clase que nos permita generar tablas de forma bastante sencilla a partir de datos ya preparados. Y la gestión de las tablas también se llevará a cabo en esta misma clase. Por lo tanto, y teniendo en cuenta su finalidad, se tratará de una clase de gestión de tablas. Un objeto de esta clase puede contener múltiples tablas diferentes, a las que se accederá mediante su identificador o el nombre que les haya asignado el usuario.


Clase para crear tablas de forma sencilla

Seguiremos escribiendo el código en el archivo \MQL5\Indicators\Tables\Controls\Controls.mqh.

//+------------------------------------------------------------------+
//| Clase de gestión de tablas                                       |
//+------------------------------------------------------------------+
class CTableControl : public CPanel
  {
protected:
   CListObj          m_list_table_model;
//--- Añade a la lista un objeto (1) del modelo (CTable) o (2) de la representación visual (CTableView) de la tabla
   bool              TableModelAdd(CTable *table_model,const int table_id,const string source);
   CTableView       *TableViewAdd(CTable *table_model,const string source);
//--- Actualiza la columna indicada de la tabla indicada
   bool              ColumnUpdate(const string source, CTable *table_model, const uint table, const uint col, const bool cells_redraw);
   
public:
//--- Devuelve (1) el modelo, (2) el objeto de representación visual de la tabla y (3) el tipo de objeto
   CTable           *GetTable(const uint index)                   { return this.m_list_table_model.GetNodeAtIndex(index);  }
   CTableView       *GetTableView(const uint index)               { return this.GetAttachedElementAt(index);               }
   
//--- Creación de una tabla a partir de los datos facilitados
template<typename T>
   CTableView       *TableCreate(T &row_data[][],const string &column_names[],const int table_id=WRONG_VALUE);
   CTableView       *TableCreate(const uint num_rows, const uint num_columns,const int table_id=WRONG_VALUE);
   CTableView       *TableCreate(const matrix &row_data,const string &column_names[],const int table_id=WRONG_VALUE);
   CTableView       *TableCreate(CList &row_data,const string &column_names[],const int table_id=WRONG_VALUE);
   
//--- Devuelve (1) el valor de cadena de la celda especificada (Model), (2) la fila especificada y (3) la celda especificada de la tabla (View)
   string            CellValueAt(const uint table, const uint row, const uint col);
   CTableRowView    *GetRowView(const uint table, const uint index);
   CTableCellView   *GetCellView(const uint table, const uint row, const uint col);
   
//--- Establece (1) el valor, (2) la precisión, (3) los indicadores de visualización de la hora y (4) el indicador de visualización de los nombres de los colores en la celda especificada (Model + View)
template<typename T>
   void              CellSetValue(const uint table, const uint row, const uint col, const T value, const bool chart_redraw);
   void              CellSetDigits(const uint table, const uint row, const uint col, const int digits, const bool chart_redraw);
   void              CellSetTimeFlags(const uint table, const uint row, const uint col, const uint flags, const bool chart_redraw);
   void              CellSetColorNamesFlag(const uint table, const uint row, const uint col, const bool flag, const bool chart_redraw);

//--- Establece el color de primer plano en la celda indicada (View)
   void              CellSetForeColor(const uint table, const uint row, const uint col, const color clr, const bool chart_redraw);
   
//--- (1) Establece, (2) devuelve el punto de anclaje del texto en la celda indicada (View)
   void              CellSetTextAnchor(const uint table, const uint row, const uint col, const ENUM_ANCHOR_POINT anchor,const bool cell_redraw,const bool chart_redraw);
   ENUM_ANCHOR_POINT CellTextAnchor(const uint table, const uint row, const uint col);
   
//--- Establece (1) la precisión, (2) los indicadores de visualización de la hora, (3) el indicador de visualización de los nombres de los colores, (4) el punto de anclaje del texto y (5) el tipo de datos en la columna especificada (View)
   void              ColumnSetDigits(const uint table, const uint col, const int digits, const bool cells_redraw, const bool chart_redraw);
   void              ColumnSetTimeFlags(const uint table, const uint col, const uint flags, const bool cells_redraw, const bool chart_redraw);
   void              ColumnSetColorNamesFlag(const uint table, const uint col, const bool flag, const bool cells_redraw, const bool chart_redraw);
   void              ColumnSetTextAnchor(const uint table, const uint col, const ENUM_ANCHOR_POINT anchor, const bool cells_redraw, const bool chart_redraw);
   void              ColumnSetDatatype(const uint table, const uint col, const ENUM_DATATYPE type, const bool cells_redraw, const bool chart_redraw);

//--- Tipo de objeto
   virtual int       Type(void)                             const { return(ELEMENT_TYPE_TABLE_CONTROL_VIEW);               }

//--- Constructores/destructor
                     CTableControl(void) { this.m_list_table_model.Clear(); }
                     CTableControl(const string object_name, const long chart_id, const int wnd, const int x, const int y, const int w, const int h);
                    ~CTableControl(void) {}
  };

La clase representa un panel en el que se colocan tablas (una o varias) y consta de dos listas:

  1. lista de modelos de tablas,
  2. lista de representaciones visuales de las tablas creadas a partir de los modelos correspondientes.

Los métodos de la clase permiten obtener la tabla deseada y gestionar su aspecto, sus filas, sus columnas y sus celdas.

Analicemos los métodos declarados de la clase.

En el constructor de la clase se vacía la lista de modelos de tablas y se establece un nombre por defecto:

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CTableControl::CTableControl(const string object_name,const long chart_id,const int wnd,const int x,const int y,const int w,const int h) :
   CPanel(object_name,"",chart_id,wnd,x,y,w,h)
  {
   this.m_list_table_model.Clear();
   this.SetName("Table Control");
  }

Una vez creado el objeto, si se prevé crear más de uno de esta clase, se le debe asignar un nombre propio y único, de modo que en la lista de objetos asociados al panel no haya dos o más elementos con el mismo nombre.

Método que añade un objeto de modelo de tabla a la lista:

//+------------------------------------------------------------------+
//| Añade un objeto de modelo de tabla (CTable) a la lista           |
//+------------------------------------------------------------------+
bool CTableControl::TableModelAdd(CTable *table_model,const int table_id,const string source)
  {
//--- Comprobamos el objeto del modelo de tabla
   if(table_model==NULL)
     {
      ::PrintFormat("%s::%s: Error. Failed to create Table Model object",source,__FUNCTION__);
      return false;
     }
//--- Asignamos al modelo de tabla un identificador, ya sea en función del tamaño de la lista o el especificado
   table_model.SetID(table_id<0 ? this.m_list_table_model.Total() : table_id);
//--- Si el modelo de tabla con el identificador especificado aparece en la lista, lo indicamos, eliminamos el objeto y devolvemos «false»
   this.m_list_table_model.Sort(0);
   if(this.m_list_table_model.Search(table_model)!=NULL)
     {
      ::PrintFormat("%s::%s: Error: Table Model object with ID %d already exists in the list",source,__FUNCTION__,table_id);
      delete table_model;
      return false;
     }
//--- Si no se ha añadido el modelo de tabla a la lista, lo indicamos, eliminamos el objeto y devolvemos «false»
   if(this.m_list_table_model.Add(table_model)<0)
     {
      ::PrintFormat("%s::%s: Error. Failed to add Table Model object to list",source,__FUNCTION__);
      delete table_model;
      return false;
     }
//--- Todo ha salido bien
   return true;
  }

Método que crea un nuevo objeto de representación visual de una tabla y lo añade a la lista:

//+------------------------------------------------------------------+
//| Crea y añade a la lista un nuevo objeto de                       |
//| representación visual de la tabla (CTableView)                   |
//+------------------------------------------------------------------+
CTableView *CTableControl::TableViewAdd(CTable *table_model,const string source)
  {
//--- Comprobamos el objeto del modelo de tabla
   if(table_model==NULL)
     {
      ::PrintFormat("%s::%s: Error. An invalid Table Model object was passed",source,__FUNCTION__);
      return NULL;
     }
//--- Creamos un nuevo elemento asociado al panel: una representación visual de la tabla
   CTableView *table_view=this.InsertNewElement(ELEMENT_TYPE_TABLE_VIEW,"","TableView"+(string)table_model.ID(),1,1,this.Width()-2,this.Height()-2);
   if(table_view==NULL)
     {
      ::PrintFormat("%s::%s: Error. Failed to create Table View object",source,__FUNCTION__);
      return NULL;
     }
//--- Al elemento gráfico «Tabla» (View) le asignamos el objeto de tabla (Model) y su identificador
   table_view.TableObjectAssign(table_model);
   table_view.SetID(table_model.ID());
   return table_view;
  }

Ambos métodos analizados anteriormente se utilizan en los métodos de creación de tablas.

Método que crea una tabla especificando el array de la tabla y el array de encabezados:

//+-------------------------------------------------------------------+
//| Crea una tabla especificando el array de la tabla y el array de encabezados. | 
//| Determina el número y los nombres de las columnas según column_names|
//| El número de filas viene determinado por el tamaño del array de datos row_data,     |
//| que también se utiliza para rellenar la tabla                     |
//+-------------------------------------------------------------------+
template<typename T>
CTableView *CTableControl::TableCreate(T &row_data[][],const string &column_names[],const int table_id=WRONG_VALUE)
  {
//--- Creamos un objeto de tabla según los parámetros indicados
   CTable *table_model=new CTable(row_data,column_names);
//--- Si se producen errores al crear o añadir una tabla a la lista, devolvemos NULL
   if(!this.TableModelAdd(table_model,table_id,__FUNCTION__))
      return NULL;
   
//--- Creamos y devolvemos la tabla
   return this.TableViewAdd(table_model,__FUNCTION__);
  }

Método que crea una tabla en la que se especifica el número de columnas y filas:

//+------------------------------------------------------------------+
//| Crea una tabla especificando el número de columnas y filas.      |
//| Las columnas tendrán los nombres de Excel «A», «B», «C», etc.    |
//+------------------------------------------------------------------+
CTableView *CTableControl::TableCreate(const uint num_rows,const uint num_columns,const int table_id=WRONG_VALUE)
  {
   CTable *table_model=new CTable(num_rows,num_columns);
//--- Si se producen errores al crear o añadir una tabla a la lista, devolvemos NULL
   if(!this.TableModelAdd(table_model,table_id,__FUNCTION__))
      return NULL;
   
//--- Creamos y devolvemos la tabla
   return this.TableViewAdd(table_model,__FUNCTION__);
  }

Método que crea una tabla a partir de una matriz:

//+------------------------------------------------------------------+
//| Crea una tabla con las columnas inicializadas según column_names |
//| El número de filas viene determinado por el parámetro row_data, de tipo matrix  |
//+------------------------------------------------------------------+
CTableView *CTableControl::TableCreate(const matrix &row_data,const string &column_names[],const int table_id=WRONG_VALUE)
  {
   CTable *table_model=new CTable(row_data,column_names);
//--- Si se producen errores al crear o añadir una tabla a la lista, devolvemos NULL
   if(!this.TableModelAdd(table_model,table_id,__FUNCTION__))
      return NULL;
   
//--- Creamos y devolvemos la tabla
   return this.TableViewAdd(table_model,__FUNCTION__);
  }

Método que crea una tabla a partir de una lista de parámetros definidos por el usuario y un array de encabezados de columnas:

//+------------------------------------------------------------------+
//| Crea una tabla especificando el array de la tabla a partir de   |
//| la lista row_data, que contiene objetos con los datos de los campos de la estructura. | 
//| Determina el número y los nombres de las columnas en función del número |
//| de nombres de columnas en el array column_names                 |
//+------------------------------------------------------------------+
CTableView *CTableControl::TableCreate(CList &row_data,const string &column_names[],const int table_id=WRONG_VALUE)
  {
   CTableByParam *table_model=new CTableByParam(row_data,column_names);
//--- Si se producen errores al crear o añadir una tabla a la lista, devolvemos NULL
   if(!this.TableModelAdd(table_model,table_id,__FUNCTION__))
      return NULL;
   
//--- Creamos y devolvemos la tabla
   return this.TableViewAdd(table_model,__FUNCTION__);
  }

La lógica de todos los métodos presentados para crear una tabla es la misma: primero, a partir de los parámetros de entrada del método, se crea y se añade a la lista un objeto de modelo de tabla y, a continuación, se genera la representación visual. Estos son los métodos principales para crear tablas a partir de un amplio conjunto de datos. La tabla creada mediante los métodos analizados se coloca en el panel, que sirve de base para ubicar las tablas creadas.

Método que establece un valor en la celda indicada:

//+------------------------------------------------------------------+
//| Establece un valor en la celda indicada (Modelo + Vista)         |
//+------------------------------------------------------------------+
template<typename T>
void CTableControl::CellSetValue(const uint table,const uint row,const uint col,const T value,const bool chart_redraw)
  {
//--- Obtenemos el modelo de la tabla
   CTable *table_model=this.GetTable(table);
   if(table_model==NULL)
      return;
   
//--- A partir del modelo de tabla obtenemos el modelo de celda
   CTableCell *cell_model=table_model.GetCell(row,col);
   if(cell_model==NULL)
      return;
      
//--- Obtenemos el objeto de representación visual de la celda
   CTableCellView *cell_view=this.GetCellView(table,row,col);
   if(cell_view==NULL)
      return;
      
//--- Comparamos el valor almacenado en la celda con el valor pasado
   bool equal=false;
   ENUM_DATATYPE datatype=cell_model.Datatype();
   switch(datatype)
     {
      case TYPE_LONG    :  
      case TYPE_DATETIME:  
      case TYPE_COLOR   :  equal=(cell_model.ValueL()==value);                                           break;
      case TYPE_DOUBLE  :  equal=(::NormalizeDouble(cell_model.ValueD()-value,cell_model.Digits())==0);  break;
      //---TYPE_STRING
      default           :  equal=(::StringCompare(cell_model.ValueS(),(string)value)==0);                break;
     }
//--- Si los valores son iguales, salimos
   if(equal)
      return;
      
//--- Establecemos un nuevo valor en el modelo de celda;
//--- introducimos el valor del modelo de la celda en el objeto de representación visual de la celda
//--- Redibujamos la celda con el indicador de actualización del gráfico
   table_model.CellSetValue(row,col,value);
   cell_view.SetText(cell_model.Value());
   cell_view.Draw(chart_redraw);
  }

La lógica del método se explica en los comentarios del código. Si la celda contiene el mismo valor que el pasado al método para escribir en ella, se sale del método. El nuevo valor se escribe primero en una celda del modelo de la tabla y, a continuación, en una celda de la representación visual de la tabla, tras lo cual se vuelve a dibujar dicha celda.

Método que establece la precisión con la que se muestran los números decimales en la celda indicada:

//+------------------------------------------------------------------+
//| Establece la precisión en la celda indicada (Modelo + Vista)     |
//+------------------------------------------------------------------+
void CTableControl::CellSetDigits(const uint table,const uint row,const uint col,const int digits,const bool chart_redraw)
  {
//--- Obtenemos el modelo de la tabla
   CTable *table_model=this.GetTable(table);
   if(table_model==NULL)
      return;
   
//--- A partir del modelo de tabla obtenemos el modelo de celda
   CTableCell *cell_model=table_model.GetCell(row,col);
   if(cell_model==NULL || cell_model.Digits()==digits)
      return;
      
//--- Obtenemos el objeto de representación visual de la celda
   CTableCellView *cell_view=this.GetCellView(table,row,col);
   if(cell_view==NULL)
      return;
   
//--- Establecemos un nuevo valor de precisión en el modelo de la celda;
//--- introducimos el valor del modelo de la celda en el objeto de representación visual de la celda
//--- Redibujamos la celda con el indicador de actualización del gráfico
   table_model.CellSetDigits(row,col,digits);
   cell_view.SetText(cell_model.Value());
   cell_view.Draw(chart_redraw);
  }

El método es similar al que se ha analizado anteriormente. Si la precisión indicada para los números decimales coincide con la actual, salimos del método. A continuación, la precisión se guarda en el modelo de la celda, se copia el texto de este modelo a la representación visual (en el caso de los números decimales, el texto ya refleja la nueva precisión) y se vuelve a dibujar la celda.

Método que establece los indicadores de visualización de la hora en la celda especificada:

//+------------------------------------------------------------------+
//| Establece los indicadores de visualización de la hora            |
//| en la celda indicada (Modelo + Vista)                            |
//+------------------------------------------------------------------+
void CTableControl::CellSetTimeFlags(const uint table,const uint row,const uint col,const uint flags,const bool chart_redraw)
  {
//--- Obtenemos el modelo de la tabla
   CTable *table_model=this.GetTable(table);
   if(table_model==NULL)
      return;
   
//--- A partir del modelo de tabla obtenemos el modelo de celda
   CTableCell *cell_model=table_model.GetCell(row,col);
   if(cell_model==NULL || cell_model.DatetimeFlags()==flags)
      return;
      
//--- Obtenemos el objeto de representación visual de la celda
   CTableCellView *cell_view=this.GetCellView(table,row,col);
   if(cell_view==NULL)
      return;
   
//--- Establecemos un nuevo valor para los indicadores de visualización de la hora en el modelo de la celda;
//--- introducimos el valor del modelo de la celda en el objeto de representación visual de la celda
//--- Redibujamos la celda con el indicador de actualización del gráfico
   table_model.CellSetTimeFlags(row,col,flags);
   cell_view.SetText(cell_model.Value());
   cell_view.Draw(chart_redraw);
  }

La lógica de este método es idéntica a la del método que establece la precisión en una celda.

Método que establece el indicador para mostrar los nombres de los colores en la celda especificada:

//+------------------------------------------------------------------+
//| Establece el indicador de visualización de los nombres de los colores                       |
//| en la celda indicada (Modelo + Vista)                            |
//+------------------------------------------------------------------+
void CTableControl::CellSetColorNamesFlag(const uint table,const uint row,const uint col,const bool flag,const bool chart_redraw)
  {
//--- Obtenemos el modelo de la tabla
   CTable *table_model=this.GetTable(table);
   if(table_model==NULL)
      return;
   
//--- A partir del modelo de tabla obtenemos el modelo de celda
   CTableCell *cell_model=table_model.GetCell(row,col);
   if(cell_model==NULL || cell_model.ColorNameFlag()==flag)
      return;
      
//--- Obtenemos el objeto de representación visual de la celda
   CTableCellView *cell_view=this.GetCellView(table,row,col);
   if(cell_view==NULL)
      return;
   
//--- En el modelo de la celda, establecemos un nuevo valor para el indicador de visualización de los nombres de los colores;
//--- introducimos el valor del modelo de la celda en el objeto de representación visual de la celda
//--- Redibujamos la celda con el indicador de actualización del gráfico
   table_model.CellSetColorNamesFlag(row,col,flag);
   cell_view.SetText(cell_model.Value());
   cell_view.Draw(chart_redraw);
  }

Es exactamente el mismo método que los analizados anteriormente.

Método que establece el color de primer plano en la celda indicada:

//+------------------------------------------------------------------+
//| Establece el color de primer plano en la celda indicada (Vista)  |
//+------------------------------------------------------------------+
void CTableControl::CellSetForeColor(const uint table,const uint row,const uint col,const color clr,const bool chart_redraw)
  {
//--- Obtenemos el objeto de representación visual de la celda
   CTableCellView *cell_view=this.GetCellView(table,row,col);
   if(cell_view==NULL)
      return;
   
//--- En el objeto de representación visual de la celda, establecemos el color de fondo de la celda
//--- Redibujamos la celda con el indicador de actualización del gráfico
   cell_view.SetForeColor(clr);
   cell_view.Draw(chart_redraw);
  }

Obtenemos el objeto de representación visual de la celda, le asignamos un nuevo color de primer plano y redibujamos la celda con el nuevo color de texto.

Método que establece el punto de anclaje del texto en la celda indicada:

//+------------------------------------------------------------------+
//| Establece el punto de anclaje del texto en la celda indicada (View)    |
//+------------------------------------------------------------------+
void CTableControl::CellSetTextAnchor(const uint table,const uint row,const uint col,const ENUM_ANCHOR_POINT anchor,const bool cell_redraw,const bool chart_redraw)
  {
//--- Obtenemos el objeto de representación visual de la celda
   CTableCellView *cell_view=this.GetCellView(table,row,col);
   if(cell_view==NULL)
      return;
   
//--- Establecemos un punto de anclaje del texto en el objeto de representación visual de la celda
//--- Redibujamos la celda con el indicador de actualización del gráfico
   cell_view.SetTextAnchor(anchor,cell_redraw,chart_redraw);
  }

Obtenemos el objeto de representación visual de la celda, le asignamos un nuevo punto de anclaje y redibujamos la celda con la nueva disposición del texto en su interior.

Método que devuelve el punto de anclaje del texto en la celda indicada:

//+------------------------------------------------------------------+
//| Devuelve el punto de anclaje del texto en la celda indicada (View)       |
//+------------------------------------------------------------------+
ENUM_ANCHOR_POINT CTableControl::CellTextAnchor(const uint table,const uint row,const uint col)
  {
//--- Obtenemos el objeto de representación visual de la celda
   CTableCellView *cell_view=this.GetCellView(table,row,col);
   if(cell_view==NULL)
      return ANCHOR_LEFT_UPPER;
   
//--- Devolvemos el punto de anclaje del texto
   return((ENUM_ANCHOR_POINT)cell_view.TextAnchor());
  }

Obtenemos el objeto de representación visual de la celda y devolvemos el punto de anclaje del texto establecido para él.

Método que actualiza la columna indicada de la tabla indicada:

//+------------------------------------------------------------------+
//| Actualiza la columna indicada de la tabla indicada               |
//+------------------------------------------------------------------+
bool CTableControl::ColumnUpdate(const string source,CTable *table_model,const uint table,const uint col,const bool cells_redraw)
  {
//--- Comprobamos el modelo de la tabla
   if(::CheckPointer(table_model)==POINTER_INVALID)
     {
      ::PrintFormat("%s::%s: Error. Invalid table model pointer passed",source,__FUNCTION__);
      return false;
     }
//--- Obtenemos la representación visual de la tabla
   CTableView *table_view=this.GetTableView(table);
   if(table_view==NULL)
     {
      ::PrintFormat("%s::%s: Error. Failed to get CTableView object",source,__FUNCTION__);
      return false;
     }
   
//--- En el bucle que recorre las filas de la representación visual de la tabla
   int total=table_view.RowsTotal();
   for(int i=0;i<total;i++)
     {
      //--- obtenemos, a partir de la fila actual de la tabla, el objeto de representación visual de la celda de la columna indicada
      CTableCellView *cell_view=this.GetCellView(table,i,col);
      if(cell_view==NULL)
        {
         ::PrintFormat("%s::%s: Error. Failed to get CTableCellView object (row %d, col %u)",source,__FUNCTION__,i,col);
         return false;
        }
      //--- Obtenemos el modelo de la celda correspondiente a partir del modelo de la fila
      CTableCell *cell_model=table_model.GetCell(i,col);
      if(cell_model==NULL)
        {
         ::PrintFormat("%s::%s: Error. Failed to get CTableCell object (row %d, col %u)",source,__FUNCTION__,i,col);
         return false;
        }
      
      //--- En el objeto de representación visual de la celda, guardamos el valor procedente del modelo de la celda
      cell_view.SetText(cell_model.Value());
      //--- Si se indica, redibujamos la representación visual de la celda
      if(cells_redraw)
         cell_view.Draw(false);
     }
   return true;
  }

La lógica del método se explica en los comentarios. Una vez actualizado el modelo de la tabla, lo pasamos a este método. Y aquí, en un bucle que recorre todas las filas de la representación visual de la tabla, obtenemos sucesivamente cada nueva fila y, de la fila correspondiente del modelo, la celda indicada. Introducimos los datos del modelo de la celda en su representación visual, y esta se redibuja. De este modo se vuelve a dibujar toda la columna de la tabla.

Método que establece la precisión en la columna indicada:

//+------------------------------------------------------------------+
//| Establece la precisión en la columna indicada (Modelo + Vista)   |
//+------------------------------------------------------------------+
void CTableControl::ColumnSetDigits(const uint table,const uint col,const int digits,const bool cells_redraw,const bool chart_redraw)
  {
//--- Obtenemos el modelo de la tabla
   CTable *table_model=this.GetTable(table);
   if(table_model==NULL)
     {
      ::PrintFormat("%s: Error. Failed to get CTable object",__FUNCTION__);
      return;
     }
//--- Establecemos Digits para la columna indicada en el modelo de la tabla 
   table_model.ColumnSetDigits(col,digits);

//--- Actualizamos la visualización de los datos de la columna y, si se ha especificado, redibujamos el gráfico
   if(this.ColumnUpdate(__FUNCTION__,table_model,table,col,cells_redraw) && chart_redraw)
      ::ChartRedraw(this.m_chart_id);
  }

En el modelo de la tabla, establecemos la precisión indicada para la columna y llamamos al método de actualización de la columna de la tabla descrito anteriormente.

Método que establece los indicadores de visualización de la hora en la columna especificada:

//+------------------------------------------------------------------+
//| Establece los indicadores de visualización de la hora            |
//| en la columna indicada (Modelo + Vista)                          |
//+------------------------------------------------------------------+
void CTableControl::ColumnSetTimeFlags(const uint table,const uint col,const uint flags,const bool cells_redraw,const bool chart_redraw)
  {
//--- Obtenemos el modelo de la tabla
   CTable *table_model=this.GetTable(table);
   if(table_model==NULL)
     {
      ::PrintFormat("%s: Error. Failed to get CTable object",__FUNCTION__);
      return;
     }
//--- Establecemos los indicadores de visualización de la hora para la columna especificada en el modelo de la tabla 
   table_model.ColumnSetTimeFlags(col,flags);

//--- Actualizamos la visualización de los datos de la columna y, si se ha especificado, redibujamos el gráfico
   if(this.ColumnUpdate(__FUNCTION__,table_model,table,col,cells_redraw) && chart_redraw)
      ::ChartRedraw(this.m_chart_id);
  }

En el modelo de la tabla, configuramos los indicadores de visualización de la hora indicados para la columna y llamamos al método de actualización de la columna de la tabla.

Método que establece el indicador para mostrar los nombres de los colores en la columna especificada:

//+------------------------------------------------------------------+
//| Establece el indicador para mostrar los nombres de los colores   |
//| en la columna indicada (Modelo + Vista)                          |
//+------------------------------------------------------------------+
void CTableControl::ColumnSetColorNamesFlag(const uint table,const uint col,const bool flag,const bool cells_redraw,const bool chart_redraw)
  {
//--- Obtenemos el modelo de la tabla
   CTable *table_model=this.GetTable(table);
   if(table_model==NULL)
     {
      ::PrintFormat("%s: Error. Failed to get CTable object",__FUNCTION__);
      return;
     }
//--- Establecemos los indicadores de visualización de la hora para la columna especificada en el modelo de la tabla 
   table_model.ColumnSetColorNamesFlag(col,flag);

//--- Actualizamos la visualización de los datos de la columna y, si se ha especificado, redibujamos el gráfico
   if(this.ColumnUpdate(__FUNCTION__,table_model,table,col,cells_redraw) && chart_redraw)
      ::ChartRedraw(this.m_chart_id);
  }

En el modelo de la tabla, establecemos el valor indicado del indicador para mostrar los nombres de los colores en la columna y llamamos al método de actualización de la columna de la tabla.

Método que establece el tipo de datos en la columna indicada:

//+------------------------------------------------------------------+
//| Establece el tipo de datos en la columna indicada (Modelo + Vista)   |
//+------------------------------------------------------------------+
void CTableControl::ColumnSetDatatype(const uint table,const uint col,const ENUM_DATATYPE type,const bool cells_redraw,const bool chart_redraw)
  {
//--- Obtenemos el modelo de la tabla
   CTable *table_model=this.GetTable(table);
   if(table_model==NULL)
     {
      ::PrintFormat("%s: Error. Failed to get CTable object",__FUNCTION__);
      return;
     }
//--- Establecemos el tipo de datos para la columna indicada en el modelo de la tabla 
   table_model.ColumnSetDatatype(col,type);

//--- Actualizamos la visualización de los datos de la columna y, si se ha especificado, redibujamos el gráfico
   if(this.ColumnUpdate(__FUNCTION__,table_model,table,col,cells_redraw) && chart_redraw)
      ::ChartRedraw(this.m_chart_id);
  }

En el modelo de la tabla, establecemos el tipo de datos indicado para la columna y llamamos al método de actualización de la columna de la tabla.

Método que establece el punto de anclaje del texto en la columna indicada:

//+------------------------------------------------------------------+
//| Establece el punto de anclaje del texto en la columna indicada (Vista)   |
//+------------------------------------------------------------------+
void CTableControl::ColumnSetTextAnchor(const uint table,const uint col,const ENUM_ANCHOR_POINT anchor,const bool cells_redraw,const bool chart_redraw)
  {
//--- Obtenemos la representación visual de la tabla
   CTableView *table_view=this.GetTableView(table);
   if(table_view==NULL)
     {
      ::PrintFormat("%s: Error. Failed to get CTableView object",__FUNCTION__);
      return;
     }
//--- En un bucle que recorre todas las filas de la tabla
   int total=table_view.RowsTotal();
   for(int i=0;i<total;i++)
     {
      //--- obtenemos el siguiente objeto de representación visual de la celda
      //--- y asignamos al objeto un nuevo punto de anclaje
      CTableCellView *cell_view=this.GetCellView(table,i,col);
      if(cell_view!=NULL && cell_view.TextAnchor()!=anchor)
         cell_view.SetTextAnchor(anchor,cells_redraw,false);
     }
//--- Si se indica, actualizamos el gráfico
   if(chart_redraw)
      ::ChartRedraw(this.m_chart_id);
  }

En el bucle que recorre todas las filas de la representación visual de la tabla, obtenemos la celda indicada de cada fila y le asignamos un nuevo punto de anclaje. Al finalizar el ciclo, actualizamos el gráfico.

Método que devuelve el valor como cadena de la celda indicada:

//+------------------------------------------------------------------+
//| Devuelve el valor de cadena de la celda especificada (Model)           |
//+------------------------------------------------------------------+
string CTableControl::CellValueAt(const uint table,const uint row,const uint col)
  {
   CTable *table_model=this.GetTable(table);
   return(table_model!=NULL ? table_model.CellValueAt(row,col) : ::StringFormat("%s: Error. Failed to get table model",__FUNCTION__));
  }

Obtenemos la celda requerida del modelo de la tabla y devolvemos su valor en forma de cadena. Si se produce un error, se devuelve el texto del error.

Método que devuelve la fila indicada de la tabla:

//+------------------------------------------------------------------+
//| Devuelve la fila especificada de la tabla (View)                 |
//+------------------------------------------------------------------+
CTableRowView *CTableControl::GetRowView(const uint table,const uint index)
  {
   CTableView *table_view=this.GetTableView(table);
   if(table_view==NULL)
     {
      ::PrintFormat("%s: Error. Failed to get CTableView object",__FUNCTION__);
      return NULL;
     }
   return table_view.GetRowView(index);
  }

Obtenemos la representación visual de la tabla por su índice y devolvemos desde ella un puntero a la fila requerida.

Método que devuelve la celda indicada de la tabla:

//+------------------------------------------------------------------+
//| Devuelve la celda especificada de la tabla (View)                |
//+------------------------------------------------------------------+
CTableCellView *CTableControl::GetCellView(const uint table,const uint row,const uint col)
  {
   CTableView *table_view=this.GetTableView(table);
   if(table_view==NULL)
     {
      ::PrintFormat("%s: Error. Failed to get CTableView object",__FUNCTION__);
      return NULL;
     }
   return table_view.GetCellView(row,col);
  }

Obtenemos la representación visual de la tabla por su índice y devolvemos desde ella un puntero a la celda requerida de la fila indicada.

Como podemos ver, esta clase es una sencilla clase auxiliar para crear tablas y trabajar con ellas. Todos sus métodos proporcionan funcionalidades de servicio para procesar, modificar, establecer y obtener datos de tablas, utilizando métodos de clases previamente definidas del modelo y de la representación visual de la tabla.

Comprobemos el resultado obtenido.


Probamos el resultado

Vamos a abrir el archivo del indicador de prueba \MQL5\Indicators\Tables\iTestTable.mq5 y a sobreescribirlo de la siguiente manera (los datos preparados previamente y la creación de la tabla aparecen resaltados en los colores correspondientes):

//+------------------------------------------------------------------+
//|                                                   iTestTable.mq5 |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 0
#property indicator_plots   0

//+------------------------------------------------------------------+
//| Bibliotecas que se incluyen                                      |
//+------------------------------------------------------------------+
#include "Controls\Controls.mqh"    // Biblioteca de elementos de control

//--- Puntero al objeto CTableControl
CTableControl *table_ctrl;

//+------------------------------------------------------------------+
//| Función de inicialización del indicador personalizado            |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Buscamos la subventana del gráfico
   int wnd=ChartWindowFind();

//--- Creamos los datos para la tabla
//--- Declaramos y rellenamos un array de encabezados de columnas de tamaño 4
   string captions[]={"Column 0","Column 1","Column 2","Column 3"};
   
//--- Declaramos y rellenamos un array de datos de 15x4
//--- El tipo de array puede ser double, long, datetime, color o string
   long array[15][4]={{ 1,  2,  3,  4},
                      { 5,  6,  7,  8},
                      { 9, 10, 11, 12},
                      {13, 14, 15, 16},
                      {17, 18, 19, 20},
                      {21, 22, 23, 24},
                      {25, 26, 27, 28},
                      {29, 30, 31, 32},
                      {33, 34, 35, 36},
                      {37, 38, 39, 40},
                      {41, 42, 43, 44},
                      {45, 46, 47, 48},
                      {49, 50, 51, 52},
                      {53, 54, 55, 56},
                      {57, 58, 59, 60}};
                      
//--- Creamos un control gráfico para gestionar tablas
   table_ctrl=new CTableControl("TableControl0",0,wnd,30,30,460,184);
   if(table_ctrl==NULL)
      return INIT_FAILED;

//--- El gráfico debe contener obligatoriamente un elemento principal
   table_ctrl.SetAsMain();

//--- Se pueden configurar los parámetros del control de tablas
   table_ctrl.SetID(0);                      // Identificador 
   table_ctrl.SetName("Table Control 0");    // Denominación

//--- Creamos el objeto de la tabla 0 (componente Model + View) a partir del array de tipo long de 15x4 y del array de tipo string de encabezados de columnas, ambas creadas anteriormente
   if(table_ctrl.TableCreate(array,captions)==NULL)
      return INIT_FAILED;
      
//--- Además, configuraremos que el texto de las columnas 1, 2 y 3 se alinee en el centro de la celda, y el de la columna 0, a la izquierda.
   table_ctrl.ColumnSetTextAnchor(0,0,ANCHOR_LEFT,true,false);
   table_ctrl.ColumnSetTextAnchor(0,1,ANCHOR_CENTER,true,false);
   table_ctrl.ColumnSetTextAnchor(0,2,ANCHOR_CENTER,true,false);
   table_ctrl.ColumnSetTextAnchor(0,3,ANCHOR_CENTER,true,false);

//--- Dibujaremos la tabla
   table_ctrl.Draw(true);
   
//--- Obtendremos la tabla con el índice 0 y la imprimiremos en el registro
   CTable *table=table_ctrl.GetTable(0);
   table.Print();
   
//--- Con éxito
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Función de desinicialización del indicador personalizado         |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Eliminamos el control de tablas y destruimos el gestor de recursos comunes de la biblioteca
   delete table_ctrl;
   CCommonManager::DestroyInstance();
  }
//+------------------------------------------------------------------+
//| Función de iteración del indicador personalizado                 |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   
//--- valor de retorno de «prev_calculated» para la siguiente llamada
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Función ChartEvent                                               |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- Llamamos al manejador OnChartEvent del control de tablas
   table_ctrl.OnChartEvent(id,lparam,dparam,sparam);
   
//--- Si el evento es el movimiento del cursor del ratón
   if(id==CHARTEVENT_MOUSE_MOVE)
     {
      //--- obtenemos las coordenadas del cursor
      int x=table_ctrl.CursorX();
      int y=table_ctrl.CursorY();
      
      //--- Establecemos el valor de la coordenada X en la celda 0 de la fila 1
      table_ctrl.CellSetValue(0,1,0,x,false);
      
      //--- establecemos el valor de la coordenada Y en la celda 1 de la fila 1
      //--- El color del texto de la celda depende del signo de la coordenada Y (si el valor es negativo, el texto aparece en rojo)
      table_ctrl.CellSetForeColor(0,1,1,(y<0 ? clrRed : table_ctrl.ForeColor()),false);
      table_ctrl.CellSetValue(0,1,1,y,true);
     }
  }
//+------------------------------------------------------------------+
//| Temporizador                                                     |
//+------------------------------------------------------------------+
void OnTimer(void)
  {
//--- Llamamos al manejador OnTimer del control de tablas
   table_ctrl.OnTimer();
  }
//+------------------------------------------------------------------+

En el manejador de eventos, comprobaremos cómo se pueden escribir determinados datos en las celdas en tiempo real. Leeremos las coordenadas del cursor y las escribiremos en las dos primeras celdas de la segunda fila desde arriba. Además, mostraremos en rojo el valor de la coordenada Y del cursor cuando sea negativo.

Compilaremos el indicador y lo ejecutaremos en el gráfico:

Como podemos ver, la interacción prevista entre la tabla y el usuario funciona.

Por supuesto, hay algunos matices a la hora de mostrar la representación visual de la tabla al interactuar con el cursor, pero todo ello se irá corrigiendo y perfeccionando poco a poco.



Conclusión

Por el momento, hemos creado una herramienta práctica para visualizar diversos datos en forma de tabla, que permite personalizar en cierta medida la visualización de la tabla creada por defecto.

Se puede crear una tabla a partir de distintos conjuntos de datos:

  • un array bidimensional de la tabla y un array de encabezados de columnas,
  • el número de columnas y filas,
  • matriz: el encabezado se crea automáticamente al estilo de Excel,
  • una lista de parámetros de usuario CList y un array de encabezados de columnas.

En el futuro, es posible que se mejoren las clases de tablas para facilitar la inserción y eliminación de filas, columnas y celdas individuales. Pero, por ahora, nos quedaremos con este formato de objeto para crear y visualizar tablas.


Programas utilizados en el artículo:

#
Nombre Tipo
Descripción
1 Tables.mqh Biblioteca de clases Clases para crear un modelo de tabla
2 Base.mqh Biblioteca de clases Clases para crear el objeto base de los controles
3 Controls.mqh Biblioteca de clases Clases de controles
4 iTestTable.mq5 Indicador de prueba Indicador para realizar pruebas con el control TableView
5 MQL5.zip Archivo Archivo comprimido con los archivos presentados anteriormente, para descomprimir en el directorio MQL5 del terminal de cliente

Todos los archivos creados se adjuntan al artículo para su estudio independiente. El archivo comprimido se puede descomprimir en la carpeta del terminal, y todos los archivos quedarán ubicados en la carpeta correspondiente: \MQL5\Indicators\Tables\.

El código fuente completo del proyecto, con todos los archivos descritos en el artículo, está disponible en el repositorio.


Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/19979

Archivos adjuntos |
Tables.mqh (272.47 KB)
Base.mqh (300.19 KB)
Controls.mqh (804.81 KB)
iTestTable.mq5 (12.11 KB)
MQL5.zip (130.08 KB)
Alexey Viktorov
Alexey Viktorov | 28 oct 2025 en 16:19
Gracias, Artem. Es un artículo realmente muy útil.
Maxim Kuznetsov
Maxim Kuznetsov | 28 oct 2025 en 18:19
MetaQuotes:
Al hacer clic con el ratón en el encabezado de una columna de la tabla (funcionamiento del componente Controller), se producirá un cambio en la disposición de los datos en el modelo de la tabla (reorganización del componente Model),
¡Artem! En un MVC auténtico, hacer clic con el ratón en una vista no cambia NADA en el modelo. En un mismo modelo puede haber muchas vistas diferentes al mismo tiempo, con distintos ordenamientos y filtrados.
Nguyen Tuấn Anh
Nguyen Tuấn Anh | 7 mar 2026 en 07:28
Gracias por tu código y tus instrucciones.
¿Podrías aplicar la separación de responsabilidades? No pongas todas las clases en un mismo archivo; sepáralas por dominio y refactorízalas.
Redes neuronales en el trading: Percepción adaptativa de la dinámica del mercado (Codificador) Redes neuronales en el trading: Percepción adaptativa de la dinámica del mercado (Codificador)
En este artículo se presenta la arquitectura integral del codificador STE-FlowNet, que combina memoria de pila, procesamiento recurrente y un mecanismo de correlación para extraer dependencias ocultas del mercado. Se muestra cómo estos módulos se integran secuencialmente en una cadena de cálculo única, capaz de realizar un análisis multifacético de series temporales.
Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 44): Desarrollo de un EA basado en señales de cruce de VWMA en MQL5 Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 44): Desarrollo de un EA basado en señales de cruce de VWMA en MQL5
Este artículo presenta una herramienta de señales de cruce de la media móvil ponderada por volumen (VWMA) para MetaTrader 5, diseñada para ayudar a los operadores a identificar posibles giros de tendencia alcistas y bajistas combinando la acción del precio con el volumen de negociación. El EA genera señales claras de compra y venta directamente en el gráfico, cuenta con un panel informativo y permite una personalización total por parte del usuario, lo que lo convierte en un complemento práctico para tu estrategia de trading.
Particularidades del trabajo con números del tipo double en MQL4 Particularidades del trabajo con números del tipo double en MQL4
En estos apuntes hemos reunido consejos para resolver los errores más frecuentes al trabajar con números del tipo double en los programas en MQL4.
Modelos matemáticos en las estrategias de rejilla Modelos matemáticos en las estrategias de rejilla
En este artículo analizaremos la aplicación de las matemáticas a las estrategias de rejilla. Además, analizaremos los principios básicos de funcionamiento de la estrategia, así como sus ventajas e inconvenientes. Usted aprenderá a crear una rejilla de trading, a establecer los parámetros óptimos y a gestionar los riesgos de forma eficaz.