AiDataTaskRuner/UI/DataGenerationTab/Base.mqh

//+------------------------------------------------------------------+
//|                                                         Base.mqh |
//|                                  Copyright 2025, Niquel Mendoza. |
//|                          https://www.mql5.com/es/users/nique_372 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Niquel Mendoza."
#property link      "https://www.mql5.com/es/users/nique_372"
#property strict

#ifndef AIDATATASKRUNER_UI_DATAGENERATIONTAB_BASE_MQH
#define AIDATATASKRUNER_UI_DATAGENERATIONTAB_BASE_MQH

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#include "Def.mqh"

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CTaskRunerAiTabDGenMain : public CGuiBaseTab
 {
private:
  //---
  CTabs              m_tabs;
  ITaskRunerAi*       m_runer;

  //--- Tab 1 Agregar task
  //- COnfigiraiino base
  CButton            m_section_bsic_buttom_load;
  CButton            m_section_bsic_buttom_save;
  CTextLabel         m_label_basic_config;
  CTextEdit          m_section_bsic_edit_files;
  CTextEdit          m_section_bsic_edit_expert_path;
  CTextEdit          m_section_bsic_edit_progres_csv_file;
  CTextEdit          m_section_bsic_edit_main_folder;

  //- Task
  CTextLabel         m_label_new_task;

  //
  CTextEdit          m_section_nt_edit_symbol;
  CTextEdit          m_section_nt_edit_symbol_folder;
  CComboBox          m_section_nt_combox_timerame;
  CTextEdit          m_section_nt_edit_label;
  CTextEdit          m_section_nt_edit_label_id;
  CDropCalendar      m_section_nt_dc_dt_start;
  CDropCalendar      m_section_nt_dc_dt_end;
  CTextEdit          m_section_nt_edit_st_file;

  //
  CButton            m_section_nt_buttom_add_task;

  //--- Tab 2 visualizar
  CButton            m_section_buttom_pending_load;
  CButton            m_section_buttom_pending_save;
  CButton            m_section_buttom_clean;
  CButton            m_section_buttom_execute_all;
  CTable             m_section_pending_table;
  //CWindow liuego dar la posiblidad de modificar

  //--- Create metods
  bool               CreateMainTab(CWndCreate* p, CWindow& main_window, CTabs& general_tabs, int tab_index, int top_gap, int left_gap, int right_gap, int bottom_gap);
  bool               CreatePendigTab(CWndCreate* p, CWindow& main_window, CTabs& general_tabs, int tab_index, int top_gap, int left_gap, int right_gap, int bottom_gap);


  //--- Partes de main tab
  bool               CreateMainTab_BasicConfig(CWndCreate* p, CWindow& main_window, CTabs& general_tabs, int tab_index, const int initial_x, int& x, int& y);
  bool               CreateMainTab_NewTask(CWndCreate* p, CWindow& main_window, CTabs& general_tabs, int tab_index, const int initial_x, int& x, int& y);

  //---
  // rows = array con las filas a actulizar
  // index_s = nuevo estaod
  // size = tamaño del array rows
  void               ActulizeTableAllTask(const int index_s, int& rows[], int size);
  void               OnAddTask();
  void               UpdateTextMain();
  void               UpdateTextTask();

  //---
  template <typename TObject>
  void               ResizeTElement(TObject& obj, const string key, int width_element);
  template <typename TObject>
  void               UpdateTBasic(TObject& obj, const string key, bool has_tool = true);

public:
                     CTaskRunerAiTabDGenMain(void) : CGuiBaseTab("CTaskRunerAiTabDGenMain") {}
                    ~CTaskRunerAiTabDGenMain(void) {}

  //---
  // topgap es 0 creo
  // leftgap debera de considerar el espeacio en V
  bool               Create(CWndCreate* p, CWindow& main_window, int top_gap, int left_gap, int right_gap, int bottom_gap);
  void               SetRunner(ITaskRunerAi* r) { m_runer = r; }

  //---
  void               OnLenguajeChange() override final;
  bool               OnClickBottom(const long lparam);
  bool               OnChangeDate(const long lparam, const double dparam); //dparm = date
  bool               OnTextEdit(const long lparam);
  bool               OnChangeComBox(const long lparam);

  //---
  void               UpdateStateInTable(const int index, const int state);
 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CTaskRunerAiTabDGenMain::Create(CWndCreate* p, CWindow& main_window, int top_gap, int left_gap, int right_gap, int bottom_gap)
 {
//---
  string txt[TASKRUNERAIDGENMAIN_TAB_TOTAL] = {m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_tabs) + "_0"], m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_tabs) + "_1"]};
  int width[TASKRUNERAIDGENMAIN_TAB_TOTAL] = { 70, 80 };
  color clrs_tab_label[TASKRUNERAIDGENMAIN_TAB_TOTAL] = {AIDATATASKRUNER_COLOR_TEXT_SECONDARY, AIDATATASKRUNER_COLOR_TEXT_SECONDARY};
  color clrs_tab_label_pressed[TASKRUNERAIDGENMAIN_TAB_TOTAL] = {AIDATATASKRUNER_COLOR_ACCENT, AIDATATASKRUNER_COLOR_ACCENT};
  top_gap += 24;
  left_gap += 4;
  right_gap += 4;
  bottom_gap += 4;

//---
  m_tabs.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB);
  m_tabs.BackColorHover(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_HOVER);
  m_tabs.BackColorPressed(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_tabs.BackColorLocked(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_LOCKED);
  m_tabs.BorderColor(AIDATATASKRUNER_COLOR_BORDER);
  m_tabs.BorderColorHover(AIDATATASKRUNER_COLOR_BORDER_HOVER);
  m_tabs.BorderColorPressed(AIDATATASKRUNER_COLOR_BORDER_HOVER);
  m_tabs.BorderColorLocked(AIDATATASKRUNER_COLOR_BORDER);
//m_tabs.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
//m_tabs.LabelColorLocked(AIDATATASKRUNER_COLOR_TEXT_LOCKED);

//---
  if(!p.CreateTabs(m_tabs, main_window, 0, m_base_tab, m_base_tab_idx, left_gap, top_gap, 0, 0, txt, width, clrs_tab_label, clrs_tab_label_pressed,
                   TABS_TOP, true, true,  right_gap,  bottom_gap))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_tabs);
    return false;
   }


//---
  if(!CreateMainTab(p, main_window, m_tabs, TASKRUNERAIDGENMAIN_TAB_MAIN, top_gap, left_gap, right_gap, bottom_gap))
    return false;

//---
  if(!CreatePendigTab(p, main_window, m_tabs, TASKRUNERAIDGENMAIN_TAB_TASK, top_gap, left_gap, right_gap, bottom_gap))
    return false;

//---
  return true;
 }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CTaskRunerAiTabDGenMain::CreateMainTab(CWndCreate *p, CWindow &main_window, CTabs &general_tabs, int tab_index, int top_gap, int left_gap, int right_gap, int bottom_gap)
 {
//---
  const int initial_x = left_gap + 5;
  int x = initial_x;
  int y = top_gap + 10;

//---
  if(!CreateMainTab_BasicConfig(p, main_window, general_tabs, tab_index, initial_x, x, y))
    return false;

  if(!CreateMainTab_NewTask(p, main_window, general_tabs, tab_index, initial_x, x, y))
    return false;

//--- Tarea actual
  TaskTester t;
  t.start_date    = m_section_nt_dc_dt_start.SelectedDate();
  t.end_date      = m_section_nt_dc_dt_end.SelectedDate();
  t.timeframe     = StrShortTimeframeToEnumNoRef(m_section_nt_combox_timerame.GetValue());
  t.set_file      = m_section_nt_edit_st_file.GetValue();
  t.symbol        = m_section_nt_edit_symbol.GetValue();
  t.symbol_folder = m_section_nt_edit_symbol_folder.GetValue();
  t.label         = m_section_nt_edit_label.GetValue();
  t.label_id      = int(m_section_nt_edit_label_id.GetValue());
  m_runer.InitCurrentTask(t);

//---
  return true;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#define AIDATATASKRUNER_MAINTAB_LABEL_X_PAD (5)
#define AIDATATASKRUNER_MAINTAB_GAP_YSEC (15)
#define AIDATATASKRUNER_MAINTAB_GAP_YPRIM (25)
#define AIDATATASKRUNER_MAINTAB_GAP_YSEC_FIRST (12)
#define AITASKRUNER_MAX_VLAUE_LABEL_ID (1000000000000.0)

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CTaskRunerAiTabDGenMain::CreateMainTab_BasicConfig(CWndCreate *p, CWindow &main_window, CTabs &general_tabs, int tab_index, const int initial_x, int &x, int &y)
 {
//---
  m_label_basic_config.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_label_basic_config.LabelColor(AIDATATASKRUNER_COLOR_TEXT_PRIMARY);
  m_label_basic_config.FontSize(14);
  m_label_basic_config.Font("Arial");
  if(!p.CreateTextLabel(m_label_basic_config, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_label_basic_config)],
                        main_window, 0, general_tabs, tab_index, x, y, 130))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_label_basic_config);
    return false;
   }


//---
  x += m_label_basic_config.XSize() + 20;

//---
//Print(m_section_bsic_buttom_load.XSize());
  m_section_bsic_buttom_load.FontSize(9);
  m_section_bsic_buttom_load.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_bsic_buttom_load.BackColor(AIDATATASKRUNER_COLOR_BTN_BACK);
  m_section_bsic_buttom_load.BorderColor(AIDATATASKRUNER_COLOR_BTN_BORDER);
  m_section_bsic_buttom_load.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_bsic_buttom_load)));

  if(!p.CreateButton(m_section_bsic_buttom_load, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_buttom_load)],
                     main_window, 0, general_tabs, tab_index, x, y + 3, 125))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_bsic_buttom_load);
    return false;
   }

  x += m_section_bsic_buttom_load.XSize() + 18;

//---
  m_section_bsic_buttom_save.FontSize(9);
  m_section_bsic_buttom_save.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_bsic_buttom_save.BackColor(AIDATATASKRUNER_COLOR_BTN_BACK);
  m_section_bsic_buttom_save.BorderColor(AIDATATASKRUNER_COLOR_BTN_BORDER);
  m_section_bsic_buttom_save.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_bsic_buttom_save)));

  if(!p.CreateButton(m_section_bsic_buttom_save, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_buttom_save)],
                     main_window, 0, general_tabs, tab_index, x, y + 3, 125))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_bsic_buttom_save);
    return false;
   }

//--- El y se mueve luego
  y += m_label_basic_config.YSize() + AIDATATASKRUNER_MAINTAB_GAP_YSEC_FIRST;

//---
  x = initial_x;

//---
  string texto;
  int    width;

// Files
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_edit_files)];
  m_section_bsic_edit_files.FontSize(10);
  m_section_bsic_edit_files.Font("Arial");
  m_section_bsic_edit_files.CanvasFontSet();
  width = m_section_bsic_edit_files.m_canvas.TextWidth(texto);
  m_section_bsic_edit_files.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_bsic_edit_files.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_bsic_edit_files.GetTextBoxPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_bsic_edit_files.GetTextBoxPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_bsic_edit_files.GetTextBoxPointer().DefaultTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_bsic_edit_files.GetTextBoxPointer().LabelColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_bsic_edit_files.GetTextBoxPointer().SelectedBackColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_SELECTED);
  m_section_bsic_edit_files.GetTextBoxPointer().SelectedTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_HIGHLIGHT);
  m_section_bsic_edit_files.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_bsic_edit_files)));

  if(!p.CreateTextEdit(m_section_bsic_edit_files, texto,
                       main_window, 0, general_tabs, tab_index, false, x, y, width + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD + 300, 300, ""))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_bsic_edit_files);
    return false;
   }
  y += m_section_bsic_edit_files.YSize() + AIDATATASKRUNER_MAINTAB_GAP_YSEC;

// Expert path
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_edit_expert_path)];
  m_section_bsic_edit_expert_path.FontSize(10);
  m_section_bsic_edit_expert_path.Font("Arial");
  m_section_bsic_edit_expert_path.CanvasFontSet();
  width = m_section_bsic_edit_expert_path.m_canvas.TextWidth(texto);
  m_section_bsic_edit_expert_path.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_bsic_edit_expert_path.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_bsic_edit_expert_path.GetTextBoxPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_bsic_edit_expert_path.GetTextBoxPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_bsic_edit_expert_path.GetTextBoxPointer().DefaultTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_bsic_edit_expert_path.GetTextBoxPointer().LabelColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_bsic_edit_expert_path.GetTextBoxPointer().SelectedBackColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_SELECTED);
  m_section_bsic_edit_expert_path.GetTextBoxPointer().SelectedTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_HIGHLIGHT);
  m_section_bsic_edit_expert_path.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_bsic_edit_expert_path)));


  if(!p.CreateTextEdit(m_section_bsic_edit_expert_path, texto,
                       main_window, 0, general_tabs, tab_index, false, x, y, width + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD + 300, 300, ""))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_bsic_edit_expert_path);
    return false;
   }
  y += m_section_bsic_edit_expert_path.YSize() + AIDATATASKRUNER_MAINTAB_GAP_YSEC;

// Progress csv
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_edit_progres_csv_file)];
  m_section_bsic_edit_progres_csv_file.FontSize(10);
  m_section_bsic_edit_progres_csv_file.Font("Arial");
  m_section_bsic_edit_progres_csv_file.CanvasFontSet();
  width = m_section_bsic_edit_progres_csv_file.m_canvas.TextWidth(texto);
  m_section_bsic_edit_progres_csv_file.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_bsic_edit_progres_csv_file.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_bsic_edit_progres_csv_file.GetTextBoxPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_bsic_edit_progres_csv_file.GetTextBoxPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_bsic_edit_progres_csv_file.GetTextBoxPointer().DefaultTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_bsic_edit_progres_csv_file.GetTextBoxPointer().LabelColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_bsic_edit_progres_csv_file.GetTextBoxPointer().SelectedBackColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_SELECTED);
  m_section_bsic_edit_progres_csv_file.GetTextBoxPointer().SelectedTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_HIGHLIGHT);
  m_section_bsic_edit_progres_csv_file.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_bsic_edit_progres_csv_file)));


  if(!p.CreateTextEdit(m_section_bsic_edit_progres_csv_file, texto,
                       main_window, 0, general_tabs, tab_index, false, x, y, width + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD + 300, 300, ""))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_bsic_edit_progres_csv_file);
    return false;
   }
  y += m_section_bsic_edit_progres_csv_file.YSize() + AIDATATASKRUNER_MAINTAB_GAP_YSEC;

// Main folder
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_edit_main_folder)];
  m_section_bsic_edit_main_folder.FontSize(10);
  m_section_bsic_edit_main_folder.Font("Arial");
  m_section_bsic_edit_main_folder.CanvasFontSet();
  width = m_section_bsic_edit_main_folder.m_canvas.TextWidth(texto);
  m_section_bsic_edit_main_folder.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_bsic_edit_main_folder.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_bsic_edit_main_folder.GetTextBoxPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_bsic_edit_main_folder.GetTextBoxPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_bsic_edit_main_folder.GetTextBoxPointer().DefaultTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_bsic_edit_main_folder.GetTextBoxPointer().LabelColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_bsic_edit_main_folder.GetTextBoxPointer().SelectedBackColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_SELECTED);
  m_section_bsic_edit_main_folder.GetTextBoxPointer().SelectedTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_HIGHLIGHT);
  m_section_bsic_edit_main_folder.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_bsic_edit_main_folder)));


  if(!p.CreateTextEdit(m_section_bsic_edit_main_folder, texto,
                       main_window, 0, general_tabs, tab_index, false, x, y, width + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD + 250, 250, ""))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_bsic_edit_main_folder);
    return false;
   }
  y += m_section_bsic_edit_main_folder.YSize() + 30;

//---
  return true;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CTaskRunerAiTabDGenMain::CreateMainTab_NewTask(CWndCreate *p, CWindow &main_window, CTabs &general_tabs, int tab_index, const int initial_x, int &x, int &y)
 {
//---
  m_label_new_task.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_label_new_task.LabelColor(AIDATATASKRUNER_COLOR_TEXT_PRIMARY);
  m_label_new_task.FontSize(14);
  m_label_new_task.Font("Arial");
  if(!p.CreateTextLabel(m_label_new_task, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_label_new_task)],
                        main_window, 0, general_tabs, tab_index, x, y, 200))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_label_new_task);
    return false;
   }
  y += m_label_new_task.YSize() + AIDATATASKRUNER_MAINTAB_GAP_YSEC_FIRST;

//---
  string texto;
  int    width;

// Symbol
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_edit_symbol)];
  m_section_nt_edit_symbol.FontSize(10);
  m_section_nt_edit_symbol.Font("Arial");
  m_section_nt_edit_symbol.CanvasFontSet();
  width = m_section_nt_edit_symbol.m_canvas.TextWidth(texto);
  m_section_nt_edit_symbol.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_edit_symbol.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_nt_edit_symbol.GetTextBoxPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_nt_edit_symbol.GetTextBoxPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_nt_edit_symbol.GetTextBoxPointer().DefaultTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_nt_edit_symbol.GetTextBoxPointer().LabelColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_nt_edit_symbol.GetTextBoxPointer().SelectedBackColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_SELECTED);
  m_section_nt_edit_symbol.GetTextBoxPointer().SelectedTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_HIGHLIGHT);
  m_section_nt_edit_symbol.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_nt_edit_symbol)));


  if(!p.CreateTextEdit(m_section_nt_edit_symbol, texto,
                       main_window, 0, general_tabs, tab_index, false, x, y, width + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD + 150, 150, ""))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_nt_edit_symbol);
    return false;
   }
  x += m_section_nt_edit_symbol.XSize() + 20;

// Symbol folder
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_edit_symbol_folder)];
  m_section_nt_edit_symbol_folder.FontSize(10);
  m_section_nt_edit_symbol_folder.Font("Arial");
  m_section_nt_edit_symbol_folder.CanvasFontSet();
  width = m_section_nt_edit_symbol_folder.m_canvas.TextWidth(texto);
  m_section_nt_edit_symbol_folder.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_edit_symbol_folder.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_nt_edit_symbol_folder.GetTextBoxPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_nt_edit_symbol_folder.GetTextBoxPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_nt_edit_symbol_folder.GetTextBoxPointer().DefaultTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_nt_edit_symbol_folder.GetTextBoxPointer().LabelColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_nt_edit_symbol_folder.GetTextBoxPointer().SelectedBackColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_SELECTED);
  m_section_nt_edit_symbol_folder.GetTextBoxPointer().SelectedTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_HIGHLIGHT);
  m_section_nt_edit_symbol_folder.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_nt_edit_symbol_folder)));


  if(!p.CreateTextEdit(m_section_nt_edit_symbol_folder, texto,
                       main_window, 0, general_tabs, tab_index, false, x, y, width + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD + 150, 150, ""))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_nt_edit_symbol_folder);
    return false;
   }
  x = initial_x;
  y += m_section_nt_edit_symbol_folder.YSize() + AIDATATASKRUNER_MAINTAB_GAP_YSEC;

// Timeframe
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_combox_timerame)];
  m_section_nt_combox_timerame.FontSize(10);
  m_section_nt_combox_timerame.Font("Arial");
  m_section_nt_combox_timerame.CanvasFontSet();
  width = m_section_nt_combox_timerame.m_canvas.TextWidth(texto);
  m_section_nt_combox_timerame.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_combox_timerame.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_nt_combox_timerame.GetListViewPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_nt_combox_timerame.GetListViewPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_nt_combox_timerame.GetListViewPointer().LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_combox_timerame.GetButtonPointer().LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_combox_timerame.GetButtonPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_nt_combox_timerame.GetButtonPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_nt_combox_timerame.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_nt_combox_timerame)));

  if(!p.CreateCombobox(m_section_nt_combox_timerame, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_combox_timerame)],
                       main_window, 0, general_tabs, tab_index, false, x, y, width + 150 + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD, 150, g_arr_str_timefrrames_short, 150))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_nt_combox_timerame);
    return false;
   }
  m_section_nt_combox_timerame.m_button.IconFile(RESOURCE_DOWN_THIN_WHITE);
  m_section_nt_combox_timerame.m_button.IconFileLocked(RESOURCE_DOWN_THIN_WHITE);
  m_section_nt_combox_timerame.m_button.CElement::IconFilePressed(RESOURCE_UP_THIN_WHITE);
  m_section_nt_combox_timerame.m_button.CElement::IconFilePressedLocked(RESOURCE_UP_THIN_WHITE);
  y += m_section_nt_combox_timerame.YSize() + AIDATATASKRUNER_MAINTAB_GAP_YSEC;

// Label
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_edit_label)];
  m_section_nt_edit_label.FontSize(10);
  m_section_nt_edit_label.Font("Arial");
  m_section_nt_edit_label.CanvasFontSet();
  width = m_section_nt_edit_label.m_canvas.TextWidth(texto);
  m_section_nt_edit_label.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_edit_label.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_nt_edit_label.GetTextBoxPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_nt_edit_label.GetTextBoxPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_nt_edit_label.GetTextBoxPointer().DefaultTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_nt_edit_label.GetTextBoxPointer().LabelColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_nt_edit_label.GetTextBoxPointer().SelectedBackColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_SELECTED);
  m_section_nt_edit_label.GetTextBoxPointer().SelectedTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_HIGHLIGHT);
  m_section_nt_edit_label.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_nt_edit_label)));


  if(!p.CreateTextEdit(m_section_nt_edit_label, texto,
                       main_window, 0, general_tabs, tab_index, false, x, y, width + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD + 200, 200, ""))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_nt_edit_label);
    return false;
   }
  x += m_section_nt_edit_label.XSize() + 20;

// Label id
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_edit_label_id)];
  m_section_nt_edit_label_id.FontSize(10);
  m_section_nt_edit_label_id.Font("Arial");
  m_section_nt_edit_label_id.CanvasFontSet();
  width = m_section_nt_edit_label_id.m_canvas.TextWidth(texto);
  m_section_nt_edit_label_id.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_edit_label_id.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_nt_edit_label_id.GetTextBoxPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_nt_edit_label_id.GetTextBoxPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_nt_edit_label_id.GetTextBoxPointer().DefaultTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_nt_edit_label_id.GetTextBoxPointer().LabelColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_nt_edit_label_id.GetTextBoxPointer().SelectedBackColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_SELECTED);
  m_section_nt_edit_label_id.GetTextBoxPointer().SelectedTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_HIGHLIGHT);
  m_section_nt_edit_label_id.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_nt_edit_label_id)));


  if(!p.CreateTextEdit(m_section_nt_edit_label_id, texto,
                       main_window, 0, general_tabs, tab_index, false, x, y, width + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD + 175, 175, AITASKRUNER_MAX_VLAUE_LABEL_ID, 0, 1, 0, 0))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_nt_edit_label_id);
    return false;
   }
  y += m_section_nt_edit_label_id.YSize() + AIDATATASKRUNER_MAINTAB_GAP_YSEC;
  x = initial_x;

// Fechas
  const datetime end   = CTimeUtils::StartOfYear(TimeCurrent());
  const datetime start = end - 31536000;


//
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_dc_dt_start)];
  m_section_nt_dc_dt_start.FontSize(10);
  m_section_nt_dc_dt_start.Font("Arial");
  m_section_nt_dc_dt_start.CanvasFontSet();
  width = m_section_nt_dc_dt_start.m_canvas.TextWidth(texto);

  m_section_nt_dc_dt_start.FontSize(10);
  m_section_nt_dc_dt_start.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_dc_dt_start.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_nt_dc_dt_start.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_nt_dc_dt_start)));


  if(!p.CreateDropCalendar(m_section_nt_dc_dt_start, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_dc_dt_start)],
                           main_window, 0, general_tabs, tab_index, x, y, width + 100 + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD, start))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_nt_dc_dt_start);
    return false;
   }
  x += m_section_nt_dc_dt_start.XSize() + 20;


//
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_dc_dt_end)];
  m_section_nt_dc_dt_end.FontSize(10);
  m_section_nt_dc_dt_end.Font("Arial");
  m_section_nt_dc_dt_end.CanvasFontSet();
  width = m_section_nt_dc_dt_end.m_canvas.TextWidth(texto);

  m_section_nt_dc_dt_end.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_dc_dt_end.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_nt_dc_dt_end.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_nt_dc_dt_end)));


  if(!p.CreateDropCalendar(m_section_nt_dc_dt_end, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_dc_dt_end)],
                           main_window, 0, general_tabs, tab_index, x, y, width + 100 + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD, end))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_nt_dc_dt_end);
    return false;
   }
  x = initial_x;
  y += m_section_nt_dc_dt_end.YSize() + AIDATATASKRUNER_MAINTAB_GAP_YSEC;

// Set file
  texto = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_edit_st_file)];
  m_section_nt_edit_st_file.FontSize(10);
  m_section_nt_edit_st_file.Font("Arial");
  m_section_nt_edit_st_file.CanvasFontSet();
  width = m_section_nt_edit_st_file.m_canvas.TextWidth(texto);
  m_section_nt_edit_st_file.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_edit_st_file.BackColor(AIDATATASKRUNER_COLOR_FONDO_SUBTAB_PRESSED);
  m_section_nt_edit_st_file.GetTextBoxPointer().BackColor(AIDATATASKRUNER_COLOR_EDIT_BACK);
  m_section_nt_edit_st_file.GetTextBoxPointer().BorderColor(AIDATATASKRUNER_COLOR_EDIT_BORDER);
  m_section_nt_edit_st_file.GetTextBoxPointer().DefaultTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_nt_edit_st_file.GetTextBoxPointer().LabelColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_NORMAL);
  m_section_nt_edit_st_file.GetTextBoxPointer().SelectedBackColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_SELECTED);
  m_section_nt_edit_st_file.GetTextBoxPointer().SelectedTextColor(AIDATATASKRUNER_COLOR_EDIT_TEXT_HIGHLIGHT);
  m_section_nt_edit_st_file.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_nt_edit_st_file)));


  if(!p.CreateTextEdit(m_section_nt_edit_st_file, texto,
                       main_window, 0, general_tabs, tab_index, false, x, y, width + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD + 200, 200, ""))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_nt_edit_st_file);
    return false;
   }
  y += m_section_nt_edit_st_file.YSize() + AIDATATASKRUNER_MAINTAB_GAP_YSEC;

// Add task button
  m_section_nt_buttom_add_task.FontSize(9);
  m_section_nt_buttom_add_task.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_nt_buttom_add_task.BackColor(AIDATATASKRUNER_COLOR_BTN_BACK);
  m_section_nt_buttom_add_task.BorderColor(AIDATATASKRUNER_COLOR_BTN_BORDER);
  m_section_nt_buttom_add_task.Tooltip(m_language.Tooltip(GUIBASE_COMPONENT_NAME(m_section_nt_buttom_add_task)));


  if(!p.CreateButton(m_section_nt_buttom_add_task, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_buttom_add_task)],
                     main_window, 0, general_tabs, tab_index, x, y, 125))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_nt_buttom_add_task);
    return false;
   }

//---
  return true;
 }




//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CTaskRunerAiTabDGenMain::CreatePendigTab(CWndCreate *p, CWindow &main_window, CTabs &general_tabs, int tab_index, int top_gap, int left_gap, int right_gap, int bottom_gap)
 {
//---
  int x = left_gap + 5;
  int y = top_gap + 10;

//---
#define TASKRUNERAIDGENMAIN_PENDINGTAB_BOOTON_XSIZE (130)
#define TASKRUNERAIDGENMAIN_PENDINGTAB_BOOTON_XGAP  (18)


//---
  m_section_buttom_pending_load.FontSize(9);
  m_section_buttom_pending_load.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_buttom_pending_load.BackColor(AIDATATASKRUNER_COLOR_BTN_BACK);
  m_section_buttom_pending_load.BorderColor(AIDATATASKRUNER_COLOR_BTN_BORDER);

  if(!p.CreateButton(m_section_buttom_pending_load, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_buttom_pending_load)],
                     main_window, 0, general_tabs, tab_index, x, y, TASKRUNERAIDGENMAIN_PENDINGTAB_BOOTON_XSIZE))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_buttom_pending_load);
    return false;
   }
  x += m_section_buttom_pending_load.XSize() + 20;

//
  m_section_buttom_pending_save.FontSize(9);
  m_section_buttom_pending_save.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_buttom_pending_save.BackColor(AIDATATASKRUNER_COLOR_BTN_BACK);
  m_section_buttom_pending_save.BorderColor(AIDATATASKRUNER_COLOR_BTN_BORDER);
  if(!p.CreateButton(m_section_buttom_pending_save, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_buttom_pending_save)]
                     , main_window, 0, general_tabs, tab_index, x, y, TASKRUNERAIDGENMAIN_PENDINGTAB_BOOTON_XSIZE))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_buttom_pending_save);
    return false;
   }
  x += m_section_buttom_pending_save.XSize() + 20;

//
  m_section_buttom_execute_all.FontSize(9);
  m_section_buttom_execute_all.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_buttom_execute_all.BackColor(AIDATATASKRUNER_COLOR_BTN_BACK);
  m_section_buttom_execute_all.BorderColor(AIDATATASKRUNER_COLOR_BTN_BORDER);
  if(!p.CreateButton(m_section_buttom_execute_all, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_buttom_execute_all)]
                     , main_window, 0, general_tabs, tab_index, x, y, TASKRUNERAIDGENMAIN_PENDINGTAB_BOOTON_XSIZE))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_buttom_execute_all);
    return false;
   }
  x += m_section_buttom_execute_all.XSize() + 20;

//
  m_section_buttom_clean.FontSize(9);
  m_section_buttom_clean.LabelColor(AIDATATASKRUNER_COLOR_TEXT_SECONDARY);
  m_section_buttom_clean.BackColor(AIDATATASKRUNER_COLOR_BTN_BACK);
  m_section_buttom_clean.BorderColor(AIDATATASKRUNER_COLOR_BTN_BORDER);
  if(!p.CreateButton(m_section_buttom_clean, m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_buttom_clean)]
                     , main_window, 0, general_tabs, tab_index, x, y, TASKRUNERAIDGENMAIN_PENDINGTAB_BOOTON_XSIZE))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_buttom_clean);
    return false;
   }

//---
  y += 25;
  x = left_gap + 5;

#define AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL (9)


#define AIDATATASKRUNER_TASK_TABLLE_SIMBOLO   (0)
#define AIDATATASKRUNER_TASK_TABLLE_SIMBOLO_FOLDER   (1)
#define AIDATATASKRUNER_TASK_TABLLE_TIMEFRAME (2)
#define AIDATATASKRUNER_TASK_TABLLE_LABEL     (3)
#define AIDATATASKRUNER_TASK_TABLLE_LABEL_ID  (4)
#define AIDATATASKRUNER_TASK_TABLLE_DESDE     (5)
#define AIDATATASKRUNER_TASK_TABLLE_HASTA     (6)
#define AIDATATASKRUNER_TASK_TABLLE_ESTADO    (7)
#define AIDATATASKRUNER_TASK_TABLLE_MODIFICAR (8)

//---
  string headers[];
  const string header_str = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_pending_table) + "_header"];
  if(!StrTo::CstArray(headers, header_str, '|', true))
   {
    LogError(StringFormat("Fallo al hacer str to arrary str, str = %s", header_str), FUNCION_ACTUAL);
    return false;
   }

  ArrayResize(headers, AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL); // Trim en caso de exendete

// Aling
  ENUM_ALIGN_MODE align[AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL];
  ArrayFill(align, 0, AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL, ALIGN_LEFT);

//--- Colores
// Headers
  m_section_pending_table.HeadersColor(C'0x2A,0x4A,0x6A');        // azul oscuro
  m_section_pending_table.HeadersColorHover(AIDATATASKRUNER_COLOR_ACCENT); // azul accent hover
  m_section_pending_table.HeadersColorPressed(C'0x1E,0x38,0x52'); // más oscuro al presionar
  m_section_pending_table.HeadersTextColor(AIDATATASKRUNER_COLOR_TEXT_PRIMARY);

// Celdas
  m_section_pending_table.CellColor(AIDATATASKRUNER_COLOR_FONDO_WIN);       // C'37,40,54'
  m_section_pending_table.CellColorHover(AIDATATASKRUNER_COLOR_EDIT_BACK);  // C'0x37,0x3D,0x53' hover sutil
  m_section_pending_table.CElement::BackColor(AIDATATASKRUNER_COLOR_FONDO_WIN);

// Grid
  m_section_pending_table.GridColor(AIDATATASKRUNER_COLOR_BORDER); // C'58,63,82' sutil

// Texto celdas - vía CellInitialize usa m_label_color
// necesitas setearlo antes de crear:
  m_section_pending_table.m_label_color = AIDATATASKRUNER_COLOR_TEXT_SECONDARY;

//---
  CScrollH *sh = m_section_pending_table.GetScrollHPointer();

// Fondo de la barra (el riel)
  sh.BackColor(AIDATATASKRUNER_COLOR_FONDO_TAB);          // C'26,29,39' - oscuro

// Ползunок (thumb) en 3 estados
  sh.ThumbColor(AIDATATASKRUNER_COLOR_BORDER);             // C'58,63,82' - reposo sutil
  sh.ThumbColorHover(AIDATATASKRUNER_COLOR_BORDER_HOVER);  // C'61,142,240' - hover azul
  sh.ThumbColorPressed(AIDATATASKRUNER_COLOR_ACCENT);      // C'0x69,0xA8,0xF3' - presionado

// Forzar iconos blancos
  sh.IncFile((string)RESOURCE_SCROLL_LEFT_WHITE);
  sh.IncFileLocked((string)RESOURCE_SCROLL_LEFT_WHITE);
  sh.IncFilePressed((string)RESOURCE_SCROLL_LEFT_WHITE);

  sh.DecFile((string)RESOURCE_SCROLL_RIGHT_WHITE);
  sh.DecFileLocked((string)RESOURCE_SCROLL_RIGHT_WHITE);
  sh.DecFilePressed((string)RESOURCE_SCROLL_RIGHT_WHITE);

//--- Base
  m_section_pending_table.CellYSize(30);
  m_section_pending_table.FontSize(10);
  m_section_pending_table.HeaderYSize(25);
  m_section_pending_table.IsSortMode(true);
  m_section_pending_table.DefaultTextAlign(ALIGN_LEFT);

//
  m_section_pending_table.TableSize(AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL, 1);

//
  m_section_pending_table.DataType(AIDATATASKRUNER_TASK_TABLLE_SIMBOLO, TYPE_STRING);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_SIMBOLO, 0, "");

  m_section_pending_table.DataType(AIDATATASKRUNER_TASK_TABLLE_SIMBOLO_FOLDER, TYPE_STRING);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_SIMBOLO_FOLDER, 0, "");


  m_section_pending_table.DataType(AIDATATASKRUNER_TASK_TABLLE_TIMEFRAME, TYPE_STRING);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_TIMEFRAME, 0, "");

  m_section_pending_table.DataType(AIDATATASKRUNER_TASK_TABLLE_LABEL, TYPE_STRING);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_LABEL, 0, "");

  m_section_pending_table.DataType(AIDATATASKRUNER_TASK_TABLLE_LABEL_ID, TYPE_LONG);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_LABEL_ID, 0, "0");

  m_section_pending_table.DataType(AIDATATASKRUNER_TASK_TABLLE_DESDE, TYPE_DATETIME);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_DESDE, 0, TimeToString(0));

  m_section_pending_table.DataType(AIDATATASKRUNER_TASK_TABLLE_HASTA, TYPE_DATETIME);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_HASTA, 0, TimeToString(0));

  m_section_pending_table.DataType(AIDATATASKRUNER_TASK_TABLLE_ESTADO, TYPE_STRING);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_ESTADO, 0, "");


// m_section_pending_table.SetImages(AIDATATASKRUNER_TASK_TABLLE_ESTADO, 0, g_taskruner_ai_dgen_main_images);
// m_section_pending_table.ChangeImage(AIDATATASKRUNER_TASK_TABLLE_ESTADO, 0, 2); // gris
// m_section_pending_table.DataType(AIDATATASKRUNER_TASK_TABLLE_MODIFICAR, TYPE_DATETIME);

//
  int arr_offset_imgeage_x[AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL];
  int arr_offset_imgeage_y[AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL];
  ArrayFill(arr_offset_imgeage_x, 0, AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL, 0);
  ArrayFill(arr_offset_imgeage_y, 0, AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL, 0);
  arr_offset_imgeage_y[AIDATATASKRUNER_TASK_TABLLE_ESTADO] = 5;
  arr_offset_imgeage_x[AIDATATASKRUNER_TASK_TABLLE_ESTADO] = 5;
  m_section_pending_table.ImageXOffset(arr_offset_imgeage_x);
  m_section_pending_table.ImageYOffset(arr_offset_imgeage_y);

//---
  int text_x_offset[AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL];
  ::ArrayInitialize(text_x_offset, 10);
  text_x_offset[AIDATATASKRUNER_TASK_TABLLE_ESTADO] += 15;
  m_section_pending_table.TextXOffset(text_x_offset);

// Width
//---
  int widths[AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL];

//--- Hagamos un resize debdio a que los nombres de los params y modelos aveces son GRADENS
  widths[AIDATATASKRUNER_TASK_TABLLE_SIMBOLO ] = 100;
  widths[AIDATATASKRUNER_TASK_TABLLE_SIMBOLO_FOLDER ] = 100;
  widths[AIDATATASKRUNER_TASK_TABLLE_TIMEFRAME ] = 125;
  widths[AIDATATASKRUNER_TASK_TABLLE_LABEL  ] = 150;
  widths[AIDATATASKRUNER_TASK_TABLLE_LABEL_ID ] = 125;
  widths[AIDATATASKRUNER_TASK_TABLLE_DESDE  ] = 175;
  widths[AIDATATASKRUNER_TASK_TABLLE_HASTA  ] = 175;
  widths[AIDATATASKRUNER_TASK_TABLLE_ESTADO  ] = 175;
  widths[AIDATATASKRUNER_TASK_TABLLE_MODIFICAR ] = 150;

//---
  m_section_pending_table.ColumnsWidth(widths);

//---
  if(!p.CreateTable(
       m_section_pending_table,
       main_window,
       0,
       general_tabs,
       tab_index,
       AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL,
       1,
       headers,
       x,
       y,
       0,
       0,
       false,
       false,
       right_gap + 5,
       left_gap + 5
     ))
   {
    AIDATATASKRUNER_ERROR_CREATION(m_section_pending_table);
    return false;
   }

//---
  return true;
 }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CTaskRunerAiTabDGenMain::OnChangeDate(const long lparam, const double dparam)
 {
//---
  if(m_tabs.SelectedTab() == TASKRUNERAIDGENMAIN_TAB_MAIN)
   {
    if(lparam == m_section_nt_dc_dt_start.Id())
     {
      m_runer.OnCurrentTask_ModifyDateStart(datetime(long(dparam)));
      return true;
     }
    if(lparam == m_section_nt_dc_dt_end.Id())
     {
      m_runer.OnCurrentTask_ModifyDateEnd(datetime(long(dparam)));
      return true;
     }
   }

//---
  return false;
 }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CTaskRunerAiTabDGenMain::OnChangeComBox(const long lparam)
 {
//---
  if(m_tabs.SelectedTab() == TASKRUNERAIDGENMAIN_TAB_MAIN)
   {
    if(lparam == m_section_nt_combox_timerame.Id())
     {
      m_runer.OnCurrentTask_ModifyTimeframe(g_arr_strtf_to_timeframes[m_section_nt_combox_timerame.GetListViewPointer().SelectedItemIndex()]);
      return true;
     }
   }

//---
  return false;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTaskRunerAiTabDGenMain::UpdateStateInTable(const int index, const int state)
 {
  m_section_pending_table.ChangeImage(AIDATATASKRUNER_TASK_TABLLE_ESTADO, index, state);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_ESTADO, index, g_taskruner_ai_dgen_main_images_label[state], 0);
  m_section_pending_table.Update(true);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CTaskRunerAiTabDGenMain::OnClickBottom(const long lparam)
 {
  switch(m_tabs.SelectedTab())
   {
    //---
    case TASKRUNERAIDGENMAIN_TAB_MAIN:
     {
      if(m_section_nt_buttom_add_task.Id() == lparam)
       {
        if(m_runer.OnCurrentTask_Add())
         {
          OnAddTask();
          MessageBox("Exito al añadir tarea", "Info", MB_OK | MB_ICONINFORMATION);
         }
        else
         {
          MessageBox(StringFormat("Fallo al añadir tarea\n%s", m_runer.m_last_error_msg), "Error", MB_OK | MB_ICONERROR);
         }
        return true;
       }

      //---
      if(m_section_bsic_buttom_load.Id() == lparam)
       {
        // Selecionanos
        if(FileSelectDialog("Escoje un archivo para cargar tareas", AIDATATASKRUNER_PATH_TASK, "TXT files (*.txt)|*.txt",
                            AIDATATASK_RUNNER_FSD_COMON_FLAG | FSD_FILE_MUST_EXIST, g_aitaskruner_arr_dyn, NULL) != 1)
         {
          MessageBox("Fallo al cargar tareas, no se ha selecionado un archivo", "Error", MB_OK | MB_ICONERROR);
          return true; // Acerto pero fallo
         }

        // Carga
        if(m_runer.LoadConfig(g_aitaskruner_arr_dyn[0]))
         {
          MessageBox("Exito al cargar config", "Info", MB_OK | MB_ICONINFORMATION);

          //--- Seteamos en los edtis
          m_section_bsic_edit_expert_path.SetValue(m_runer.ExperthPath());
          m_section_bsic_edit_expert_path.GetTextBoxPointer().Update(true);

          m_section_bsic_edit_main_folder.SetValue(m_runer.MainFolder());
          m_section_bsic_edit_main_folder.GetTextBoxPointer().Update(true);

          m_section_bsic_edit_progres_csv_file.SetValue(m_runer.ProgreesFile());
          m_section_bsic_edit_progres_csv_file.GetTextBoxPointer().Update(true);

          m_section_bsic_edit_files.SetValue(m_runer.MoveFiles());
          m_section_bsic_edit_files.GetTextBoxPointer().Update(true);
         }
        else
         {
          MessageBox(StringFormat("Fallo al cargar config\n%s", m_runer.m_last_error_msg), "Error", MB_OK | MB_ICONERROR);
         }
        return true;
       }

      //---
      if(m_section_bsic_buttom_save.Id() == lparam)
       {
        // Selecionanos
        if(FileSelectDialog("Escoje un archivo para guardar tareas", AIDATATASKRUNER_PATH_TASK, "TXT files (*.txt)|*.txt",
                            AIDATATASK_RUNNER_FSD_COMON_FLAG, g_aitaskruner_arr_dyn, NULL) != 1)
         {
          MessageBox("Fallo al cargar tareas, no se ha selecionado un archivo", "Error", MB_OK | MB_ICONERROR);
          return true; // Acerto pero fallo
         }

        // Carga
        if(m_runer.SaveConfig(g_aitaskruner_arr_dyn[0]))
         {
          MessageBox("Exito al guardar config", "Info", MB_OK | MB_ICONINFORMATION);
         }
        else
         {
          MessageBox(StringFormat("Fallo al cargar config\n%s", m_runer.m_last_error_msg), "Error", MB_OK | MB_ICONERROR);
         }
        return true;
       }

      //---
      return true;
     }

    //---
    case TASKRUNERAIDGENMAIN_TAB_TASK:
     {
      if(m_section_buttom_pending_load.Id() == lparam) // Catgamos de arhcivo y rellenamos tabla y rpersnentaicon interna
       {
        // Selecionanos
        if(FileSelectDialog("Escoje un archivo para cargar tareas", AIDATATASKRUNER_PATH_TASK, "CSV files (*.csv)|*.csv",
                            AIDATATASK_RUNNER_FSD_COMON_FLAG | FSD_FILE_MUST_EXIST, g_aitaskruner_arr_dyn, NULL) != 1)
         {
          MessageBox("Fallo al cargar tareas, no se ha selecionado un archivo", "Error", MB_OK | MB_ICONERROR);
          return true; // Acerto pero fallo
         }

        // Solo si hay existo al setear
        if(m_runer.SetTastByFile(g_aitaskruner_arr_dyn[0]))
         {
          const int t = m_runer.TaskSize();
          m_section_pending_table.TableSize(AIDATATASKRUNER_TASK_TABLLE_COL_TOTAL, t);

          for(int i = 0; i < t; i++)
           {
            const TaskTester task = m_runer.GetTaskByIndex(i);

            //---
            m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_SIMBOLO, i, task.symbol);
            m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_SIMBOLO_FOLDER, i, task.symbol_folder);
            m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_TIMEFRAME, i, TimeframeToStrShort(task.timeframe));
            m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_LABEL, i, task.label);
            m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_LABEL_ID, i, string(task.label_id));
            m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_DESDE, i, string(task.start_date));
            m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_HASTA,  i, string(task.end_date));
            m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_ESTADO, i, g_taskruner_ai_dgen_main_images_label[TASKRUNERAIDGENMAIN_IMG_LABEL_PENDIENTE]);
            m_section_pending_table.SetImages(AIDATATASKRUNER_TASK_TABLLE_ESTADO, i, g_taskruner_ai_dgen_main_images);
            m_section_pending_table.ChangeImage(AIDATATASKRUNER_TASK_TABLLE_ESTADO, i, TASKRUNERAIDGENMAIN_IMG_LABEL_PENDIENTE); // gris
           }
         }
        else
         {
          MessageBox(StringFormat("Fallo al cargar tareas\n%s", m_runer.m_last_error_msg), AIDATATASKRUNER_CAPTION, MB_OK | MB_ICONERROR);
         }
        return true;
       }
      else
        if(m_section_buttom_pending_save.Id() == lparam)
         {
          if(FileSelectDialog("Escoje un archivo para guardar tareas", AIDATATASKRUNER_PATH_TASK, "CSV files (*.csv)|*.csv",
                              AIDATATASK_RUNNER_FSD_COMON_FLAG, g_aitaskruner_arr_dyn, AIDATATASKRUNER_PATH_TASK) != 1)
           {
            MessageBox("Fallo al cargar tareas, no se ha selecionado un archivo", "Error", MB_OK | MB_ICONERROR);
            return true; // Acerto pero fallo
           }

          if(!m_runer.SaveAllTaskInFile(g_aitaskruner_arr_dyn[0]))
           {
            MessageBox(StringFormat("Fallo al guardar tareas\n%s", m_runer.m_last_error_msg), AIDATATASKRUNER_CAPTION, MB_OK | MB_ICONERROR);
           }
          return true;
         }
        else
          if(m_section_buttom_clean.Id() == lparam)
           {
            int arr[];
            const int t = m_runer.CleanAllTask(arr);
            if(t <= 0) // Internsmnte solo
             {
              MessageBox(StringFormat("Fallo al limpiar todas las tareas\n%s", m_runer.m_last_error_msg), AIDATATASKRUNER_CAPTION, MB_OK | MB_ICONERROR);
             }
            else
             {
              m_section_pending_table.DeleteMultipleRows(arr);
              return true;
             }
           }
          else
            if(m_section_buttom_execute_all.Id() == lparam)
             {
              int arr[];
              const int t = m_runer.RunAllTask(arr);
              if(t <= 0)
               {
                MessageBox(StringFormat("No hay tareas para ejeuctar\n%s", m_runer.m_last_error_msg), AIDATATASKRUNER_CAPTION, MB_OK | MB_ICONWARNING);
               }
              else
               {
                // actuliamos el estaod de los elemntos devueltos por out estos ahora estan en cola
                ActulizeTableAllTask(TASKRUNERAIDGENMAIN_IMG_LABEL_ENCOLA, arr, t);
               }
              return true;
             }
     }
   }

//---
  return false;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTaskRunerAiTabDGenMain::OnAddTask(void)
 {
//--- Base
  const TaskTester t = m_runer.CurrentTask(); // Ultimo (task current ya se reinicio)
  const uint total_rows = m_section_pending_table.RowsTotal();

//--- Escojemos el indice
  int idx;
  if(total_rows == 1 && m_section_pending_table.GetValue(AIDATATASKRUNER_TASK_TABLLE_SIMBOLO, 0) == "")
   {
    idx = 0;
   }
  else
   {
    // Hay mas de un row
    idx = (int)total_rows;
    m_section_pending_table.AddRow(idx);
   }

//
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_SIMBOLO, idx, t.symbol);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_SIMBOLO_FOLDER, idx, t.symbol_folder);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_TIMEFRAME, idx, TimeframeToStrShort(t.timeframe));
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_LABEL, idx, t.label);
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_LABEL_ID, idx, string(t.label_id));
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_DESDE, idx, TimeToString(t.start_date));
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_HASTA, idx, TimeToString(t.end_date));
  m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_ESTADO, idx, g_taskruner_ai_dgen_main_images_label[TASKRUNERAIDGENMAIN_IMG_LABEL_PENDIENTE]);
  m_section_pending_table.SetImages(AIDATATASKRUNER_TASK_TABLLE_ESTADO, idx, g_taskruner_ai_dgen_main_images);
  m_section_pending_table.ChangeImage(AIDATATASKRUNER_TASK_TABLLE_ESTADO, idx, TASKRUNERAIDGENMAIN_IMG_LABEL_PENDIENTE); // gris
  m_section_pending_table.Update(true);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTaskRunerAiTabDGenMain::ActulizeTableAllTask(const int index_s, int &rows[], int size)
 {
  for(int i = 0; i < size; i++)
   {
    m_section_pending_table.SetValue(AIDATATASKRUNER_TASK_TABLLE_ESTADO, rows[i], g_taskruner_ai_dgen_main_images_label[index_s]);
    m_section_pending_table.ChangeImage(AIDATATASKRUNER_TASK_TABLLE_ESTADO, rows[i], index_s); // gris
   }
  m_section_pending_table.Update(true);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool CTaskRunerAiTabDGenMain::OnTextEdit(const long lparam)
 {
//---
  if(m_tabs.SelectedTab() == TASKRUNERAIDGENMAIN_TAB_MAIN)
   {
    if(lparam == m_section_bsic_edit_files.Id())
     {
      m_runer.OnCurrentTask_ModifyConfigMoveFile(m_section_bsic_edit_files.GetValue());
      return true;
     }
    else
      if(lparam == m_section_bsic_edit_main_folder.Id())
       {
        m_runer.OnCurrentTask_ModifyConfigMainFolder(m_section_bsic_edit_main_folder.GetValue());
        return true;
       }
      else
        if(lparam == m_section_bsic_edit_expert_path.Id())
         {
          m_runer.OnCurrentTask_ModifyConfigExpertPath(m_section_bsic_edit_expert_path.GetValue());
          return true;
         }
        else
          if(lparam == m_section_bsic_edit_progres_csv_file.Id())
           {
            m_runer.OnCurrentTask_ModifyConfigProgresCsvFile(m_section_bsic_edit_progres_csv_file.GetValue());
            return true;
           }
          //---
          else
            if(lparam == m_section_nt_edit_symbol.Id())
             {
              m_runer.OnCurrentTask_ModifySimbolo(m_section_nt_edit_symbol.GetValue());
              return true;
             }
            else
              if(lparam == m_section_nt_edit_symbol_folder.Id())
               {
                m_runer.OnCurrentTask_ModifySimboloFolder(m_section_nt_edit_symbol_folder.GetValue());
                return true;
               }
              else
                if(lparam == m_section_nt_edit_label.Id())
                 {
                  m_runer.OnCurrentTask_ModifyLabel(m_section_nt_edit_label.GetValue());
                  return true;
                 }
                else
                  if(lparam == m_section_nt_edit_label_id.Id())
                   {
                    m_runer.OnCurrentTask_ModifyLabelId(int(m_section_nt_edit_label_id.GetValue()));
                    return true;
                   }
                  else
                    if(lparam == m_section_nt_edit_st_file.Id())
                     {
                      m_runer.OnCurrentTask_ModifySetFile(m_section_nt_edit_st_file.GetValue());
                      return true;
                     }
   }

//---
  return false;
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTaskRunerAiTabDGenMain::OnLenguajeChange(void)
 {
// const bool true = m_base_tab.SelectedTab() == m_base_tab_idx && m_base_tab.IsVisible();

//--- Update tab text
  string txt[TASKRUNERAIDGENMAIN_TAB_TOTAL] = {m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_tabs) + "_0"], m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_tabs) + "_1"]};
  const int t = m_tabs.TabsTotal();
  for(int i = 0; i < t; i++)
   {
    m_tabs.Text(i, txt[i]);
   }
  m_tabs.Update();

//---
  const int idx = m_tabs.SelectedTab();
  UpdateTextMain();
  UpdateTextTask();
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTaskRunerAiTabDGenMain::UpdateTextTask()
 {
// Buttons
  m_section_buttom_pending_load.LabelText(m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_buttom_pending_load)]);
  m_section_buttom_pending_load.Update(true);

  m_section_buttom_pending_save.LabelText(m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_buttom_pending_save)]);
  m_section_buttom_pending_save.Update(true);

  m_section_buttom_execute_all.LabelText(m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_buttom_execute_all)]);
  m_section_buttom_execute_all.Update(true);

  m_section_buttom_clean.LabelText(m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_buttom_clean)]);
  m_section_buttom_clean.Update(true);

// Headers de la tabla
  const string header_str = m_language[AIDATATASKRUNNERL_COMPONENT_NAME(m_section_pending_table) + "_header"];
  string headers[];
  if(StrTo::CstArray(headers, header_str, '|', true))
   {
    const int cols = (int)m_section_pending_table.ColumnsTotal();
    for(int i = 0; i < cols; i++)
     {
      m_section_pending_table.SetHeaderText(i, headers[i]);
     }
    m_section_pending_table.Update(true);
   }
  else
   {
    LogError("Fallo al hacer split str array en table header", FUNCION_ACTUAL);
   }
 }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
template <typename TObject>
void CTaskRunerAiTabDGenMain::ResizeTElement(TObject& obj, const string key, int width_element)
 {
  obj.LabelText(m_language[key]);
  obj.Tooltip(m_language.Tooltip(key));
  const string texto = obj.LabelText();
  obj.CanvasFontSet();
  const int width = obj.m_canvas.TextWidth(texto);

// Ancho texto | Extra separacion entre texto y obj element| Ancho de elemento
  obj.XSize(width + AIDATATASKRUNER_MAINTAB_LABEL_X_PAD + width_element);
  obj.Update(true);
 }

//+------------------------------------------------------------------+
template <typename TObject>
void CTaskRunerAiTabDGenMain::UpdateTBasic(TObject& obj, const string key, bool has_tool = true)
 {
  obj.LabelText(m_language[key]);
  if(has_tool)
    obj.Tooltip(m_language.Tooltip(key));
  obj.Update(true);
 }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTaskRunerAiTabDGenMain::UpdateTextMain()
 {
//--- Basic config label
  UpdateTBasic(m_label_basic_config, AIDATATASKRUNNERL_COMPONENT_NAME(m_label_basic_config), false);
  UpdateTBasic(m_section_bsic_buttom_load, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_buttom_load));
  UpdateTBasic(m_section_bsic_buttom_save, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_buttom_save));

//--- Basic config edits
  ResizeTElement(m_section_bsic_edit_files, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_edit_files), 300);
  ResizeTElement(m_section_bsic_edit_expert_path, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_edit_expert_path), 300);
  ResizeTElement(m_section_bsic_edit_progres_csv_file, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_edit_progres_csv_file), 300);
  ResizeTElement(m_section_bsic_edit_main_folder,  AIDATATASKRUNNERL_COMPONENT_NAME(m_section_bsic_edit_main_folder), 250);


//--- New task label
  UpdateTBasic(m_label_new_task, AIDATATASKRUNNERL_COMPONENT_NAME(m_label_new_task), false);

//--- Resize new task edits y combox
  ResizeTElement(m_section_nt_edit_symbol, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_edit_symbol), 150);
  ResizeTElement(m_section_nt_edit_symbol_folder, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_edit_symbol_folder), 150);
  ResizeTElement(m_section_nt_combox_timerame, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_combox_timerame), 150);
  ResizeTElement(m_section_nt_edit_label, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_edit_label), 200);
  ResizeTElement(m_section_nt_edit_label_id, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_edit_label_id), 175);
  ResizeTElement(m_section_nt_dc_dt_start, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_dc_dt_start), 100);
  ResizeTElement(m_section_nt_dc_dt_end, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_dc_dt_end), 100);
  ResizeTElement(m_section_nt_edit_st_file, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_edit_st_file), 200);

//--- Button final
  UpdateTBasic(m_section_nt_buttom_add_task, AIDATATASKRUNNERL_COMPONENT_NAME(m_section_nt_buttom_add_task));
 }

//+------------------------------------------------------------------+
#endif // AIDATATASKRUNER_UI_DATAGENERATIONTAB_BASE_MQH

//+------------------------------------------------------------------+