DoEasy. Elementos de control (Parte 18): Preparamos la funcionalidad para el scrolling de las pestañas en TabControl
197
0
Contenido
Concepto
Continuamos trabajando con el objeto WinForms TabControl. Si observa cómo funciona este control en MS Visual Studio, verá este comportamiento: si una fila de encabezados no cabe dentro de la anchura del control, por ejemplo, los encabezados se cortarán en los bordes. Si seleccionamos un encabezado recortado al borde derecho del control, toda la fila de encabezados se desplazará a la izquierda para que el encabezado seleccionado se ajuste a la anchura del contenedor; es decir, el primer encabezado previamente visible se desplazará al borde izquierdo del control y el siguiente encabezado se hará visible por el lado izquierdo. De la misma forma, el scrolling de la barra de encabezado funcionará al clicar en sus botones de desplazamiento, que aparecerán cuando la barra de encabezado no se ajuste al tamaño del control.
Hoy implementaremos el mismo comportamiento para nuestro objeto WinForms TabControl. Pero, en esta ocasión, su scrolling no se realizará con los botones, nos limitaremos a desplazar la línea del encabezado a la izquierda cuando seleccionemos un encabezado recortado a la derecha, y solo si los encabezados se colocan en la parte superior o inferior del control. Esta será una prueba preliminar de dicha funcionalidad: en el próximo artículo, nos basaremos en ella para crear métodos completos para el scrolling de todos los encabezados a ambos lados del control, tanto al seleccionar un encabezado recortado como al desplazar la fila de encabezados con los botones de control.
Por cierto, hoy colocaremos estos botones en las posiciones adecuadas, por si fueran necesarios, y resultarán necesarios cuando una fila de encabezados no quepa dentro del control. En este caso, si los encabezados se colocan en la parte superior o inferior, los botones de control de scrolling se colocarán en la parte superior derecha o inferior derecha, respectivamente. Si los encabezados están a la izquierda, los botones de control del scrolling estarán en la parte superior izquierda, y si los encabezados están a la derecha, los botones estarán en la parte inferior derecha. Los controles de scrolling de la fila de encabezado se ubicarán con un margen de un píxel a partir de la posición del campo de la pestaña, mientras que los encabezados de las pestañas se recortarán hasta el borde de esos botones (no por el borde del contenedor), también con un margen de un píxel. Así, estos controles se colocarán según su ubicación en el control TabControl en MS Visual Studio.
Mejorando las clases de la biblioteca
En el archivo \MQL5\Include\DoEasy\Data.mqh, introduciremos el índice del nuevo mensaje:
//--- CDataPropObj MSG_DATA_PROP_OBJ_OUT_OF_PROP_RANGE, // Passed property is out of object property range MSG_GRAPH_OBJ_FAILED_CREATE_NEW_HIST_OBJ, // Failed to create an object of the graphical object change history MSG_GRAPH_OBJ_FAILED_ADD_OBJ_TO_HIST_LIST, // Failed to add the change history object to the list MSG_GRAPH_OBJ_FAILED_GET_HIST_OBJ, // Failed to receive the change history object MSG_GRAPH_OBJ_FAILED_INC_ARRAY_SIZE, // Failed to increase the array size //--- CGraphElementsCollection MSG_GRAPH_OBJ_FAILED_GET_ADDED_OBJ_LIST, // Failed to get the list of newly added objects MSG_GRAPH_OBJ_FAILED_GET_OBJECT_NAMES, // Failed to get object names MSG_GRAPH_OBJ_FAILED_DETACH_OBJ_FROM_LIST, // Failed to remove a graphical object from the list MSG_GRAPH_OBJ_FAILED_DELETE_OBJ_FROM_LIST, // Failed to remove a graphical object from the list MSG_GRAPH_OBJ_FAILED_DELETE_OBJ_FROM_CHART, // Failed to remove a graphical object from the chart MSG_GRAPH_OBJ_FAILED_ADD_OBJ_TO_DEL_LIST, // Failed to set a graphical object to the list of removed objects MSG_GRAPH_OBJ_FAILED_ADD_OBJ_TO_RNM_LIST, // Failed to set a graphical object to the list of renamed objects
y el texto del mensaje correspondiente al nuevo índice añadido:
//--- CDataPropObj {"Переданное свойство находится за пределами диапазона свойств объекта","The passed property is outside the range of the object's properties"}, {"Не удалось создать объект истории изменений графического объекта","Failed to create a graphical object change history object"}, {"Не удалось добавить объект истории изменений в список","Failed to add change history object to the list"}, {"Не удалось получить объект истории изменений","Failed to get change history object"}, {"Не удалось увеличить размер массива","Failed to increase array size"}, //--- CGraphElementsCollection {"Не удалось получить список вновь добавленных объектов","Failed to get the list of newly added objects"}, {"Не удалось получить имена объектов","Failed to get object names"}, {"Не удалось изъять графический объект из списка","Failed to detach graphic object from the list"}, {"Не удалось удалить графический объект из списка","Failed to delete graphic object from the list"}, {"Не удалось удалить графический объект с графика","Failed to delete graphic object from the chart"}, {"Не удалось поместить графический объект в список удалённых объектов","Failed to place graphic object in the list of deleted objects"}, {"Не удалось поместить графический объект в список переименованных объектов","Failed to place graphic object in the list of renamed objects"},
Al clicar en los controles, no siempre podremos manejar este evento en la misma clase. Podrían darse situaciones en las que necesitemos llamar a una funcionalidad en un evento de este tipo desde otras clases que no están disponibles en la clase en la que está escrito el manejador de eventos del ratón para el objeto pulsado. Aquí, la solución propuesta es la siguiente: al clicar en el control, enviaremos un evento al gráfico del programa de control, y la biblioteca procesará este evento enviándolo a la clase donde se encuentra la funcionalidad para procesar dicho evento.
Así se implementarán algunos manejadores de eventos internos, pero además de las necesidades de la biblioteca, todavía necesitaremos enviar al programa de control algunos eventos para que puedan ser manejados desde allí. Por ello, necesitaremos usar un modelo de eventos de todos modos, para no tener que organizar el procesamiento de eventos de los elementos gráficos a través de un temporizador.
En el archivo \MQL5\Include\DoEasy\Defines.mqh, escribiremos una lista de posibles eventos de los objetos de la biblioteca WinForms:
//+------------------------------------------------------------------+ //| List of possible WinForms control events | //+------------------------------------------------------------------+ enum ENUM_WF_CONTROL_EVENT { WF_CONTROL_EVENT_NO_EVENT = GRAPH_OBJ_EVENTS_NEXT_CODE,// No event WF_CONTROL_EVENT_CLICK, // "Click on the control" event WF_CONTROL_EVENT_TAB_SELECT, // "TabControl tab selection" event }; #define WF_CONTROL_EVENTS_NEXT_CODE (WF_CONTROL_EVENT_TAB_SELECT+1) // The code of the next event after the last graphical element event code //+------------------------------------------------------------------+ //| Mode of automatic interface element resizing | //+------------------------------------------------------------------+ enum ENUM_CANV_ELEMENT_AUTO_SIZE_MODE { CANV_ELEMENT_AUTO_SIZE_MODE_GROW, // Increase only CANV_ELEMENT_AUTO_SIZE_MODE_GROW_SHRINK, // Increase and decrease }; //+------------------------------------------------------------------+
Hasta ahora solo hay dos eventos en la enumeración: el clic en el control y el evento de selección de pestañas en el control TabControl, que usaremos hoy para procesar el clic en un encabezado de pestaña recortado para organizar el scrolling de una fila de encabezados de pestañas.
Antes, creábamos controles auxiliares que no suponen objetos WinForms independientes, sino que se utilizan para crear otros controles. Todos ellos eran colocados en una carpeta común de objetos WinForms. Como estamos empezando a ver más y más de ellos, vamos a crear una carpeta aparte llamada Helpers en la ruta \MQL5\Include\DoEasy\Objects\Graph\WForms\Helpers\, y a trasladar a esta todos los archivos auxiliares de los objetos WinForms, tales como ArrowButton.mqh, ArrowDownButton.mqh, ArrowLeftButton.mqh, ArrowLeftRightBox.mqh, ArrowRightButton.mqh, ArrowUpButton.mqh, ArrowUpDownBox.mqh, ListBoxItem.mqh, TabField.mqh y TabHeader.mqh.
Como ahora los archivos de los objetos auxiliares se encuentran en una nueva ruta, deberemos corregir las líneas de ruta de los archivos incluidos en algunos archivos de la biblioteca.
En el archivo \MQL5\Include\DoEasy\Objects\Graph\WForms\Helpers\ListBoxItem.mqh, corregiremos la ruta:
//+------------------------------------------------------------------+ //| ListBoxItem.mqh | //| Copyright 2022, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "..\Common Controls\Button.mqh" //+------------------------------------------------------------------+ //| Label object class of WForms controls | //+------------------------------------------------------------------+
En el archivo \MQL5\Include\DoEasy\Objects\Graph\WForms\Helpers\ArrowButton.mqh:
//+------------------------------------------------------------------+ //| ArrowButton.mqh | //| Copyright 2022, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "..\Common Controls\Button.mqh" //+------------------------------------------------------------------+ //| Arrow Button object class of WForms controls | //+------------------------------------------------------------------+
En el archivo \MQL5\Include\DoEasy\Objects\Graph\WForms\Helpers\ArrowLeftRightBox.mqh:
//+------------------------------------------------------------------+ //| ArrowLeftRightBox.mqh | //| Copyright 2022, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "..\Containers\Panel.mqh" //+------------------------------------------------------------------+ //| ArrowLeftRightBox object class of WForms controls | //+------------------------------------------------------------------+
En el archivo \MQL5\Include\DoEasy\Objects\Graph\WForms\Helpers\ArrowUpDownBox.mqh:
//+------------------------------------------------------------------+ //| ArrowUpDownBox.mqh | //| Copyright 2022, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "..\Containers\Panel.mqh" //+------------------------------------------------------------------+ //| ArrowUpDownBox object class of the WForms controls | //+------------------------------------------------------------------+
En el archivo \MQL5\Include\DoEasy\Objects\Graph\WForms\Common Controls\ElementsListBox.mqh:
//+------------------------------------------------------------------+ //| ElementsListBox.mqh | //| Copyright 2022, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "..\Containers\Container.mqh" #include "..\Helpers\ListBoxItem.mqh" //+------------------------------------------------------------------+ //| Class of the base object of the WForms control list | //+------------------------------------------------------------------+
En el archivo \MQL5\Include\DoEasy\Objects\Graph\WForms\Containers\Panel.mqh, ajustaremos las líneas de conexión de los archivos, ahora se encontrarán en la nueva carpeta:
//+------------------------------------------------------------------+ //| Panel.mqh | //| Copyright 2022, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "Container.mqh" #include "..\Helpers\TabField.mqh" #include "..\Helpers\ArrowButton.mqh" #include "..\Helpers\ArrowUpButton.mqh" #include "..\Helpers\ArrowDownButton.mqh" #include "..\Helpers\ArrowLeftButton.mqh" #include "..\Helpers\ArrowRightButton.mqh" #include "..\Helpers\ArrowUpDownBox.mqh" #include "..\Helpers\ArrowLeftRightBox.mqh" #include "GroupBox.mqh" #include "TabControl.mqh" #include "..\..\WForms\Common Controls\ListBox.mqh" #include "..\..\WForms\Common Controls\CheckedListBox.mqh" #include "..\..\WForms\Common Controls\ButtonListBox.mqh" //+------------------------------------------------------------------+ //| Panel object class of WForms controls | //+------------------------------------------------------------------+
asimismo, cambiaremos el método CreateNewGObject(), simplemente pondremos todas las líneas en sus casos en una línea en el interruptor, haciendo el método más pequeño y más fácil de leer:
//+------------------------------------------------------------------+ //| Create a new graphical object | //+------------------------------------------------------------------+ CGCnvElement *CPanel::CreateNewGObject(const ENUM_GRAPH_ELEMENT_TYPE type, const int obj_num, const string descript, const int x, const int y, const int w, const int h, const color colour, const uchar opacity, const bool movable, const bool activity) { CGCnvElement *element=NULL; switch(type) { case GRAPH_ELEMENT_TYPE_ELEMENT : element=new CGCnvElement(type,this.ID(),obj_num,this.ChartID(),this.SubWindow(),descript,x,y,w,h,colour,opacity,movable,activity); break; case GRAPH_ELEMENT_TYPE_FORM : element=new CForm(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CONTAINER : element=new CContainer(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_GROUPBOX : element=new CGroupBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_PANEL : element=new CPanel(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LABEL : element=new CLabel(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CHECKBOX : element=new CCheckBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_RADIOBUTTON : element=new CRadioButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_BUTTON : element=new CButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LIST_BOX : element=new CListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LIST_BOX_ITEM : element=new CListBoxItem(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CHECKED_LIST_BOX : element=new CCheckedListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_BUTTON_LIST_BOX : element=new CButtonListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_HEADER : element=new CTabHeader(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_FIELD : element=new CTabField(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_CONTROL : element=new CTabControl(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON : element=new CArrowButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_UP : element=new CArrowUpButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_DOWN : element=new CArrowDownButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_LEFT : element=new CArrowLeftButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_RIGHT : element=new CArrowRightButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX : element=new CArrowUpDownBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX : element=new CArrowLeftRightBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; default : break; } if(element==NULL) ::Print(DFUN,CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ),this.TypeElementDescription(type)); return element; } //+------------------------------------------------------------------+
El método antes era así:
//+------------------------------------------------------------------+ //| Create a new graphical object | //+------------------------------------------------------------------+ CGCnvElement *CPanel::CreateNewGObject(const ENUM_GRAPH_ELEMENT_TYPE type, const int obj_num, const string descript, const int x, const int y, const int w, const int h, const color colour, const uchar opacity, const bool movable, const bool activity) { CGCnvElement *element=NULL; switch(type) { case GRAPH_ELEMENT_TYPE_ELEMENT : element=new CGCnvElement(type,this.ID(),obj_num,this.ChartID(),this.SubWindow(),descript,x,y,w,h,colour,opacity,movable,activity); break; case GRAPH_ELEMENT_TYPE_FORM : element=new CForm(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CONTAINER : element=new CContainer(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_GROUPBOX : element=new CGroupBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_PANEL : element=new CPanel(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LABEL : element=new CLabel(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CHECKBOX : element=new CCheckBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_RADIOBUTTON : element=new CRadioButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_BUTTON : element=new CButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LIST_BOX : element=new CListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LIST_BOX_ITEM : element=new CListBoxItem(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CHECKED_LIST_BOX : element=new CCheckedListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_BUTTON_LIST_BOX : element=new CButtonListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_HEADER : element=new CTabHeader(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_FIELD : element=new CTabField(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_CONTROL : element=new CTabControl(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON : element=new CArrowButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_UP : element=new CArrowUpButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_DOWN : element=new CArrowDownButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_LEFT : element=new CArrowLeftButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_RIGHT : element=new CArrowRightButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX : element=new CArrowUpDownBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX : element=new CArrowLeftRightBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; default: break; } if(element==NULL) ::Print(DFUN,CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ),this.TypeElementDescription(type)); return element; } //+------------------------------------------------------------------+
... y este formato nos impedía ver todo el método de una sola vez, lo cual resulta menos útil para comparar los mismos métodos en otras clases en las que lo cambiaremos exactamente de la misma manera para realizar la comparación con mayor claridad. ¿Para qué nos sirve todo esto? Podemos ver que este método es el mismo en diferentes clases contenedoras y, en consecuencia, deberemos organizarlo para que sea el único para todas las clases en las que existe; en este caso, además, todas las clases creadas en él deberán ser accesibles desde su ubicación. En futuros artículos, reflexionaremos sobre este punto.
En el archivo \MQL5\Include\DoEasy\Objects\Graph\WForms\Helpers\TabField.mqh, ajustaremos la línea de conexión del archivo de clase del objeto de panel:
//+------------------------------------------------------------------+ //| TabField.mqh | //| Copyright 2022, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "..\Containers\Panel.mqh" //+------------------------------------------------------------------+ //| TabHeader object class of WForms TabControl | //+------------------------------------------------------------------+
y cambiaremos el formato del método CreateNewGObject():
//+------------------------------------------------------------------+ //| Create a new graphical object | //+------------------------------------------------------------------+ CGCnvElement *CTabField::CreateNewGObject(const ENUM_GRAPH_ELEMENT_TYPE type, const int obj_num, const string descript, const int x, const int y, const int w, const int h, const color colour, const uchar opacity, const bool movable, const bool activity) { CGCnvElement *element=NULL; switch(type) { case GRAPH_ELEMENT_TYPE_ELEMENT : element=new CGCnvElement(type,this.ID(),obj_num,this.ChartID(),this.SubWindow(),descript,x,y,w,h,colour,opacity,movable,activity); break; case GRAPH_ELEMENT_TYPE_FORM : element=new CForm(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CONTAINER : element=new CContainer(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_GROUPBOX : element=new CGroupBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_PANEL : element=new CPanel(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LABEL : element=new CLabel(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CHECKBOX : element=new CCheckBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_RADIOBUTTON : element=new CRadioButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_BUTTON : element=new CButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LIST_BOX : element=new CListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LIST_BOX_ITEM : element=new CListBoxItem(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CHECKED_LIST_BOX : element=new CCheckedListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_BUTTON_LIST_BOX : element=new CButtonListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_HEADER : element=new CTabHeader(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_FIELD : element=new CTabField(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_CONTROL : element=new CTabControl(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON : element=new CArrowButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_UP : element=new CArrowUpButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_DOWN : element=new CArrowDownButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_LEFT : element=new CArrowLeftButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_RIGHT : element=new CArrowRightButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX : element=new CArrowUpDownBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX : element=new CArrowLeftRightBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; default : break; } if(element==NULL) ::Print(DFUN,CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ),this.TypeElementDescription(type)); return element; } //+------------------------------------------------------------------+
En el archivo \MQL5\Include\DoEasy\Objects\Graph\WForms\Containers\GroupBox.mqh, también cambiaremos el formato:
//+------------------------------------------------------------------+ //| Create a new graphical object | //+------------------------------------------------------------------+ CGCnvElement *CGroupBox::CreateNewGObject(const ENUM_GRAPH_ELEMENT_TYPE type, const int obj_num, const string descript, const int x, const int y, const int w, const int h, const color colour, const uchar opacity, const bool movable, const bool activity) { CGCnvElement *element=NULL; switch(type) { case GRAPH_ELEMENT_TYPE_ELEMENT : element=new CGCnvElement(type,this.ID(),obj_num,this.ChartID(),this.SubWindow(),descript,x,y,w,h,colour,opacity,movable,activity); break; case GRAPH_ELEMENT_TYPE_FORM : element=new CForm(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CONTAINER : element=new CContainer(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_GROUPBOX : element=new CGroupBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_PANEL : element=new CPanel(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LABEL : element=new CLabel(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CHECKBOX : element=new CCheckBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_RADIOBUTTON : element=new CRadioButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_BUTTON : element=new CButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LIST_BOX : element=new CListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LIST_BOX_ITEM : element=new CListBoxItem(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CHECKED_LIST_BOX : element=new CCheckedListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_BUTTON_LIST_BOX : element=new CButtonListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_HEADER : element=new CTabHeader(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_FIELD : element=new CTabField(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_CONTROL : element=new CTabControl(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON : element=new CArrowButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_UP : element=new CArrowUpButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_DOWN : element=new CArrowDownButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_LEFT : element=new CArrowLeftButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_RIGHT : element=new CArrowRightButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX : element=new CArrowUpDownBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX : element=new CArrowLeftRightBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; default : break; } if(element==NULL) ::Print(DFUN,CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ),this.TypeElementDescription(type)); return element; } //+------------------------------------------------------------------+
Tras introducir estos cambios en todos los archivos de las clases contenedoras, los métodos resultarán más fáciles de leer y se podrán comparar entre sí de un vistazo. Serán iguales, y esto significará que deberemos crear un único método o función común y llamarlos en estos métodos de todas las clases contenedoras.
Al clicar en un encabezado de pestaña que no se extienda completamente más allá del contenedor y esté parcialmente recortado, deberemos desplazar la fila del encabezado para que ésta resulte totalmente visible. El desplazamiento de la fila de encabezados se producirá en la clase de control TabControl, que no resulta visible en la clase del objeto de encabezado de la pestaña porque las pestañas se encuentran dentro del objeto TabControl. Por ello, necesitaremos enviar un mensaje de evento que registre el número del encabezado sobre el que se ha clicado y los nombres de los objetos dentro de los que se ha producido el evento. Los nombres deben ser tanto del objeto TabControl como del objeto al que está unido: estos serán los nombres del objeto principal y del objeto TabControl. En el manejador de eventos de la biblioteca, conociendo estos nombres, podremos identificar de forma unívoca el objeto principal al que están unidos todos los demás, y entre ellos el TabControl cuyo nombre también conoceremos, y seleccionar este en caso de que haya varios objetos TabControl unidos al objeto principal.
Todos los objetos del mismo tipo se construirán ahora en la biblioteca con nombres distintos, independientemente del gráfico en el que se hayan creado. Por consiguiente, solo necesitaremos conocer el nombre del objeto para encontrarlo. Todos los métodos para seleccionar un objeto según su nombre, ahora disponibles en la biblioteca, requerirán también el identificador del gráfico sobre el que se crean. Como no se requiere un identificador de gráfico para seleccionar de forma exclusiva un objeto según su nombre (por cierto, esto solo resulta cierto para esta biblioteca, porque el terminal del cliente permite crear objetos con el mismo nombre pero en diferentes gráficos), y no tenemos todavía un método de este tipo, vamos a crearlo.
En el archivo \MQL5\Include\DoEasy\Objects\Graph\WForms\WinFormBase.mqh, declararemos el método que retornará un elemento gráfico según su nombre:
public: //--- Draw a frame virtual void DrawFrame(void){} //--- Return by type the (1) list, (2) the number of bound controls, the bound control (3) by index in the list, (4) by name CArrayObj *GetListElementsByType(const ENUM_GRAPH_ELEMENT_TYPE type); int ElementsTotalByType(const ENUM_GRAPH_ELEMENT_TYPE type); CGCnvElement *GetElementByType(const ENUM_GRAPH_ELEMENT_TYPE type,const int index); CGCnvElement *GetElementByName(const string name); //--- Clear the element filling it with color and opacity
Escribiremos su implementación fuera del cuerpo de la clase:
//+------------------------------------------------------------------+ //| Return the bound element by name | //+------------------------------------------------------------------+ CGCnvElement *CWinFormBase::GetElementByName(const string name) { string nm=(::StringFind(name,this.m_name_prefix)<0 ? this.m_name_prefix : "")+name; CArrayObj *list=CSelect::ByGraphCanvElementProperty(this.GetListElements(),CANV_ELEMENT_PROP_NAME_OBJ,nm,EQUAL); return(list!=NULL ? list.At(0) : NULL); } //+------------------------------------------------------------------+
Aquí, primero comprobaremos que el nombre del objeto buscado contenga el nombre del programa y, si no está en el nombre transmitido al método, añadiremos el nombre del programa al nombre del objeto buscado. A continuación, obtendremos una lista de elementos gráficos adjuntos al control que tienen el nombre que buscamos (solo deberá haber un objeto de este tipo, si se encuentra uno). Esto retornará el puntero al único objeto de la lista. Si la lista está vacía, o no se ha creado, el método retornará NULL.
En la clase de objeto de encabezado de la pestaña, necesitaremos conocer las dimensiones de los controles de la fila de encabezados de scrolling creados en la clase de objeto TabControl. Esto resultará necesario para asegurar que los encabezados se recorten correctamente si los controles son visibles. Nuevamente, los objetos de encabezado no sabrán nada de los objetos colocados en el objeto de la clase de la que ellos mismos han sido creados, pero podemos transmitir todos los tamaños que necesitemos de este objeto a los objetos de encabezado, y entonces los encabezados conocerán "algunos" tamaños que deberán considerarse a la hora de recortar la zona invisible, además, para entender cuando estos tamaños deberán ser considerados y cuando no, deberemos enviar a los objetos de encabezado los controles de visibilidad de las líneas de scrolling de los encabezados.
De esta manera, aunque los encabezados no sepan nada de estos objetos, dentro de las clases de objetos de encabezado habrá variables que almacenarán toda la información que necesitemos, y podremos escribir esta información en los objetos de encabezado de la clase del objeto TabControl. De esta forma, emularemos la visibilidad de los parámetros requeridos en un objeto que no sabrá nada sobre el objeto, pero que utilizará sus parámetros para hacer su trabajo.
En el archivo de la clase de objeto de la pestaña \MQL5\Include\DoEasy\Objects\Graph\WForms\Helpers\TabHeader.mqh, corregiremos la línea de acceso al archivo y declararemos las variables para guardar las propiedades de los controles de scrolling de la fila de encabezados:
//+------------------------------------------------------------------+ //| TabHeader.mqh | //| Copyright 2022, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "..\Common Controls\Button.mqh" //+------------------------------------------------------------------+ //| TabHeader object class of WForms TabControl | //+------------------------------------------------------------------+ class CTabHeader : public CButton { private: int m_width_off; // Object width in the released state int m_height_off; // Object height in the released state int m_width_on; // Object width in the selected state int m_height_on; // Object height in the selected state bool m_arr_butt_ud_visible_flag; // Tab header "up-down" control buttons visibility flag bool m_arr_butt_lr_visible_flag; // Tab header "left-right" control buttons visibility flag int m_arr_butt_ud_size; // Tab header "up-down" control buttons size int m_arr_butt_lr_size; // Tab header "left-right" control buttons size //--- Adjust the size and location of the element depending on the state
En la sección pública de la clase, escribiremos los métodos para gestionar las variables privadas declaradas:
public: //--- Return the visibility of the (1) left-right, (2) up-down buttons bool IsVisibleLeftRightBox(void) const { return this.m_arr_butt_lr_visible_flag; } bool IsVisibleUpDownBox(void) const { return this.m_arr_butt_ud_visible_flag; } //--- Set the visibility of the (1) left-right, (2) up-down buttons void SetVisibleLeftRightBox(const bool flag) { this.m_arr_butt_lr_visible_flag=flag; } void SetVisibleUpDownBox(const bool flag) { this.m_arr_butt_ud_visible_flag=flag; } //--- Set the size of the (1) left-right, (2) up-down buttons void SetSizeLeftRightBox(const int value) { this.m_arr_butt_lr_size=value; } void SetSizeUpDownBox(const int value) { this.m_arr_butt_ud_size=value; } //--- Find and return a pointer to the field object corresponding to the tab index
Los datos reales de todas estas variables se enviarán a la clase de objeto TabControl, y aquí se usarán para calcular el tamaño de la zona visible y recortar la parte de la imagen que esté fuera de la zona visible.
Para permitirnos usar los valores de las nuevas variables en el cálculo de la zona visible, necesitaremos redefinir aquí el método virtual Crop() del objeto padre.
Vamos a declarar un método en la zona pública de la clase:
//--- Redraw the object virtual void Redraw(bool redraw); //--- Clear the element filling it with color and opacity virtual void Erase(const color colour,const uchar opacity,const bool redraw=false); //--- Clear the element with a gradient fill virtual void Erase(color &colors[],const uchar opacity,const bool vgradient,const bool cycle,const bool redraw=false); //--- Crop the image outlined by the previously specified rectangular visibility scope virtual void Crop(void); //--- Last mouse event handler virtual void OnMouseEventPostProcessing(void);
Escribiremos su implementación fuera del cuerpo de la misma:
//+------------------------------------------------------------------+ //| Crop the image outlined by the calculated | //| rectangular visibility scope | //+------------------------------------------------------------------+ void CTabHeader::Crop(void) { //--- Get the pointer to the base object CGCnvElement *base=this.GetBase(); //--- If the object does not have a base object it is attached to, then there is no need to crop the hidden areas - leave if(base==NULL) return; //--- Set the initial coordinates and size of the visibility scope to the entire object int vis_x=0; int vis_y=0; int vis_w=this.Width(); int vis_h=this.Height(); //--- Set the size of the top, bottom, left and right areas that go beyond the container int crop_top=0; int crop_bottom=0; int crop_left=0; int crop_right=0; //--- Get the additional size, by which to crop the titles when the arrow buttons are visible int add_size_lr=(this.IsVisibleLeftRightBox() ? this.m_arr_butt_lr_size : 0); int add_size_ud=(this.IsVisibleUpDownBox() ? this.m_arr_butt_ud_size : 0); //--- Calculate the boundaries of the container area, inside which the object is fully visible int top=fmax(base.CoordY()+(int)base.GetProperty(CANV_ELEMENT_PROP_BORDER_SIZE_TOP),base.CoordYVisibleArea())+(this.Alignment()==CANV_ELEMENT_ALIGNMENT_LEFT ? add_size_ud : 0); int bottom=fmin(base.BottomEdge()-(int)base.GetProperty(CANV_ELEMENT_PROP_BORDER_SIZE_BOTTOM),base.BottomEdgeVisibleArea()+1)-(this.Alignment()==CANV_ELEMENT_ALIGNMENT_RIGHT ? add_size_ud : 0); int left=fmax(base.CoordX()+(int)base.GetProperty(CANV_ELEMENT_PROP_BORDER_SIZE_LEFT),base.CoordXVisibleArea()); int right=fmin(base.RightEdge()-(int)base.GetProperty(CANV_ELEMENT_PROP_BORDER_SIZE_RIGHT),base.RightEdgeVisibleArea()+1)-add_size_lr; //--- Calculate the values of the top, bottom, left and right areas, at which the object goes beyond //--- the boundaries of the container area, inside which the object is fully visible crop_top=this.CoordY()-top; if(crop_top<0) vis_y=-crop_top; crop_bottom=bottom-this.BottomEdge()-1; if(crop_bottom<0) vis_h=this.Height()+crop_bottom-vis_y; crop_left=this.CoordX()-left; if(crop_left<0) vis_x=-crop_left; crop_right=right-this.RightEdge()-1; if(crop_right<0) vis_w=this.Width()+crop_right-vis_x; //--- If there are areas that need to be hidden, call the cropping method with the calculated size of the object visibility scope if(crop_top<0 || crop_bottom<0 || crop_left<0 || crop_right<0) this.Crop(vis_x,vis_y,vis_w,vis_h); } //+------------------------------------------------------------------+
Aquí, a diferencia del método original, hemos añadido tamaños adicionales que deberemos tener en cuenta al calcular la zona de visibilidad. Si en las variables de bandera está escrito que el control de scrolling es visible, entonces usaremos el tamaño del control visible de scrolling para el cálculo. Si en la variable está escrito que el objeto no es visible, utilizaremos cero en lugar de su tamaño. Los objetos de botón con flechas izquierda-derecha y los objetos de botón con flechas arriba-abajo utilizan sus propias variables y, por lo tanto, sus propios cálculos aparte de las dimensiones adicionales para calcular la zona de visibilidad.
En los constructores de la clase, inicializaremos las nuevas variables con valores por defecto:
//+------------------------------------------------------------------+ //| Protected constructor with an object type, | //| chart ID and subwindow | //+------------------------------------------------------------------+ CTabHeader::CTabHeader(const ENUM_GRAPH_ELEMENT_TYPE type, const long chart_id, const int subwindow, const string descript, const int x, const int y, const int w, const int h) : CButton(type,chart_id,subwindow,descript,x,y,w,h) { this.SetTypeElement(GRAPH_ELEMENT_TYPE_WF_TAB_HEADER); this.m_type=OBJECT_DE_TYPE_GWF_HELPER; this.SetAlignment(CANV_ELEMENT_ALIGNMENT_TOP); this.SetToggleFlag(true); this.SetGroupButtonFlag(true); this.SetText(TypeGraphElementAsString(this.TypeGraphElement())); this.SetForeColor(CLR_DEF_FORE_COLOR,true); this.SetOpacity(CLR_DEF_CONTROL_TAB_HEAD_OPACITY,true); this.SetBackgroundColor(CLR_DEF_CONTROL_TAB_HEAD_BACK_COLOR,true); this.SetBackgroundColorMouseDown(CLR_DEF_CONTROL_TAB_HEAD_MOUSE_DOWN); this.SetBackgroundColorMouseOver(CLR_DEF_CONTROL_TAB_HEAD_MOUSE_OVER); this.SetBackgroundStateOnColor(CLR_DEF_CONTROL_TAB_HEAD_BACK_COLOR_ON,true); this.SetBackgroundStateOnColorMouseDown(CLR_DEF_CONTROL_TAB_HEAD_BACK_DOWN_ON); this.SetBackgroundStateOnColorMouseOver(CLR_DEF_CONTROL_TAB_HEAD_BACK_OVER_ON); this.SetBorderStyle(FRAME_STYLE_SIMPLE); this.SetBorderColor(CLR_DEF_CONTROL_TAB_HEAD_BORDER_COLOR,true); this.SetBorderColorMouseDown(CLR_DEF_CONTROL_TAB_HEAD_BORDER_MOUSE_DOWN); this.SetBorderColorMouseOver(CLR_DEF_CONTROL_TAB_HEAD_BORDER_MOUSE_OVER); this.SetPadding(6,3,6,3); this.SetSizes(w,h); this.SetState(false); this.m_arr_butt_ud_visible_flag=false; this.m_arr_butt_lr_visible_flag=false; this.m_arr_butt_ud_size=0; this.m_arr_butt_lr_size=0; } //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CTabHeader::CTabHeader(const long chart_id, const int subwindow, const string descript, const int x, const int y, const int w, const int h) : CButton(GRAPH_ELEMENT_TYPE_WF_TAB_HEADER,chart_id,subwindow,descript,x,y,w,h) { this.SetTypeElement(GRAPH_ELEMENT_TYPE_WF_TAB_HEADER); this.m_type=OBJECT_DE_TYPE_GWF_HELPER; this.SetAlignment(CANV_ELEMENT_ALIGNMENT_TOP); this.SetToggleFlag(true); this.SetGroupButtonFlag(true); this.SetText(TypeGraphElementAsString(this.TypeGraphElement())); this.SetForeColor(CLR_DEF_FORE_COLOR,true); this.SetOpacity(CLR_DEF_CONTROL_TAB_HEAD_OPACITY,true); this.SetBackgroundColor(CLR_DEF_CONTROL_TAB_HEAD_BACK_COLOR,true); this.SetBackgroundColorMouseDown(CLR_DEF_CONTROL_TAB_HEAD_MOUSE_DOWN); this.SetBackgroundColorMouseOver(CLR_DEF_CONTROL_TAB_HEAD_MOUSE_OVER); this.SetBackgroundStateOnColor(CLR_DEF_CONTROL_TAB_HEAD_BACK_COLOR_ON,true); this.SetBackgroundStateOnColorMouseDown(CLR_DEF_CONTROL_TAB_HEAD_BACK_DOWN_ON); this.SetBackgroundStateOnColorMouseOver(CLR_DEF_CONTROL_TAB_HEAD_BACK_OVER_ON); this.SetBorderStyle(FRAME_STYLE_SIMPLE); this.SetBorderColor(CLR_DEF_CONTROL_TAB_HEAD_BORDER_COLOR,true); this.SetBorderColorMouseDown(CLR_DEF_CONTROL_TAB_HEAD_BORDER_MOUSE_DOWN); this.SetBorderColorMouseOver(CLR_DEF_CONTROL_TAB_HEAD_BORDER_MOUSE_OVER); this.SetPadding(6,3,6,3); this.SetSizes(w,h); this.SetState(false); this.m_arr_butt_ud_visible_flag=false; this.m_arr_butt_lr_visible_flag=false; this.m_arr_butt_ud_size=0; this.m_arr_butt_lr_size=0; } //+------------------------------------------------------------------+
En el manejador de eventos "Cursor dentro del área activa, botón (izquierdo) del ratón pulsado", escribiremos un bloque de código para crear y enviar un evento de selección de pestaña TabControl al clicar en el encabezado:
//+------------------------------------------------------------------+ //| 'The cursor is inside the active area, | //| left mouse button released | //+------------------------------------------------------------------+ void CTabHeader::MouseActiveAreaReleasedHandler(const int id,const long& lparam,const double& dparam,const string& sparam) { //--- The mouse button released outside the element means refusal to interact with the element if(lparam<this.CoordX() || lparam>this.RightEdge() || dparam<this.CoordY() || dparam>this.BottomEdge()) { //--- If this is a simple button, set the initial background and text color if(!this.Toggle()) { this.SetBackgroundColor(this.BackgroundColorInit(),false); this.SetForeColor(this.ForeColorInit(),false); } //--- If this is the toggle button, set the initial background and text color depending on whether the button is pressed or not else { this.SetBackgroundColor(!this.State() ? this.BackgroundColorInit() : this.BackgroundStateOnColorInit(),false); this.SetForeColor(!this.State() ? this.ForeColorInit() : this.ForeStateOnColorInit(),false); } //--- Set the initial frame color this.SetBorderColor(this.BorderColorInit(),false); //--- Send the test message to the journal Print(DFUN_ERR_LINE,TextByLanguage("Отмена","Cancel")); } //--- The mouse button released within the element means a click on the control else { //--- If this is a simple button, set the background and text color for "The cursor is over the active area" status if(!this.Toggle()) { this.SetBackgroundColor(this.BackgroundColorMouseOver(),false); this.SetForeColor(this.ForeColorMouseOver(),false); this.Redraw(true); } //--- If this is the toggle button, else { //--- if the button does not work in the group, set its state to the opposite, if(!this.GroupButtonFlag()) this.SetState(!this.State()); //--- if the button is not pressed yet, set it to the pressed state else if(!this.State()) this.SetState(true); //--- set the background and text color for "The cursor is over the active area" status depending on whether the button is clicked or not this.SetBackgroundColor(this.State() ? this.BackgroundStateOnColorMouseOver() : this.BackgroundColorMouseOver(),false); this.SetForeColor(this.State() ? this.ForeStateOnColorMouseOver() : this.ForeColorMouseOver(),false); //--- Get the field object corresponding to the header CWinFormBase *field=this.GetFieldObj(); if(field!=NULL) { //--- Display the field, bring it to the front, draw a frame and crop the excess field.Show(); field.BringToTop(); field.DrawFrame(); field.Crop(); } //--- Redraw an object and a chart this.Redraw(true); } //--- Send the test message to the journal Print(DFUN_ERR_LINE,TextByLanguage("Щелчок","Click"),", this.State()=",this.State(),", ID=",this.ID(),", Group=",this.Group()); //--- Create the event: //--- Get the base and main objects CWinFormBase *base=this.GetBase(); CWinFormBase *main=this.GetMain(); //--- in the 'long' event parameter, pass a string, while in the 'double' parameter, the tab header location column long lp=this.Row(); double dp=this.Column(); //--- in the 'string' parameter of the event, pass the names of the main and base objects separated by ";" string name_main=(main!=NULL ? main.Name() : ""); string name_base=(base!=NULL ? base.Name() : ""); string sp=name_main+";"+name_base; //--- Send the tab selection event to the chart of the control program ::EventChartCustom(::ChartID(),WF_CONTROL_EVENT_TAB_SELECT,lp,dp,sp); //--- Set the frame color for "The cursor is over the active area" status this.SetBorderColor(this.BorderColorMouseOver(),false); } } //+------------------------------------------------------------------+
Aquí creamos un evento que se enviará al manejador de eventos de la biblioteca y en este mensaje especificaremos el número de fila del encabezado en el parámetro long del mensaje (para una sola fila siempre será cero), el número de columna del encabezado en la fila, en el parámetro double que indicará exactamente sobre qué encabezado se ha clicado (el número de pestaña seleccionada). Para identificar de forma unívoca el TabControl en el que se ha seleccionado la pestaña, necesitaremos enviar en el evento el nombre del objeto principal en el que se ha producido el evento y el nombre del objeto TabControl en el que se ha seleccionado la pestaña. Como solo tenemos un parámetro string, simplemente añadiremos los nombres del objeto principal y del objeto TabControl separados por ";". En el manejador de eventos, podremos entonces utilizar el separador para cortar la cadena y recuperar los dos nombres de estos objetos.
Ahora vamos a mejorar la clase WinForms del objeto TabControl en el archivo \MQL5\Include\DoEasy\Objects\Graph\WForms\Containers\TabControl.mqh.
Así, ajustaremos las rutas de los archivos de los objetos auxiliares, declararemos las nuevas variables y métodos, y luego escribiremos los métodos que retornan los punteros a los objetos de botón con flechas:
//+------------------------------------------------------------------+ //| TabControl.mqh | //| Copyright 2022, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2022, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "Container.mqh" #include "GroupBox.mqh" #include "..\Helpers\TabHeader.mqh" #include "..\Helpers\TabField.mqh" //+------------------------------------------------------------------+ //| TabHeader object class of WForms TabControl | //+------------------------------------------------------------------+ class CTabControl : public CContainer { private: int m_item_width; // Fixed width of tab titles int m_item_height; // Fixed height of tab titles int m_header_padding_x; // Additional header width if DrawMode==Fixed int m_header_padding_y; // Additional header height if DrawMode==Fixed int m_field_padding_top; // Padding of top tab fields int m_field_padding_bottom; // Padding of bottom tab fields int m_field_padding_left; // Padding of left tab fields int m_field_padding_right; // Padding of right tab fields bool m_arr_butt_ud_visible_flag; // Tab header "up-down" control buttons visibility flag bool m_arr_butt_lr_visible_flag; // Tab header "left-right" control buttons visibility flag //--- (1) Hide and (2) display right-left and up-down button controls void ShowArrLeftRightBox(void); void ShowArrUpDownBox(void); void HideArrLeftRightBox(void); void HideArrUpDownBox(void); //--- Move right-left and up-down button controls to the foreground void BringToTopArrLeftRightBox(void); void BringToTopArrUpDownBox(void); //--- Create a new graphical object virtual CGCnvElement *CreateNewGObject(const ENUM_GRAPH_ELEMENT_TYPE type, const int element_num, const string descript, const int x, const int y, const int w, const int h, const color colour, const uchar opacity, const bool movable, const bool activity); //--- Return the list of (1) headers, (2) tab fields, the pointer to the (3) up-down and (4) left-right button objects CArrayObj *GetListHeaders(void) { return this.GetListElementsByType(GRAPH_ELEMENT_TYPE_WF_TAB_HEADER); } CArrayObj *GetListFields(void) { return this.GetListElementsByType(GRAPH_ELEMENT_TYPE_WF_TAB_FIELD); } CArrowUpDownBox *GetArrUpDownBox(void) { return this.GetElementByType(GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX,0); } CArrowLeftRightBox *GetArrLeftRightBox(void) { return this.GetElementByType(GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX,0); } //--- Set the tab as selected
En la sección pública de la clase, escribiremos los métodos para gestionar las nuevas variables y los objetos de botón con flechas, y también declararemos un método para desplazar la barra de encabezados y el manejador de eventos:
//--- Return a pointer to the (1) tab header, (2) field, (3) the number of tabs, visibility of (4) left-right and (5) up-down buttons CTabHeader *GetTabHeader(const int index) { return this.GetElementByType(GRAPH_ELEMENT_TYPE_WF_TAB_HEADER,index); } CWinFormBase *GetTabField(const int index) { return this.GetElementByType(GRAPH_ELEMENT_TYPE_WF_TAB_FIELD,index); } int TabPages(void) { return(this.GetListHeaders()!=NULL ? this.GetListHeaders().Total() : 0); } bool IsVisibleLeftRightBox(void) { return this.m_arr_butt_lr_visible_flag; } bool IsVisibleUpDownBox(void) { return this.m_arr_butt_ud_visible_flag; } //--- Set the visibility of the (1) left-right, (2) up-down buttons void SetVisibleLeftRightBox(const bool flag); void SetVisibleUpDownBox(const bool flag); //--- Set the size of the (1) left-right, (2) up-down buttons void SetSizeLeftRightBox(const int value); void SetSizeUpDownBox(const int value); //--- (1) Set and (2) return the location of tabs on the control
...
//--- Set the object above all virtual void BringToTop(void); //--- Show the control virtual void Show(void); //--- Shift the header row void ShiftHeadersRow(const int selected); //--- Event handler virtual void OnChartEvent(const int id,const long& lparam,const double& dparam,const string& sparam); //--- Constructor CTabControl(const long chart_id, const int subwindow, const string descript, const int x, const int y, const int w, const int h); }; //+------------------------------------------------------------------+
En el constructor de la clase, estableceremos los valores de visibilidad por defecto para los objetos de flecha:
//+------------------------------------------------------------------+ //| Constructor indicating the chart and subwindow ID | //+------------------------------------------------------------------+ CTabControl::CTabControl(const long chart_id, const int subwindow, const string descript, const int x, const int y, const int w, const int h) : CContainer(GRAPH_ELEMENT_TYPE_WF_TAB_CONTROL,chart_id,subwindow,descript,x,y,w,h) { this.SetTypeElement(GRAPH_ELEMENT_TYPE_WF_TAB_CONTROL); this.m_type=OBJECT_DE_TYPE_GWF_CONTAINER; this.SetBorderSizeAll(0); this.SetBorderStyle(FRAME_STYLE_NONE); this.SetOpacity(0,true); this.SetBackgroundColor(CLR_CANV_NULL,true); this.SetBackgroundColorMouseDown(CLR_CANV_NULL); this.SetBackgroundColorMouseOver(CLR_CANV_NULL); this.SetBorderColor(CLR_CANV_NULL,true); this.SetBorderColorMouseDown(CLR_CANV_NULL); this.SetBorderColorMouseOver(CLR_CANV_NULL); this.SetForeColor(CLR_DEF_FORE_COLOR,true); this.SetAlignment(CANV_ELEMENT_ALIGNMENT_TOP); this.SetItemSize(58,18); this.SetTabSizeMode(CANV_ELEMENT_TAB_SIZE_MODE_NORMAL); this.SetPaddingAll(0); this.SetHeaderPadding(6,3); this.SetFieldPadding(3,3,3,3); this.m_arr_butt_ud_visible_flag=false; this.m_arr_butt_lr_visible_flag=false; } //+------------------------------------------------------------------+
Por defecto, estos dos objetos deberán estar ocultos, y solo se mostrarán si la fila de encabezados horizontal o vertical se extiende más allá del contenedor. Utilizaremos estas mismas banderas para determinar en los objetos de encabezado de las pestañas si se deben añadir valores adicionales a la zona de visibilidad. Si no hay un objeto de flecha, el encabezado se recortará hasta el borde del contenedor, y si lo hay, hasta el borde de este objeto, para que el objeto de botón con flechas no se superponga al encabezado recortado sobre el borde del contenedor.
En el método que crea el número especificado de pestañas, ajustaremos la coordenada Y del desplazamiento del encabezado y la altura de los campos de pestañas al colocarlos en la parte inferior del contenedor, y añadiremos un bloque de código para crear dos objetos de botón izquierda-derecha y arriba-abajo:
//+------------------------------------------------------------------+ //| Create the specified number of tabs | //+------------------------------------------------------------------+ bool CTabControl::CreateTabPages(const int total,const int selected_page,const int tab_w=0,const int tab_h=0,const string header_text="") { //--- Calculate the size and initial coordinates of the tab title int w=(tab_w==0 ? this.ItemWidth() : tab_w); int h=(tab_h==0 ? this.ItemHeight() : tab_h); //--- In the loop by the number of tabs CTabHeader *header=NULL; CTabField *field=NULL; for(int i=0;i<total;i++) { //--- Depending on the location of tab titles, set their initial coordinates int header_x=2; int header_y=2; int header_w=w; int header_h=h; //--- Set the current X and Y coordinate depending on the location of the tab headers switch(this.Alignment()) { case CANV_ELEMENT_ALIGNMENT_TOP : header_w=w; header_h=h; header_x=(header==NULL ? 2 : header.RightEdgeRelative()); header_y=2; break; case CANV_ELEMENT_ALIGNMENT_BOTTOM : header_w=w; header_h=h; header_x=(header==NULL ? 2 : header.RightEdgeRelative()); header_y=this.Height()-header_h-2; break; case CANV_ELEMENT_ALIGNMENT_LEFT : header_w=h; header_h=w; header_x=2; header_y=(header==NULL ? this.Height()-header_h-2 : header.CoordYRelative()-header_h); break; case CANV_ELEMENT_ALIGNMENT_RIGHT : header_w=h; header_h=w; header_x=this.Width()-header_w-2; header_y=(header==NULL ? 2 : header.BottomEdgeRelative()); break; default: break; } //--- Create the TabHeader object if(!this.CreateNewElement(GRAPH_ELEMENT_TYPE_WF_TAB_HEADER,header_x,header_y,header_w,header_h,clrNONE,255,this.Active(),false)) { ::Print(DFUN,CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ),this.TypeElementDescription(GRAPH_ELEMENT_TYPE_WF_TAB_HEADER),string(i+1)); return false; } header=this.GetElementByType(GRAPH_ELEMENT_TYPE_WF_TAB_HEADER,i); if(header==NULL) { ::Print(DFUN,CMessage::Text(MSG_ELM_LIST_ERR_FAILED_GET_GRAPH_ELEMENT_OBJ),this.TypeElementDescription(GRAPH_ELEMENT_TYPE_WF_TAB_HEADER),string(i+1)); return false; } header.SetBase(this.GetObject()); header.SetPageNumber(i); header.SetGroup(this.Group()+1); header.SetBackgroundColor(CLR_DEF_CONTROL_TAB_HEAD_BACK_COLOR,true); header.SetBackgroundColorMouseDown(CLR_DEF_CONTROL_TAB_HEAD_MOUSE_DOWN); header.SetBackgroundColorMouseOver(CLR_DEF_CONTROL_TAB_HEAD_MOUSE_OVER); header.SetBackgroundStateOnColor(CLR_DEF_CONTROL_TAB_HEAD_BACK_COLOR_ON,true); header.SetBackgroundStateOnColorMouseDown(CLR_DEF_CONTROL_TAB_HEAD_BACK_DOWN_ON); header.SetBackgroundStateOnColorMouseOver(CLR_DEF_CONTROL_TAB_HEAD_BACK_OVER_ON); header.SetBorderStyle(FRAME_STYLE_SIMPLE); header.SetBorderColor(CLR_DEF_CONTROL_TAB_HEAD_BORDER_COLOR,true); header.SetBorderColorMouseDown(CLR_DEF_CONTROL_TAB_HEAD_BORDER_MOUSE_DOWN); header.SetBorderColorMouseOver(CLR_DEF_CONTROL_TAB_HEAD_BORDER_MOUSE_OVER); header.SetAlignment(this.Alignment()); header.SetPadding(this.HeaderPaddingWidth(),this.HeaderPaddingHeight(),this.HeaderPaddingWidth(),this.HeaderPaddingHeight()); if(header_text!="" && header_text!=NULL) this.SetHeaderText(header,header_text+string(i+1)); else this.SetHeaderText(header,"TabPage"+string(i+1)); if(this.Alignment()==CANV_ELEMENT_ALIGNMENT_LEFT) header.SetFontAngle(90); if(this.Alignment()==CANV_ELEMENT_ALIGNMENT_RIGHT) header.SetFontAngle(270); header.SetTabSizeMode(this.TabSizeMode()); //--- Save the initial height of the header and set its size in accordance with the header size setting mode int h_prev=header_h; header.SetSizes(header_w,header_h); //--- Get the Y offset of the header position after changing its height and //--- shift it by the calculated value only for headers on the left int y_shift=header.Height()-h_prev; if(header.Move(header.CoordX(),header.CoordY()-(this.Alignment()==CANV_ELEMENT_ALIGNMENT_LEFT ? y_shift : 0))) { header.SetCoordXRelative(header.CoordX()-this.CoordX()); header.SetCoordYRelative(header.CoordY()-this.CoordY()); } header.SetVisibleFlag(this.IsVisible(),false); //--- Depending on the location of the tab headers, set the initial coordinates of the tab fields int field_x=0; int field_y=0; int field_w=this.Width(); int field_h=this.Height()-header.Height()-2; int header_shift=0; switch(this.Alignment()) { case CANV_ELEMENT_ALIGNMENT_TOP : field_x=0; field_y=header.BottomEdgeRelative(); field_w=this.Width(); field_h=this.Height()-header.Height()-2; break; case CANV_ELEMENT_ALIGNMENT_BOTTOM : field_x=0; field_y=0; field_w=this.Width(); field_h=this.Height()-header.Height()-2; break; case CANV_ELEMENT_ALIGNMENT_LEFT : field_x=header.RightEdgeRelative(); field_y=0; field_h=this.Height(); field_w=this.Width()-header.Width()-2; break; case CANV_ELEMENT_ALIGNMENT_RIGHT : field_x=0; field_y=0; field_h=this.Height(); field_w=this.Width()-header.Width()-2; break; default: break; } //--- Create the TabField object (tab field) if(!this.CreateNewElement(GRAPH_ELEMENT_TYPE_WF_TAB_FIELD,field_x,field_y,field_w,field_h,clrNONE,255,true,false)) { ::Print(DFUN,CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ),this.TypeElementDescription(GRAPH_ELEMENT_TYPE_WF_TAB_FIELD),string(i+1)); return false; } field=this.GetElementByType(GRAPH_ELEMENT_TYPE_WF_TAB_FIELD,i); if(field==NULL) { ::Print(DFUN,CMessage::Text(MSG_ELM_LIST_ERR_FAILED_GET_GRAPH_ELEMENT_OBJ),this.TypeElementDescription(GRAPH_ELEMENT_TYPE_WF_TAB_FIELD),string(i+1)); return false; } field.SetBase(this.GetObject()); field.SetPageNumber(i); field.SetGroup(this.Group()+1); field.SetBorderSizeAll(1); field.SetBorderStyle(FRAME_STYLE_SIMPLE); field.SetOpacity(CLR_DEF_CONTROL_TAB_PAGE_OPACITY,true); field.SetBackgroundColor(CLR_DEF_CONTROL_TAB_PAGE_BACK_COLOR,true); field.SetBackgroundColorMouseDown(CLR_DEF_CONTROL_TAB_PAGE_MOUSE_DOWN); field.SetBackgroundColorMouseOver(CLR_DEF_CONTROL_TAB_PAGE_MOUSE_OVER); field.SetBorderColor(CLR_DEF_CONTROL_TAB_PAGE_BORDER_COLOR,true); field.SetBorderColorMouseDown(CLR_DEF_CONTROL_TAB_PAGE_BORDER_MOUSE_DOWN); field.SetBorderColorMouseOver(CLR_DEF_CONTROL_TAB_PAGE_BORDER_MOUSE_OVER); field.SetForeColor(CLR_DEF_FORE_COLOR,true); field.SetPadding(this.FieldPaddingLeft(),this.FieldPaddingTop(),this.FieldPaddingRight(),this.FieldPaddingBottom()); field.Hide(); } //--- Create left-right and up-down buttons this.CreateNewElement(GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX,this.Width()-32,0,15,15,clrNONE,255,this.Active(),false); this.CreateNewElement(GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX,0,this.Height()-32,15,15,clrNONE,255,this.Active(),false); CArrowUpDownBox *box_ud=this.GetArrUpDownBox(); if(box_ud!=NULL) { this.SetVisibleUpDownBox(false); this.SetSizeUpDownBox(box_ud.Height()); box_ud.SetBorderStyle(FRAME_STYLE_NONE); box_ud.SetBackgroundColor(CLR_CANV_NULL,true); box_ud.SetOpacity(0); box_ud.Hide(); } CArrowLeftRightBox *box_lr=this.GetArrLeftRightBox(); if(box_lr!=NULL) { this.SetVisibleLeftRightBox(false); this.SetSizeLeftRightBox(box_lr.Width()); box_lr.SetBorderStyle(FRAME_STYLE_NONE); box_lr.SetBackgroundColor(CLR_CANV_NULL,true); box_lr.SetOpacity(0); box_lr.Hide(); } //--- Arrange all titles in accordance with the specified display modes and select the specified tab this.ArrangeTabHeaders(); this.Select(selected_page,true); return true; } //+------------------------------------------------------------------+
La coordenada Y de los encabezados deberá estar dos píxeles más por encima del borde inferior del contenedor cuando los encabezados se coloquen en la parte inferior, porque el encabezado de la pestaña seleccionada aumentará de tamaño en dos píxeles y, si se coloca en el borde inferior del contenedor, al darse su selección (y, por lo tanto, al aumentar de altura en dos píxeles), su borde inferior se extenderá más allá del contenedor y se cortará allí.
Para evitar el recorte, el objeto deberá colocarse dos píxeles más arriba, lo cual permitirá su posible ampliación al ser seleccionado. Así, el campo de la pestaña deberá ser dos píxeles más pequeño, ya que estos dos píxeles serán ahora "comidos" por el desplazamiento hacia arriba de la ubicación del encabezado.
Después de crear los dos objetos de flecha, los podremos en el estado "oculto" (estos estados se transmitirán a los objetos de encabezado de la pestaña) y estableceremos las dimensiones de los objetos creados en todos los objetos del encabezado de la pestaña. Haremos todo esto utilizando los dos métodos que veremos en la siguiente sección. Para los objetos, el tipo de marco se establecerá como "ninguno", el color de fondo se establecerá como transparente y la opacidad se establecerá como completa. Al final, el objeto se ocultará.
Así que ambos objetos se crearán como dos botones sobre un fondo transparente, para que coincidan con la apariencia de los objetos correspondientes en el control de MS Visual Studio.
En todos los métodos que colocan encabezados de pestaña en la parte superior, inferior, izquierda y derecha, añadiremos el ajuste del número de fila y columna para el encabezado y un bloque de código para gestionar la situación cuando tenemos activado el modo de encabezado de pestaña de una sola línea y cuando el encabezado de pestaña se extiende más allá del contenedor:
//+------------------------------------------------------------------+ //| Arrange tab headers on top | //+------------------------------------------------------------------+ void CTabControl::ArrangeTabHeadersTop(void) { //--- Get the list of tab headers CArrayObj *list=this.GetListHeaders(); if(list==NULL) return; //--- Declare the variables int col=0; // Column int row=0; // Row int x1_base=2; // Initial X coordinate int x2_base=this.Width()-2; // Final X coordinate int x_shift=0; // Shift the tab set for calculating their exit beyond the container int n=0; // The variable for calculating the column index relative to the loop index //--- In a loop by the list of headers, for(int i=0;i<list.Total();i++) { //--- get the next tab header object CTabHeader *header=list.At(i); if(header==NULL) continue; //--- If the flag for positioning headers in several rows is set if(this.Multiline()) { //--- Calculate the value of the right edge of the header, taking into account that //--- the origin always comes from the left edge of TabControl + 2 pixels int x2=header.RightEdgeRelative()-x_shift; //--- If the calculated value does not go beyond the right edge of the TabControl minus 2 pixels, //--- set the column number equal to the loop index minus the value in the n variable if(x2<x2_base) col=i-n; //--- If the calculated value goes beyond the right edge of the TabControl minus 2 pixels, else { //--- Increase the row index, calculate the new shift (so that the next object is compared with the TabControl left edge + 2 pixels), //--- set the loop index for the n variable, while the column index is set to zero, this is the start of the new row row++; x_shift=header.CoordXRelative()-2; n=i; col=0; } //--- Assign the row and column indices to the tab header and shift it to the calculated coordinates header.SetTabLocation(row,col); if(header.Move(header.CoordX()-x_shift,header.CoordY()-header.Row()*header.Height())) { header.SetCoordXRelative(header.CoordX()-this.CoordX()); header.SetCoordYRelative(header.CoordY()-this.CoordY()); } } //--- If only one row of headers is allowed else { header.SetRow(0); header.SetColumn(i); } } //--- The location of all tab titles is set. Now place them all together with the fields //--- according to the header row and column indices. //--- Get the last title in the list CTabHeader *last=this.GetTabHeader(list.Total()-1); //--- If the object is received if(last!=NULL) { //--- If the mode of stretching headers to the width of the container is set, call the stretching method if(this.TabSizeMode()==CANV_ELEMENT_TAB_SIZE_MODE_FILL) this.StretchHeaders(); //--- If this is not the first row (with index 0) if(last.Row()>0) { //--- Calculate the offset of the tab field Y coordinate int y_shift=last.Row()*last.Height(); //--- In a loop by the list of headers, for(int i=0;i<list.Total();i++) { //--- get the next object CTabHeader *header=list.At(i); if(header==NULL) continue; //--- get the tab field corresponding to the received header CTabField *field=header.GetFieldObj(); if(field==NULL) continue; //--- shift the tab header by the calculated row coordinates if(header.Move(header.CoordX(),header.CoordY()+y_shift)) { header.SetCoordXRelative(header.CoordX()-this.CoordX()); header.SetCoordYRelative(header.CoordY()-this.CoordY()); } //--- shift the tab field by the calculated shift if(field.Move(field.CoordX(),field.CoordY()+y_shift)) { field.SetCoordXRelative(field.CoordX()-this.CoordX()); field.SetCoordYRelative(field.CoordY()-this.CoordY()); //--- change the size of the shifted field by the value of its shift field.Resize(field.Width(),field.Height()-y_shift,false); } } } //--- If this is the first and only string else if(!this.Multiline()) { //--- If the right edge of the header goes beyond the right edge of the container area, if(last.RightEdge()>this.RightEdgeWorkspace()) { //--- get the button object with left-right arrows CArrowLeftRightBox *arr_box=this.GetArrLeftRightBox(); if(arr_box!=NULL) { //--- Calculate object location coordinates int x=this.RightEdgeWorkspace()-arr_box.Width()+1; int y=last.BottomEdge()-arr_box.Height(); //--- If the object is shifted by the specified coordinates, if(arr_box.Move(x,y)) { //--- set its relative coordinates arr_box.SetCoordXRelative(arr_box.CoordX()-this.CoordX()); arr_box.SetCoordYRelative(arr_box.CoordY()-this.CoordY()); //--- set the visibility flag for the object this.SetVisibleLeftRightBox(true); //--- If the control is visible, display the buttons and bring them to the foreground if(this.IsVisible()) { arr_box.Show(); arr_box.BringToTop(); } } } } } } } //+------------------------------------------------------------------+
Aquí mostramos el método completo, colocando los encabezados de las pestañas en la parte superior. Los otros tres métodos hacen exactamente el mismo trabajo en cuanto al establecimiento del número de fila (cero) y el número de columna (índice de ciclo) para el encabezado de la pestaña, mientras que los bloques de código que definen el encabezado que queda fuera del contenedor y muestra sus botones de control de scrolling para la fila difieren ligeramente: solo se calculan las coordenadas de ubicación del encabezado en relación con el contenedor y se muestran los botones de control de scrolling en las coordenadas correspondientes.
Vamos a analizar estos bloques de código para diferentes métodos.
Para el método que coloca los encabezados de las pestañas en la parte inferior(ArrangeTabHeadersBottom()):
//--- If this is the first and only string else if(!this.Multiline()) { if(last.RightEdge()>this.RightEdgeWorkspace()) { CArrowLeftRightBox *arr_box=this.GetArrLeftRightBox(); if(arr_box!=NULL) { int x=this.RightEdgeWorkspace()-arr_box.Width()+1; int y=last.CoordY(); if(arr_box.Move(x,y)) { arr_box.SetCoordXRelative(arr_box.CoordX()-this.CoordX()); arr_box.SetCoordYRelative(arr_box.CoordY()-this.CoordY()); this.SetVisibleLeftRightBox(true); if(this.IsVisible()) { arr_box.Show(); arr_box.BringToTop(); } } } } }
Para el método que coloca los encabezados de las pestañas a la izquierda(ArrangeTabHeadersLeft()):
//--- If this is the first and only string else if(!this.Multiline()) { if(last.CoordY()<this.CoordY()) { CArrowUpDownBox *arr_box=this.GetArrUpDownBox(); if(arr_box!=NULL) { int x=last.RightEdge()-arr_box.Width(); int y=this.CoordY()-1; if(arr_box.Move(x,y)) { arr_box.SetCoordXRelative(arr_box.CoordX()-this.CoordX()); arr_box.SetCoordYRelative(arr_box.CoordY()-this.CoordY()); this.SetVisibleUpDownBox(true); if(this.IsVisible()) { arr_box.Show(); arr_box.BringToTop(); } } } } }
Para el método que coloca los encabezados de las pestañas a la derecha(ArrangeTabHeadersRight()):
//--- If this is the first and only string else if(!this.Multiline()) { if(last.BottomEdge()>this.BottomEdge()) { CArrowUpDownBox *arr_box=this.GetArrUpDownBox(); if(arr_box!=NULL) { int x=last.CoordX(); int y=this.BottomEdgeWorkspace()-arr_box.Height()+1; if(arr_box.Move(x,y)) { arr_box.SetCoordXRelative(arr_box.CoordX()-this.CoordX()); arr_box.SetCoordYRelative(arr_box.CoordY()-this.CoordY()); this.SetVisibleUpDownBox(true); if(this.IsVisible()) { arr_box.Show(); arr_box.BringToTop(); } } } } }
Al comparar los cuatro bloques de código en los cuatro métodos, podemos ver cómo se calculan las coordenadas de las ubicaciones de los botones de control del scrolling y se definen los encabezados fuera del contenedor.
El método que crea el nuevo objeto gráfico también ha sufrido cambios en el formato de los casos del operador switch:
//+------------------------------------------------------------------+ //| Create a new graphical object | //+------------------------------------------------------------------+ CGCnvElement *CTabControl::CreateNewGObject(const ENUM_GRAPH_ELEMENT_TYPE type, const int obj_num, const string descript, const int x, const int y, const int w, const int h, const color colour, const uchar opacity, const bool movable, const bool activity) { CGCnvElement *element=NULL; switch(type) { case GRAPH_ELEMENT_TYPE_ELEMENT : element=new CGCnvElement(type,this.ID(),obj_num,this.ChartID(),this.SubWindow(),descript,x,y,w,h,colour,opacity,movable,activity); break; case GRAPH_ELEMENT_TYPE_FORM : element=new CForm(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CONTAINER : element=new CContainer(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_GROUPBOX : element=new CGroupBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_PANEL : element=new CPanel(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LABEL : element=new CLabel(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CHECKBOX : element=new CCheckBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_RADIOBUTTON : element=new CRadioButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_BUTTON : element=new CButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LIST_BOX : element=new CListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_LIST_BOX_ITEM : element=new CListBoxItem(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_CHECKED_LIST_BOX : element=new CCheckedListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_BUTTON_LIST_BOX : element=new CButtonListBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_HEADER : element=new CTabHeader(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_FIELD : element=new CTabField(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_TAB_CONTROL : element=new CTabControl(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON : element=new CArrowButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_UP : element=new CArrowUpButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_DOWN : element=new CArrowDownButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_LEFT : element=new CArrowLeftButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTON_RIGHT : element=new CArrowRightButton(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX : element=new CArrowUpDownBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; case GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX : element=new CArrowLeftRightBox(this.ChartID(),this.SubWindow(),descript,x,y,w,h); break; default : break; } if(element==NULL) ::Print(DFUN,CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ),this.TypeElementDescription(type)); return element; } //+------------------------------------------------------------------+
Ahora todo se encuentra en una línea, para lograr una representación más compacta de la lógica del método.
En el método virtual que coloca un objeto por encima de todo, sustituimos la llamada al método BringToTop() del objeto de formulario
//+------------------------------------------------------------------+ //| Set the object above all the rest | //+------------------------------------------------------------------+ void CTabControl::BringToTop(void) { //--- Move all elements of the object to the foreground CForm::BringToTop(); //--- Get the index of the selected tab
para llamar al método Show() del objeto de elemento gráfico y, si el propio objeto resulta visible, mostraremos los controles de scrolling de las filas de encabezados en caso de que estos objetos deban ser visibles:
//+------------------------------------------------------------------+ //| Set the object above all the rest | //+------------------------------------------------------------------+ void CTabControl::BringToTop(void) { //--- Move all elements of the object to the foreground CGCnvElement::Show(); //--- Get the index of the selected tab int selected=this.SelectedTabPageNum(); //--- Declare the pointers to tab header objects and tab fields CTabHeader *header=NULL; CTabField *field=NULL; //--- Get the list of all tab headers CArrayObj *list=this.GetListHeaders(); if(list==NULL) return; //--- In a loop by the list of tab headers, for(int i=0;i<list.Total();i++) { //--- get the next header, and if failed to get the object, //--- or this is the header of the selected tab, skip it header=list.At(i); if(header==NULL || header.PageNumber()==selected) continue; //--- bring the header to the foreground header.BringToTop(); //--- get the tab field corresponding to the current header field=header.GetFieldObj(); if(field==NULL) continue; //--- Hide the tab field field.Hide(); } //--- Get the pointer to the title of the selected tab header=this.GetTabHeader(selected); if(header!=NULL) { //--- bring the header to the front header.BringToTop(); //--- get the tab field corresponding to the selected tab header field=header.GetFieldObj(); //--- Display the tab field on the foreground if(field!=NULL) field.BringToTop(); } //--- If the object is visible and the "up-down" and "left-right" buttons should be visible, move them to the foreground if(this.IsVisible()) { if(this.m_arr_butt_ud_visible_flag) this.BringToTopArrUpDownBox(); if(this.m_arr_butt_lr_visible_flag) this.BringToTopArrLeftRightBox(); } } //+------------------------------------------------------------------+
Si antes llamábamos al método BringToTop de la clase padre CForm (este método traía absolutamente todos los objetos adjuntos al control al primer plano, haciéndolos visibles), ahora necesitaremos controlar la visibilidad de los objetos de botón del control de scrolling. Así que simplemente haremos visible el objeto en sí, y luego dentro del método comprobaremos si deben mostrarse los encabezados y los campos de pestañas y botones que controlan el scrolling de las filas de encabezados.
Método que muestra los controles "Botones arriba-abajo":
//+------------------------------------------------------------------+ //| Display Up-down button controls | //+------------------------------------------------------------------+ void CTabControl::ShowArrUpDownBox(void) { CArrowUpDownBox *box=this.GetArrUpDownBox(); if(box==NULL) { ::Print(DFUN,CMessage::Text(MSG_ELM_LIST_ERR_FAILED_GET_GRAPH_ELEMENT_OBJ)," ",this.TypeElementDescription(GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX)); return; } box.Show(); } //+------------------------------------------------------------------+
Obtenemos el puntero al control. Si el puntero falla, imprimiremos un mensaje de error y saldremos del método. Cuando obtenemos el puntero con éxito, mostramos el objeto.
Método que muestra el los controles "Botones derecha-izquierda":
//+------------------------------------------------------------------+ //| Display the Right-left button controls | //+------------------------------------------------------------------+ void CTabControl::ShowArrLeftRightBox(void) { CArrowLeftRightBox *box=this.GetArrLeftRightBox(); if(box==NULL) { ::Print(DFUN,CMessage::Text(MSG_ELM_LIST_ERR_FAILED_GET_GRAPH_ELEMENT_OBJ)," ",this.TypeElementDescription(GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX)); return; } box.Show(); } //+------------------------------------------------------------------+
La lógica del método es idéntica a la anterior.
Métodos para ocultar los controles "Botones arriba-abajo" y "Botones izquierda-derecha":
//+------------------------------------------------------------------+ //| Hide the Up-down button controls | //+------------------------------------------------------------------+ void CTabControl::HideArrUpDownBox(void) { CArrowUpDownBox *box=this.GetArrUpDownBox(); if(box==NULL) { ::Print(DFUN,CMessage::Text(MSG_ELM_LIST_ERR_FAILED_GET_GRAPH_ELEMENT_OBJ)," ",this.TypeElementDescription(GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX)); return; } box.Hide(); } //+------------------------------------------------------------------+ //| Hide the Right-left button controls | //+------------------------------------------------------------------+ void CTabControl::HideArrLeftRightBox(void) { CArrowLeftRightBox *box=this.GetArrLeftRightBox(); if(box==NULL) { ::Print(DFUN,CMessage::Text(MSG_ELM_LIST_ERR_FAILED_GET_GRAPH_ELEMENT_OBJ)," ",this.TypeElementDescription(GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX)); return; } box.Hide(); } //+------------------------------------------------------------------+
La lógica de los métodos resulta idéntica a la de los dos métodos anteriores para asignar controles, pero aquí, en lugar de mostrarse el elemento, se ocultará.
Métodos que llevan al primer plano los controles "Botones arriba-abajo" y "Botones derecha-izquierda":
//+------------------------------------------------------------------+ //| Move Up-down button controls to the foreground | //+------------------------------------------------------------------+ void CTabControl::BringToTopArrUpDownBox(void) { CArrowUpDownBox *box=this.GetArrUpDownBox(); if(box==NULL) { ::Print(DFUN,CMessage::Text(MSG_ELM_LIST_ERR_FAILED_GET_GRAPH_ELEMENT_OBJ)," ",this.TypeElementDescription(GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_UD_BOX)); return; } box.BringToTop(); } //+------------------------------------------------------------------+ //|Move right-left button controls to the foreground | //+------------------------------------------------------------------+ void CTabControl::BringToTopArrLeftRightBox(void) { CArrowLeftRightBox *box=this.GetArrLeftRightBox(); if(box==NULL) { ::Print(DFUN,CMessage::Text(MSG_ELM_LIST_ERR_FAILED_GET_GRAPH_ELEMENT_OBJ)," ",this.TypeElementDescription(GRAPH_ELEMENT_TYPE_WF_ARROW_BUTTONS_LR_BOX)); return; } box.BringToTop(); } //+------------------------------------------------------------------+
Es exactamente lo mismo, pero con el traslado al primer plano.
Método que establece la visibilidad de los botones izquierda-derecha:
//+------------------------------------------------------------------+ //| Set the visibility of the left-right buttons | //+------------------------------------------------------------------+ void CTabControl::SetVisibleLeftRightBox(const bool flag) { this.m_arr_butt_lr_visible_flag=flag; CArrayObj *list=this.GetListHeaders(); if(list==NULL) return; for(int i=0;i<list.Total();i++) { CTabHeader *obj=list.At(i); if(obj==NULL) continue; obj.SetVisibleLeftRightBox(flag); } } //+------------------------------------------------------------------+
En primer lugar, estableceremos la bandera de visibilidad del control, luego obtendremos una lista de encabezados de pestaña y crearemos un ciclo a través de la lista para cada uno de los objetos de encabezado para establecer el valor de bandera transmitido al método.
Método que establece la visibilidad de los botones arriba-abajo:
//+------------------------------------------------------------------+ //| Set the visibility of up-down buttons | //+------------------------------------------------------------------+ void CTabControl::SetVisibleUpDownBox(const bool flag) { this.m_arr_butt_ud_visible_flag=flag; CArrayObj *list=this.GetListHeaders(); if(list==NULL) return; for(int i=0;i<list.Total();i++) { CTabHeader *obj=list.At(i); if(obj==NULL) continue; obj.SetVisibleUpDownBox(flag); } } //+------------------------------------------------------------------+
La lógica del método es idéntica a la anterior. Sin embargo, aquí estableceremos las banderas para los objetos de los botones arriba-abajo.
Método que establece el tamaño de los botones izquierda-derecha:
//+------------------------------------------------------------------+ //| The method setting the size of left-right buttons | //+------------------------------------------------------------------+ void CTabControl::SetSizeLeftRightBox(const int value) { CArrowLeftRightBox *butt=this.GetArrLeftRightBox(); if(butt!=NULL) butt.Resize(value,butt.Height(),false); CArrayObj *list=this.GetListHeaders(); if(list==NULL) return; for(int i=0;i<list.Total();i++) { CTabHeader *obj=list.At(i); if(obj==NULL) continue; obj.SetSizeLeftRightBox(value); } } //+------------------------------------------------------------------+
Luego obtendremos el puntero al objeto de botón izquierda-derecha, estableceremos el valor trasmitido al método como la anchura del objeto (ya que aquí solo necesitamos cambiar la anchura del objeto), y después, en un ciclo por la lista de encabezados de pestañas, escribiremos en cada objeto subsiguiente el valor de la anchura establecida del objeto de botón de control del scrolling.
Método que establece el tamaño de los botones arriba-abajo:
//+------------------------------------------------------------------+ //| Set the up-down button size | //+------------------------------------------------------------------+ void CTabControl::SetSizeUpDownBox(const int value) { CArrowUpDownBox *butt=this.GetArrUpDownBox(); if(butt!=NULL) butt.Resize(butt.Width(),value,false); CArrayObj *list=this.GetListHeaders(); if(list==NULL) return; for(int i=0;i<list.Total();i++) { CTabHeader *obj=list.At(i); if(obj==NULL) continue; obj.SetSizeUpDownBox(value); } } //+------------------------------------------------------------------+
La lógica del método es idéntica a la anterior, pero aquí obtendremos el puntero al objeto de botón arriba-abajo, y estableceremos la altura de este objeto.
Método que desplaza la fila de encabezados:
//+------------------------------------------------------------------+ //| Shift the header row | //+------------------------------------------------------------------+ void CTabControl::ShiftHeadersRow(const int selected) { //--- If there are multiline headers, leave if(this.Multiline()) return; //--- Get the list of tab headers CArrayObj *list=this.GetListHeaders(); if(list==NULL) return; //--- Get the header of the selected tab CTabHeader *header=this.GetTabHeader(selected); if(header==NULL) return; //--- Check how much of the selected header is cropped on the right int hidden=header.RightEdge()-this.RightEdgeWorkspace(); //--- If the header is not cropped, exit if(hidden<0) return; CTabHeader *obj=NULL; int shift=0; //--- Look for the leftmost one starting from the selected header for(int i=selected-1;i>WRONG_VALUE;i--) { obj=list.At(i); if(obj==NULL) continue; //--- If the leftmost one is found, remember how much to shift all headers to the right if(obj.CoordX()-2==this.CoordX()) shift=obj.Width(); } //--- In a loop by the list of headers, for(int i=0;i<list.Total();i++) { //--- get the next header obj=list.At(i); if(obj==NULL) continue; //--- and, if the header is shifted to the left by 'shift', if(obj.Move(obj.CoordX()-shift,obj.CoordY())) { //--- save its new relative coordinates obj.SetCoordXRelative(obj.CoordX()-this.CoordX()); obj.SetCoordYRelative(obj.CoordY()-this.CoordY()); //--- If the title has gone beyond the left edge, if(obj.CoordX()-2<this.CoordX()) { //--- crop and hide it obj.Crop(); obj.Hide(); } //--- If the header fits the visible area of the control, else { //--- display and redraw it obj.Show(); obj.Redraw(false); //--- Get the tab field corresponding to the header CTabField *field=obj.GetFieldObj(); if(field==NULL) continue; //--- If this is a selected header, if(i==selected) { //--- Draw the field frame field.DrawFrame(); field.Update(); } } } } //--- Redraw the chart to display changes immediately ::ChartRedraw(this.ChartID()); } //+------------------------------------------------------------------+
La lógica del método se explica línea por línea en los comentarios al código. Resumiendo: transmitimos al método el índice del encabezado sobre la que se ha clicado (selección de pestañas del objeto TabControl). Si la pestaña seleccionada, su encabezado, se extiende fuera del contenedor, es decir, está recortada, deberemos desplazar todos los encabezados hacia la izquierda para que el encabezado seleccionado sea totalmente visible desplazando todos los encabezados hacia la izquierda. El primer encabezado visible a la izquierda se desplazará hacia la izquierda y el siguiente ocupará su lugar.
Así que primero tendremos que encontrar el primer encabezado visible a la izquierda y averiguar su anchura (la anchura de cada encabezado puede ser diferente, si las dimensiones son establecidas por el texto del encabezado). La anchura del primer encabezado encontrado será la magnitud en la que toda la fila de encabezados deberá desplazarse hacia la izquierda. Una vez desplazada la fila, para el encabezado seleccionado, buscaremos su campo y redibujaremos su marco, ya que el marco del campo se dibujará en relación con la ubicación del encabezado, y ahora está desplazado, y el marco no se dibujará correctamente.
Este método solo resultará adecuado para desplazar hacia la izquierda una fila de encabezados colocados horizontalmente. Basándonos en este método, en el próximo artículo crearemos métodos para desplazar la fila de encabezados en todas las direcciones: izquierda-derecha y arriba-abajo.
Manejador de eventos:
//+------------------------------------------------------------------+ //| Event handler | //+------------------------------------------------------------------+ void CTabControl::OnChartEvent(const int id,const long &lparam,const double &dparam,const string &sparam) { //--- Adjust subwindow Y shift CGCnvElement::OnChartEvent(id,lparam,dparam,sparam); if(id==WF_CONTROL_EVENT_TAB_SELECT) { this.ShiftHeadersRow((int)dparam); } } //+------------------------------------------------------------------+
Primero llamamos al método de corrección de las coordenadas Y de la subventana de la clase de elemento gráfico (esto se aplica a todos los elementos gráficos del lienzo, pero aquí redefiniremos el manejador de eventos de la clase padre, por lo que deberemos recordar crear la llamada al método de corrección de coordenadas), y luego llamaremos al método de desplazamiento de la fila del encabezados de la pestaña que comentamos anteriormente.
Vamos a mejorar la clase de colección de elementos gráficos en el archivo \MQL5\Include\DoEasy\Collections\GraphElementsCollection.mqh.
Luego añadiremos el método que retorna el elemento gráfico según su nombre:
//--- Return the list of graphical elements by chart ID and object name CArrayObj *GetListCanvElementByName(const long chart_id,const string name) { string nm=(::StringFind(name,this.m_name_prefix)<0 ? this.m_name_prefix : "")+name; CArrayObj *list=CSelect::ByGraphCanvElementProperty(this.GetListCanvElm(),CANV_ELEMENT_PROP_CHART_ID,chart_id,EQUAL); return CSelect::ByGraphCanvElementProperty(list,CANV_ELEMENT_PROP_NAME_OBJ,nm,EQUAL); } //--- Return the graphical element by name CGCnvElement *GetCanvElement(const string name) { string nm=(::StringFind(name,this.m_name_prefix)<0 ? this.m_name_prefix : "")+name; CArrayObj *list=CSelect::ByGraphCanvElementProperty(this.GetListCanvElm(),CANV_ELEMENT_PROP_NAME_OBJ,nm,EQUAL); return(list!=NULL ? list.At(0) : NULL); } //--- Return the graphical element by chart ID and name CGCnvElement *GetCanvElement(const long chart_id,const string name) { CArrayObj *list=this.GetListCanvElementByName(chart_id,name); return(list!=NULL ? list.At(0) : NULL); } //--- Return the graphical element by chart and object IDs
Como los nombres de todos los elementos gráficos del lienzo son ahora únicos, no deberemos especificar el identificador del gráfico sobre el que se construye el objeto al buscar un objeto según su nombre. Por ello, resulta aconsejable añadir un método que retorne un objeto solo según su nombre. Aquí comprobaremos qué nombre es transmitido al método y, si no hay ningún nombre de programa en la cadena del nombre, añadiremos el nombre del programa al principio del nombre, para que el nombre del objeto requerido coincida con el nombre real del elemento gráfico (porque todos tienen una subcadena con el nombre del programa), así es como la biblioteca creará los nombres de los objetos de elementos gráficos.
Ahora tendremos objetos WinForms que pueden enviar mensajes sobre sus eventos al gráfico del programa de control. Estos eventos serán capturados por la biblioteca y esta deberá ser capaz de procesarlos y redirigir el mensaje de evento correcto a la clase correcta. Por lo tanto, añadiremos al manejador de eventos de la clase de colección de elementos gráficos el procesamiento de los códigos de los eventos de los objetos WinForms:
//+------------------------------------------------------------------+ //| Event handler | //+------------------------------------------------------------------+ void CGraphElementsCollection::OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) { CGStdGraphObj *obj_std=NULL; // Pointer to the standard graphical object CGCnvElement *obj_cnv=NULL; // Pointer to the graphical element object on canvas ushort idx=ushort(id-CHARTEVENT_CUSTOM); //--- Processing WinForms control events if(idx>WF_CONTROL_EVENT_NO_EVENT && idx<WF_CONTROL_EVENTS_NEXT_CODE) { //--- Clicking the control if(idx==WF_CONTROL_EVENT_CLICK) { //--- } //--- Selecting the TabControl tab if(idx==WF_CONTROL_EVENT_TAB_SELECT) { string array[]; if(::StringSplit(sparam,::StringGetCharacter(";",0),array)!=2) { CMessage::ToLog(MSG_GRAPH_OBJ_FAILED_GET_OBJECT_NAMES); return; } CWinFormBase *main=this.GetCanvElement(array[0]); if(main==NULL) return; CWinFormBase *base=main.GetElementByName(array[1]); if(base!=NULL) base.OnChartEvent(idx,lparam,dparam,sparam); } } //--- Handle the events of renaming and clicking a standard graphical object if(id==CHARTEVENT_OBJECT_CHANGE || id==CHARTEVENT_OBJECT_DRAG || id==CHARTEVENT_OBJECT_CLICK || idx==CHARTEVENT_OBJECT_CHANGE || idx==CHARTEVENT_OBJECT_DRAG || idx==CHARTEVENT_OBJECT_CLICK) { //--- Calculate the chart ID //---... //---... } //---... //---... }
Hasta ahora solo se procesaba un código de evento: la selección de una pestaña en el control TabControl. Vamos a dividir el mensaje transmitido en el parámetro de cadena sparam en dos con la ayuda del separador ";" utilizando la función StringSplit(). Como resultado, obtendremos dos nombres en el array: el nombre del objeto principal (en este caso, el objeto de panel main), y el nombre del objeto WinForms TabControl base, que se adjuntará al panel. En los parámetros lparam y dparam, transmitiremos el número de fila y columna del encabezado de pestaña seleccionado. Con todos estos datos, ahora podremos identificar exactamente el panel al que está vinculado el TabControl, y la pestaña del control en cuyo título se ha clicado. Una vez hayamos obtenido los punteros a todos estos objetos, podremos llamar al manejador de eventos del objeto obtenido, que a su vez llamará al método de desplazamiento de la fila de encabezados de las pestañas.
Estos son todos los cambios y mejoras necesarios hasta ahora.
Simulación
Para la prueba, tomaremos el asesor del artículo anterior y lo guardaremos en la nueva carpeta \MQL5\Experts\TestDoEasy\Part118\ con el nuevo nombre TestDoEasy118.mq5.
¿Cómo realizaremos la prueba? Crearemos un panel principal y colocaremos el control TabControl con 11 pestañas en él. En cada una de las pestañas, crearemos una etiqueta de texto que describirá esa pestaña, para que podamos ver qué pestaña se muestra realmente durante la prueba.
Después de iniciar al asesor, estableceremos su configuración para estirar los encabezados de las pestañas a lo ancho del control para que podemos ver claramente qué pestaña no encaja y sobrepasa el borde del contenedor. Luego comprobaremos la disposición de las pestañas a cada lado del control, es decir, cómo se colocan los controles del scrolling de la fila de encabezados. Y con los encabezados en la parte superior, clicaremos en los encabezados de las pestañas recortadas a la derecha y veremos cómo toda la línea se desplaza hacia la izquierda, haciendo visible el encabezado seleccionado, copiando el comportamiento del control TabControl de MS Visual Studio.
Luego crearemos en el manejador OnInit() del asesor un panel, y en él un control TabControl con 11 pestañas con etiquetas de texto:
//+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- Set EA global variables ArrayResize(array_clr,2); // Array of gradient filling colors array_clr[0]=C'26,100,128'; // Original ≈Dark-azure color array_clr[1]=C'35,133,169'; // Lightened original color //--- Create the array with the current symbol and set it to be used in the library string array[1]={Symbol()}; engine.SetUsedSymbols(array); //--- Create the timeseries object for the current symbol and period, and show its description in the journal engine.SeriesCreate(Symbol(),Period()); engine.GetTimeSeriesCollection().PrintShort(false); // Short descriptions //--- Create the required number of WinForms Panel objects CPanel *pnl=NULL; for(int i=0;i<1;i++) { pnl=engine.CreateWFPanel("WinForms Panel"+(string)i,(i==0 ? 50 : 70),(i==0 ? 50 : 70),410,200,array_clr,200,true,true,false,-1,FRAME_STYLE_BEVEL,true,false); if(pnl!=NULL) { pnl.Hide(); Print(DFUN,"Panel description: ",pnl.Description(),", Type and name: ",pnl.TypeElementDescription()," ",pnl.Name()); //--- Set Padding to 4 pnl.SetPaddingAll(3); //--- Set the flags of relocation, auto resizing and auto changing mode from the inputs pnl.SetMovable(InpMovable); pnl.SetAutoSize(InpAutoSize,false); pnl.SetAutoSizeMode((ENUM_CANV_ELEMENT_AUTO_SIZE_MODE)InpAutoSizeMode,false); //--- Create TabControl pnl.CreateNewElement(GRAPH_ELEMENT_TYPE_WF_TAB_CONTROL,InpTabControlX,InpTabControlY,pnl.Width()-30,pnl.Height()-40,clrNONE,255,true,false); CTabControl *tc=pnl.GetElementByType(GRAPH_ELEMENT_TYPE_WF_TAB_CONTROL,0); if(tc!=NULL) { tc.SetTabSizeMode((ENUM_CANV_ELEMENT_TAB_SIZE_MODE)InpTabPageSizeMode); tc.SetAlignment((ENUM_CANV_ELEMENT_ALIGNMENT)InpHeaderAlignment); tc.SetMultiline(InpTabCtrlMultiline); tc.SetHeaderPadding(6,0); tc.CreateTabPages(11,0,56,20,TextByLanguage("Вкладка","TabPage")); //--- Create a text label with a tab description on each tab for(int j=0;j<tc.TabPages();j++) { tc.CreateNewElement(j,GRAPH_ELEMENT_TYPE_WF_LABEL,60,20,80,20,clrDodgerBlue,255,true,false); CLabel *label=tc.GetTabElement(j,0); if(label==NULL) continue; label.SetText("TabPage"+string(j+1)); } } } } //--- Display and redraw all created panels for(int i=0;i<1;i++) { pnl=engine.GetWFPanelByName("Panel"+(string)i); if(pnl!=NULL) { pnl.Show(); pnl.Redraw(true); } } //--- return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+
Los paneles se crearán en un ciclo (solo un panel por el momento), porque resulta que si creamos varios paneles con controles TabControl, esos controles no funcionarán correctamente. Para subsanar este defecto en el futuro, implementaremos la creación del número necesario de paneles.
Luego compilaremos el asesor experto y lo ejecutaremos en el gráfico, configurando previamente los ajustes necesarios:
Como podemos ver, la funcionalidad declarada funciona correctamente.
¿Qué es lo próximo?
En el próximo artículo, crearemos los métodos necesarios para desplazar los encabezados de las pestañas en todas las direcciones utilizando los botones de control del scrolling.
*Artículos de esta serie:
DoEasy. Elementos de control (Parte 10): Objetos WinForms: dando vida a la interfaz
DoEasy. Elementos de control (Parte 11): Objetos WinForms: grupos, el objeto WinForms CheckedListBox
DoEasy. Elementos de control (Parte 12): Objeto de lista básico, objetos WinForms ListBox y ButtonListBox
DoEasy. Elementos de control (Parte 13): Optimizando la interacción de los objetos WinForms con el ratón. Comenzamos el desarrollo del objeto WinForms TabControl
DoEasy. Elementos de control (Parte 14): Nuevo algoritmo de denominación de los elementos gráficos. Continuamos trabajando con el objeto WinForms TabControl
DoEasy. Elementos de control (Parte 15): Objeto WinForms TabControl - múltiples filas de encabezados de pestañas, métodos de trabajo con pestañas
DoEasy. Elementos de control (Parte 16): Objeto WinForms TabControl - múltiples filas de encabezados de pestañas, modo de expansión de encabezados para ajustarse al tamaño del contenedor
DoEasy. Elementos de control (Parte 17): Recortando partes invisibles de objetos, objetos WinForms auxiliares de botón con flechas
Traducción del ruso hecha por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/ru/articles/11454
Redes neuronales: así de sencillo (Parte 29): Algoritmo actor-crítico con ventaja (Advantage actor-critic)
Aprendiendo a diseñar un sistema de trading con Relative Vigor Index
Aprendiendo a diseñar un sistema de trading con Awesome Oscillator
Gráfico de montaña o gráfico de iceberg
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso