Tablas en el paradigma MVC en MQL5: Columnas de tabla personalizables y ordenables
Índice
- Introducción
- Mejoramos las clases de la biblioteca
- Clase para crear tablas de forma sencilla
- Probamos el resultado
- Conclusión
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:
- lista de modelos de tablas,
- 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
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.
Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.
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),
¿Podrías aplicar la separación de responsabilidades? No pongas todas las clases en un mismo archivo; sepáralas por dominio y refactorízalas.