//+---------------------------------------------------------------------------+
//|                                                          EQ Dashboard.mq5 |
//|                                            Copyright 2025, by Ivan Butko  |
//|                                https://www.mql5.com/ru/users/capitalplus  |
//+---------------------------------------------------------------------------+
//|            Historical equity of virtual positions with dynamic            |
//|                           interactive dashboard                           |
//|---------------------------------------------------------------------------|
//| PURPOSE:                                                                  |
//| - Calculate virtual equity of a portfolio                                 |
//| - Provide a dynamic, interactive dashboard for managing symbols,          |
//|   volumes, and directions                                                 |
//| - Facilitate identification of volatile-flat structures                   |
//| - Analyze spread trading efficiency                                       |
//| - Help determine entry/exit points for equity trading                     |
//|                                                                           |
//| OPERATION PRINCIPLE:                                                      |
//| - Users activate/deactivate symbols via dashboard buttons                 |
//| - Adjust volumes and trade directions interactively                       |
//| - Equity line dynamically recalculates based on current selections        |
//| - Cumulative profit/loss from all active positions is displayed           |
//| - Dashboard provides quick control of settings and visualization          |
//|                                                                           |
//| HOW TO USE:                                                               |
//| 1. Use the dashboard to select symbols and set buy/sell directions        |
//| 2. Adjust lot sizes using volume controls in the dashboard                |
//| 3. Configure history depth and initial balance in inputs                  |
//| 4. Monitor historical virtual equity line and adjust parameters as needed |
//+---------------------------------------------------------------------------+

#property copyright "Copyright © 2025, iboot@yandex.ru, https://t.me/bootelega"
#property link      "https://www.mql5.com/ru/users/capitalplus/seller"
#property version   "1.1"
#property strict

//--- Indicator description ------------------------------------------
#property description "Historical virtual equity indicator with dynamic dashboard"
#property description "Purpose:"
#property description "- Model portfolio behavior with interactive symbol management"
#property description "- Visualize combined instrument movements with adjustable settings"
#property description "Applications:"
#property description "- Identify volatility-flat patterns for spread and equity trading"
#property description "- Evaluate spread and equity trading strategies using visual feedback"
#property description "- Dynamic control of portfolio components via on-chart dashboard"

#property indicator_separate_window
#property indicator_buffers 1
#property indicator_plots    1
#property indicator_type1    DRAW_LINE
#property indicator_color1   clrDodgerBlue
#property indicator_width1   1
#property indicator_label1   "Virtual Equity"

//+------------------------------------------------------------------+
//| === Calculation Settings ===                                     |
//+------------------------------------------------------------------+
input group " -------- Calculation Settings -------- "
input int    Bars_to_calculate = 1000;     // Number of bars to calculate
input double Initial_balance   = 0;        // Initial virtual balance

//+------------------------------------------------------------------+
//| === Dashboard Positioning Parameters ===                         |
//+------------------------------------------------------------------+
input group " -------- Dashboard Positioning Parameters -------- "
input int Dashboard_Base_X = 50;           // Base X coordinate
input int Dashboard_Base_Y = 50;           // Base Y coordinate

// === Symbols ===
input group " -------- Symbols -------- "
input color  Sym_ActiveClr        = C'102,187,106';  // Active button color (bright grass green)
input color  Sym_InactiveClr      = C'240,243,248';  // Inactive button background (very light)
input color  Sym_TextClr          = C'36,42,56';     // Button text color
input int    SymbolBut_Height     = 25;              // Button height
input int    FntSize_SymbolButs   = 10;              // Button font size

// === Buy/Sell Buttons ===
input group " -------- Buy/Sell Buttons -------- "
input color  BuySell_BuyClr       = C'100,160,210';  // Buy button background color (light steel blue)
input color  BuySell_SellClr      = C'255,138,128';  // Sell button background color (light scarlet)
input color  BuySell_TextClr      = C'36,42,56';     // Buy/Sell button text color
input int    BuySellBut_Width     = 40;              // Button width
input int    BuySellBut_Height    = 25;              // Button height
input string BuySell_BuyText      = "BUY";           // Buy button text
input string BuySell_SellText     = "SELL";          // Sell button text
input int    FntSize_BuySellButs  = 10;              // Button font size

// === Volume Management Buttons ===
input group " -------- Volume Management Buttons -------- "
input color  VolMng_ButClr        = C'240,243,248';  // Background color (light gray-blue)
input color  VolMng_TextClr       = C'36,42,56';     // Text color
input int    VolMng_ButWidth      = 20;              // Button width
input int    VolMng_ButHeight     = 25;              // Button height
input string VolMng_LotMns01Text  = "«";             // Lot decrease by 0.1 button text
input string VolMng_LotMns001Text = "‹";             // Lot decrease by 0.01 button text
input string VolMng_LotPls001Text = "›";             // Lot increase by 0.01 button text
input string VolMng_LotPls01Text  = "»";             // Lot increase by 0.1 button text
input int    FntSize_VolButs      = 15;              // Font size

// === Input Field ===
input group " -------- Input Field -------- "
input int    LotInput_Width       = 50;              // Input field width
input int    LotInput_Height      = 25;              // Input field height
input color  InputField_BgdClr    = C'245,245,245';  // Background color
input color  InputField_TextClr   = C'36,42,56';     // Text color
input int    FntSize_InputField   = 11;              // Font size

// === Columns Background ===
input group " -------- Columns Background -------- "
input color  Bgd_Clr             = C'220,225,230';  // Background color (soft bluish)
input color  Bgd_BrdClr          = C'180,185,195';  // Border color (slightly darker)
input int    Bgd_Width           = 280;             // Width
input int    Bgd_Height          = 80;              // Height

// === Dashboard Header ===
input group " -------- Dashboard Header -------- "
input color  Hdr_BgdClr           = C'245,247,250';  // Background color
input color  Hdr_BrdClr           = C'220,224,230';  // Border color
input string Hdr_Title            = "EQ";            // Title text
input color  Hdr_TitleClr         = C'40,44,52';     // Title color
input int    Hdr_Width            = 280;             // Width
input int    Hdr_Height           = 25;              // Height
input int    FntSize_HdrAndTopButs = 10;             // Font size for header and top buttons

// === Reset Settings Button ===
input group " -------- Reset Settings Button -------- "
input color  RstSet_ButClr        = C'255,138,128';  // Background color (light red)
input color  RstSet_TextClr       = C'255,255,255';  // Text color (white)
input int    RstAllBut_Width      = 20;              // Width
input int    RstAllBut_Height     = 20;              // Height
input string RstAllBut_Text       = "R";             // Text

// === Theme Switch Button ===
input group " -------- Theme Switch Button -------- "
input color  ThemeSwitch_ButClr   = C'144,176,160';  // Background color (light moss green)
input color  ThemeSwitch_TextClr  = C'255,255,255';  // Text color (white)
input int    ThemeSwitchBut_Width = 20;              // Width
input int    ThemeSwitchBut_Height= 20;              // Height
input string ThemeSwitchBut_Text  = "☼";             // Text

// === Dashboard Scaling Buttons ===
input group " -------- Dashboard Scaling Buttons -------- "
input color  SclPlsBut_Clr        = C'170,210,240';  // Background color (light blue)
input color  SclPlsBut_TextClr    = C'36,42,56';     // Text color
input int    SclPlsBut_Width      = 20;              // Width
input int    SclPlsBut_Height     = 20;              // Height
input string SclPlsBut_Text       = "+";             // Text

input color  SclMnsBut_Clr        = C'170,210,240';  // Background color (light blue)
input color  SclMnsBut_TextClr    = C'36,42,56';     // Text color
input int    SclMnsBut_Width      = 20;              // Width
input int    SclMnsBut_Height     = 20;              // Height
input string SclMnsBut_Text       = "–";             // Text

input int    FntSize_SclButs      = 10;              // Font size

// === Column Management Buttons ===
input group " -------- Column Management Buttons -------- "
input color  ClnMng_ButClr        = C'180,190,210';  // Background color (light gray-purple)
input color  ClnMng_TextClr       = C'36,42,56';     // Text color
input int    DcrClnsBut_Width     = 20;              // Decrease columns button width
input int    DcrClnsBut_Height    = 20;              // Decrease columns button height
input string DcrClnsBut_Text      = "<";             // Decrease columns button text
input int    IcrClnsBut_Width     = 20;              // Increase columns button width
input int    IcrClnsBut_Height    = 20;              // Increase columns button height
input string IcrClnsBut_Text      = ">";             // Increase columns button text

// === Collapse/Expand Button ===
input group " -------- Collapse/Expand Button -------- "
input color  Hid_ButClr           = C'255,236,140';  // Background color (light yellow)
input color  Hid_TextClr          = C'36,42,56';     // Text color
input int    HidBut_Width         = 20;              // Width
input int    HidBut_Height        = 20;              // Height
input string Hid_CollapseText     = "—";             // Text when collapsed
input string Hid_ExpandText       = "+";             // Text when expanded

// === Close (Delete Indicator) Button ===
input group " -------- Close (Delete Indicator) Button -------- "
input color  CloseDelete_ButClr   = C'255,138,128';  // Background color (light red)
input color  CloseDelete_TextClr  = C'255,255,255';  // Text color (white)
input int    CloseDeleteBut_Width = 20;              // Width
input int    CloseDeleteBut_Height= 20;              // Height
input string CloseDeleteBut_Text  = "X";             // Text



//+------------------------------------------------------------------+
//| Structure to simplify UI state management                         |
//+------------------------------------------------------------------+
struct SymbolState
{
    bool   active;           // Symbol active state
    bool   is_sell;          // Sell or buy direction
    double lot_value;        // Lot size
    string symbol_name;      // Symbol name

    SymbolState() : active(false), is_sell(false), lot_value(0.1) {}
};

//+------------------------------------------------------------------+
//| Global positioning constants                                     |
//+------------------------------------------------------------------+
const int Cln_Width  = 300;  // Width of a column (used for X offset positioning)
const int Row_Height = 30;   // Height of a row (used for Y offset positioning)

//+------------------------------------------------------------------+
//| Theme switching                                                  |
//+------------------------------------------------------------------+
enum ThemeType { THEME_DARK = 0, THEME_LIGHT = 1, THEME_CUSTOM = 2 };
ThemeType g_theme = THEME_CUSTOM;  // Default theme is custom

//+------------------------------------------------------------------+
//| UI variables                                                     |
//+------------------------------------------------------------------+
const string PFX                = "Dashboard_";  // Prefix for UI object names
int          g_clnCnt           = 1;            // Number of columns currently displayed
bool         g_panelExpanded    = true;          // Dashboard panel expansion flag
bool         g_manualDeletion   = false;         // Manual indicator deletion flag
string       g_indName;                          // Indicator name string
SymbolState  g_symSts[];                        // Array holding state for each symbol
int          g_ttlSym;                          // Total number of symbols available
double       g_scl              = 1.0;           // Current UI scaling factor
string       g_hdrTitle         = "EQ";          // Header title string
string       g_loadHistoryLabel = "EQ_LoadHistoryLabel"; // Label for loading history

// Auto-calculated symbol button width
int          g_symButW          = 100;

// Calculation buffers and flags
double       E_buf[];                           // Buffer for equity values
double       g_initlPrs[];                      // Array of initial prices
int          g_dir[];                           // Trade direction: 1=buy, -1=sell
bool         g_startFlag        = true;          // First run flag
bool         g_startChartFlag   = true;          // Chart redraw trigger flag


//+------------------------------------------------------------------+
//| Initialization function: sets up indicator and UI               |
//+------------------------------------------------------------------+
int OnInit()
{
    // Get the name of this indicator program
    g_indName = MQL5InfoString(MQL5_PROGRAM_NAME);

    // Get total number of symbols available in Market Watch
    g_ttlSym = SymbolsTotal(true);

    // Resize symbol state array to total symbols count
    ArrayResize(g_symSts, g_ttlSym);

    // Initialize symbol names in the symbol state array
    InitializeSymbolNames();

    // Calculate button width for symbols dynamically based on symbol name lengths
    CalcSymbolButWidth();

    // Load saved states from previous sessions (active symbols, lots, directions)
    LoadStates();

    // Apply colors according to selected theme
    ApplyThemeColors();

    // Create the user interface elements (buttons, labels, etc)
    CreateUI();

    // Set timer event to trigger every 100 milliseconds for UI updates
    EventSetMillisecondTimer(100);

    // Initialize calculation buffers to hold initial prices and directions
    ArrayResize(g_initlPrs, g_ttlSym);
    ArrayResize(g_dir, g_ttlSym);

    // Bind the indicator buffer to E_buf for plotting virtual equity line
    SetIndexBuffer(0, E_buf, INDICATOR_DATA);

    // Set buffer to be indexed as series (time series with index 0 as latest bar)
    ArraySetAsSeries(E_buf, true);

    // Set number of decimal digits for indicator values
    IndicatorSetInteger(INDICATOR_DIGITS, 2);

    return(INIT_SUCCEEDED);  // Initialization successful
}

//+------------------------------------------------------------------+
//| Deinitialization function: cleans up on indicator removal       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    // Stop the timer event
    EventKillTimer();

    // If indicator was not deleted manually, save states and remove UI objects
    if (!g_manualDeletion)
    {
        SaveStates();       // Save current symbol states to persistent storage
        DeleteAllObjects(); // Remove all created UI objects from chart
    }

    // Remove loading history label if it exists
    if (ObjectFind(0, g_loadHistoryLabel) != -1)
        ObjectDelete(0, g_loadHistoryLabel);

    // Redraw chart to update display after cleanup
    ChartRedraw();
}

//+------------------------------------------------------------------+
//| Calculation entry point: called on each new tick or bar update   |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[],
                const double &open[], const double &high[], const double &low[],
                const double &close[], const long &tick_volume[], const long &volume[],
                const int &spread[])
{
    // Perform main calculation and UI update
    Main();

    // Return total bars processed to MetaTrader engine
    return(rates_total);
}

//+------------------------------------------------------------------+
//| Timer event handler: called every 100 ms to update UI           |
//+------------------------------------------------------------------+
void OnTimer()
{
    // Checks for new Market Watch symbols and adds them to the dashboard without resetting settings.
    SyncAndRebuildDashboard();
    // Run main update logic on timer event
    Main();
}

//+------------------------------------------------------------------+
//| Main calculation and update function                             |
//+------------------------------------------------------------------+
void Main()
{
    // Update the header title text on the dashboard
    UpdateHdrTitle();

    // Arrays to hold active symbol info: names, directions, and lot sizes
    string actSym[];
    int actDir[];
    double actLot[];

    // Retrieve currently active symbols and their parameters
    GetActiveSymbols(actSym, actDir, actLot);

    // Count how many symbols are active
    int actCnt = ArraySize(actSym);

    // If no active symbols, clear equity buffer and exit
    if(actCnt == 0)
    {
        ArrayInitialize(E_buf, 0.0);  // Reset equity buffer to zero
        return;
    }

    int start = 0; // Starting bar index for calculation

    // On first run, initialize buffers and read initial prices
    if(g_startFlag)
    {
        ArrayInitialize(E_buf, EMPTY_VALUE);  // Mark equity buffer as empty initially

        // Resize arrays to active symbols count
        ArrayResize(g_initlPrs, actCnt);
        ArrayResize(g_dir, actCnt);

        // Loop through each active symbol
        for(int i = 0; i < actCnt; i++)
        {
            // Validate symbol availability and history
            if(!CheckSymbol(actSym[i]))
                return;  // Exit if symbol data is not ready

            // Store trade direction for symbol (1 for buy, -1 for sell)
            g_dir[i] = actDir[i];

            // Store initial opening price at Bars_to_calculate offset for symbol
            g_initlPrs[i] = iOpen(actSym[i], _Period, Bars_to_calculate);
        }

        // Start calculation from Bars_to_calculate bars ago
        start = Bars_to_calculate;

        // Clear the start flag after initialization
        g_startFlag = false;
    }
    else
    {
        // On subsequent runs, start from the latest bar (index 0)
        start = 0;

        // If chart redraw is pending, trigger it once
        if(g_startChartFlag)
        {
            ChartRedraw();
            g_startChartFlag = false;
        }
    }

    // Loop backwards through bars from start to 0 (latest bar)
    for(int i = start; i >= 0; i--)
    {
        double equity = Initial_balance;  // Reset equity to initial balance at each bar

        // Loop through all active symbols to calculate equity contribution
        for(int j = 0; j < actCnt; j++)
        {
            string symbol = actSym[j];  // Current symbol name

            // Get close price for symbol at bar i
            double curClose = iClose(symbol, _Period, i);

            // Skip if close price is zero (invalid data)
            if(curClose == 0)
                continue;

            // Calculate price change in points from initial price
            double priceChange = (curClose - g_initlPrs[j]) / SymbolInfoDouble(symbol, SYMBOL_POINT);

            // Calculate point value for symbol (monetary value per point)
            double pointValue = CalculatePointValue(symbol);

            // Update equity by adding price change * direction * lot size * point value
            equity += priceChange * g_dir[j] * actLot[j] * pointValue;
        }

        // Store calculated equity value in buffer for plotting
        E_buf[i] = equity;

        // If first equity value is empty, redraw chart to update display
        if(E_buf[0] == EMPTY_VALUE)
            ChartRedraw();
    }
}

//+------------------------------------------------------------------+
//| Symbol validation: checks if symbol is available and has history|
//+------------------------------------------------------------------+
bool CheckSymbol(string symbol)
{
    // Try to select symbol in Market Watch, returns false if symbol not found
    if(!SymbolSelect(symbol, true))
    {
        Print(symbol + " - error: symbol not found in Market Watch!");
        return false;
    }

    // Check if close price at Bars_to_calculate is valid (non-zero)
    if(iClose(symbol, PERIOD_CURRENT, Bars_to_calculate) <= 0)
    {
        // Show loading message for symbol history
        Comment("LOADING HISTORY: " + symbol);
        return false;
    }

    // Symbol is valid and has sufficient history
    return true;
}

//+------------------------------------------------------------------+
//| Calculate point value for symbol: monetary value per symbol point|
//+------------------------------------------------------------------+
double CalculatePointValue(string symbol)
{
    // Get tick value in account currency for the symbol
    double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);

    // Get tick size (minimum price change) for the symbol
    double tickSize = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);

    // Get point size for the symbol (usually equal to tick size or fraction)
    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);

    // Calculate and return monetary value of one point move for the symbol
    return tickValue * (point / tickSize);
}





































//+--------------------------------------------------------------------+
//| ========================= DASHBOARD ============================== |
//+--------------------------------------------------------------------+

color Hdr_BgdClr_work, Hdr_BrdClr_work, Hdr_TitleClr_work;
color RstSet_ButClr_work, RstSet_TextClr_work;
color SclPlsBut_Clr_work, SclPlsBut_TextClr_work, SclMnsBut_Clr_work, SclMnsBut_TextClr_work;
color ClnMng_ButClr_work, ClnMng_TextClr_work;
color Hid_ButClr_work, Hid_TextClr_work;
color CloseDelete_ButClr_work, CloseDelete_TextClr_work;
color Sym_ActiveClr_work, Sym_InactiveClr_work, Sym_TextClr_work;
color BuySell_BuyClr_work, BuySell_SellClr_work, BuySell_TextClr_work;
color VolMng_ButClr_work, VolMng_TextClr_work;
color InputField_BgdClr_work, InputField_TextClr_work;
color Bgd_Clr_work, Bgd_BrdClr_work;
color ThemeSwitch_ButClr_work, ThemeSwitch_TextClr_work;

int Sht_HdrBg_X = 0;
int Sht_HdrBg_Y = 0;

int Sht_HdrTitle_X = 5;
int Sht_HdrTitle_Y = 5;

int Sht_RstAllBut_X = 117;
int Sht_RstAllBut_Y = 2;

int Sht_ThemeSwitchBut_X = 137;
int Sht_ThemeSwitchBut_Y = 2;

int Sht_SclPlsBut_X = 157;
int Sht_SclPlsBut_Y = 2;

int Sht_SclMnsBut_X = 177;
int Sht_SclMnsBut_Y = 2;

int Sht_DcrClnsBut_X = 197;
int Sht_DcrClnsBut_Y = 2;

int Sht_IcrClnsBut_X = 217;
int Sht_IcrClnsBut_Y = 2;

int Sht_HidBut_X = 237;
int Sht_HidBut_Y = 2;

int Sht_DltIndBut_X = 257;
int Sht_DltIndBut_Y = 2;

int Sht_ClnBgd_X = 0;
int Sht_ClnBgd_Y = 0;

int Sht_SymbolBut_X = 5;
int Sht_SymbolBut_Y = -5;

int Sht_BuySellBut_X = 80;
int Sht_BuySellBut_Y = 0;

int Sht_LotMns01But_X = 130;
int Sht_LotMns01But_Y = 0;

int Sht_LotMns001But_X = 150;
int Sht_LotMns001But_Y = 0;

int Sht_LotInput_X = 175;
int Sht_LotInput_Y = 0;

int Sht_LotPls001But_X = 230;
int Sht_LotPls001But_Y = 0;

int Sht_LotPls01But_X = 250;
int Sht_LotPls01But_Y = 0;

void CalcSymbolButWidth()
{
    int maxLen = 0;
    for(int i=0; i<g_ttlSym; i++)
    {
        int len = StringLen(g_symSts[i].symbol_name);
        if(len > maxLen)
            maxLen = len;
    }
    g_symButW = 8 * maxLen + 24;
    if(g_symButW < 60) g_symButW = 60;
    if(g_symButW > 200) g_symButW = 200; 
}


void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
    if(id != CHARTEVENT_OBJECT_CLICK && id != CHARTEVENT_OBJECT_ENDEDIT) return;

    bool needRecalc = false;

    if(id == CHARTEVENT_OBJECT_CLICK)
    {
        SetButState(sparam, true);
        needRecalc = ProcessClick(sparam);
        SetButState(sparam, false);
    }
    else if(id == CHARTEVENT_OBJECT_ENDEDIT)
    {
        needRecalc = ProcessInputEdit(sparam);
    }

    if(needRecalc)
    {
        g_startFlag = true;
        Main();
        ChartRedraw();
    }
}

bool ProcessClick(string objName)
{
    if(objName == PFX + "RstAllBut")      {        RstAllStates();        return true;    }
    if(objName == PFX + "ThemeSwitchBut") {        SwitchTheme();          return false;      }
    if(objName == PFX + "SclPlsBut")      {        g_scl += 0.1;        if(g_scl > 3.0) g_scl = 3.0;        RecreateUI();        return false;    }
    if(objName == PFX + "SclMnsBut")      {        g_scl -= 0.1;        if(g_scl < 0.5) g_scl = 0.5;        RecreateUI();        return false;    }
    if(objName == PFX + "IcrClnsBut")     {        ChangeClnCount(g_clnCnt + 1);        return false;    }
    if(objName == PFX + "DcrClnsBut")     {        ChangeClnCount(MathMax(1, g_clnCnt - 1));        return false;    }    
    if(objName == PFX + "HidBut")         {        TogglePanel();        return false;    }
    if(objName == PFX + "DltIndBut")      {        DltInd();        return false;    }

    return ProcessSymbolClick(objName);
}

void RecreateUI()
{
    DeleteAllObjects(); 
    CreateUI();    
    ChartRedraw();      
}

bool ProcessSymbolClick(string objName)
{
    for(int i = 0; i < g_ttlSym; i++)
    {
        string symName = g_symSts[i].symbol_name;

        if(objName == PFX + "Symbol_" + symName)
        {
            g_symSts[i].active = !g_symSts[i].active;
            UpdateSymbolBut(i);
            SaveStates();
            return true;
        }

        if(objName == PFX + "BuySell_" + symName)
        {
            g_symSts[i].is_sell = !g_symSts[i].is_sell;
            UpdateBuySellBut(i);
            SaveStates();
            if (g_symSts[i].active) return true;
            else return false;
        }

        string lotButs[] = {"Lot1_", "Lot2_", "Lot3_", "Lot4_"};
        double lotChanges[] = {-0.1, -0.01, 0.01, 0.1};

        for(int j = 0; j < 4; j++)
        {
            if(objName == PFX + lotButs[j] + symName)
            {
                g_symSts[i].lot_value = MathMax(0, g_symSts[i].lot_value + lotChanges[j]);
                UpdateLotInput(i);
                SaveStates();
                if (g_symSts[i].active) return true;
                  else return false;
            }
        }
    }
    return false;
}

bool ProcessInputEdit(string objName)
{
    for(int i = 0; i < g_ttlSym; i++)
    {
        if(objName == PFX + "LotInput_" + g_symSts[i].symbol_name)
        {
            g_symSts[i].lot_value = StringToDouble(ObjectGetString(0, objName, OBJPROP_TEXT));
            SaveStates();
            return true;
        }
    }
    return false;
}

void CreateUI()
{
    CreateHdrPanel();
    CreateTopButs();
    if(g_panelExpanded)
    {
        CreateClnBgds();
        CreateSymbolButs();
        ApplyStates();
    }
}

void CreateHdrPanel()
{
    CreateBgd(PFX + "HdrBg", Dashboard_Base_X + Sht_HdrBg_X, Dashboard_Base_Y + Sht_HdrBg_Y, Hdr_Width, Hdr_Height, Hdr_BgdClr_work, Hdr_BrdClr_work);

    string name = PFX + "HdrTitle";
    int relX = Sht_HdrTitle_X;
    int relY = Sht_HdrTitle_Y;
    int sclX = Dashboard_Base_X + int(relX * g_scl);
    int sclY = Dashboard_Base_Y + int(relY * g_scl);
    int sclFntSize = MathMax(8, int(FntSize_HdrAndTopButs * g_scl));

    if(ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0))
    {
        ObjectSetInteger(0, name, OBJPROP_XDISTANCE, sclX);
        ObjectSetInteger(0, name, OBJPROP_YDISTANCE, sclY);
        ObjectSetInteger(0, name, OBJPROP_FONTSIZE, sclFntSize);
        ObjectSetInteger(0, name, OBJPROP_COLOR, Hdr_TitleClr_work);
        ObjectSetInteger(0, name, OBJPROP_CORNER, 0);
        ObjectSetString(0, name, OBJPROP_TEXT, g_hdrTitle);
        ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
        ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
        ObjectSetInteger(0, name, OBJPROP_ZORDER, 0);
    }
}

void CreateTopButs()
{
    struct TopBtn { string name, text; int x, y, w, h; color bg, fg; int fontSize; };
    TopBtn buttons[] = {
        {"DcrClnsBut", DcrClnsBut_Text,
            Dashboard_Base_X + Sht_DcrClnsBut_X,
            Dashboard_Base_Y + Sht_DcrClnsBut_Y,
            DcrClnsBut_Width, DcrClnsBut_Height,
            ClnMng_ButClr_work, ClnMng_TextClr_work,
            FntSize_HdrAndTopButs},
            
        {"ThemeSwitchBut", ThemeSwitchBut_Text, 
            Dashboard_Base_X + Sht_ThemeSwitchBut_X, 
            Dashboard_Base_Y + Sht_ThemeSwitchBut_Y, 
            ThemeSwitchBut_Width, ThemeSwitchBut_Height, 
            ThemeSwitch_ButClr_work, ThemeSwitch_TextClr_work, 
            FntSize_HdrAndTopButs},

        {"IcrClnsBut", IcrClnsBut_Text,
            Dashboard_Base_X + Sht_IcrClnsBut_X,
            Dashboard_Base_Y + Sht_IcrClnsBut_Y,
            IcrClnsBut_Width, IcrClnsBut_Height,
            ClnMng_ButClr_work, ClnMng_TextClr_work,
            FntSize_HdrAndTopButs},

        {"RstAllBut", RstAllBut_Text,
            Dashboard_Base_X + Sht_RstAllBut_X,
            Dashboard_Base_Y + Sht_RstAllBut_Y,
            RstAllBut_Width, RstAllBut_Height,
            RstSet_ButClr_work, RstSet_TextClr_work,
            FntSize_HdrAndTopButs},

        // Кнопка "+" масштабирования
        {"SclPlsBut", SclPlsBut_Text,
            Dashboard_Base_X + Sht_SclPlsBut_X,
            Dashboard_Base_Y + Sht_SclPlsBut_Y,
            SclPlsBut_Width, SclPlsBut_Height,
            SclPlsBut_Clr_work, SclPlsBut_TextClr_work,
            FntSize_SclButs},

        // Кнопка "–" масштабирования
        {"SclMnsBut", SclMnsBut_Text,
            Dashboard_Base_X + Sht_SclMnsBut_X,
            Dashboard_Base_Y + Sht_SclMnsBut_Y,
            SclMnsBut_Width, SclMnsBut_Height,
            SclMnsBut_Clr_work, SclMnsBut_TextClr_work,
            FntSize_SclButs},

        {"HidBut", g_panelExpanded ? Hid_CollapseText : Hid_ExpandText,
            Dashboard_Base_X + Sht_HidBut_X,
            Dashboard_Base_Y + Sht_HidBut_Y,
            HidBut_Width, HidBut_Height,
            Hid_ButClr_work, Hid_TextClr_work,
            FntSize_HdrAndTopButs},

        {"DltIndBut", CloseDeleteBut_Text,
            Dashboard_Base_X + Sht_DltIndBut_X,
            Dashboard_Base_Y + Sht_DltIndBut_Y,
            CloseDeleteBut_Width, CloseDeleteBut_Height,
            CloseDelete_ButClr_work, CloseDelete_TextClr_work,
            FntSize_HdrAndTopButs}
    };

    for(int i = 0; i < ArraySize(buttons); i++)
    {
        CreateBut(PFX + buttons[i].name,
                     buttons[i].x, buttons[i].y,
                     buttons[i].w, buttons[i].h,
                     buttons[i].bg, buttons[i].fg,
                     buttons[i].text, buttons[i].fontSize);
    }
}

void CreateSymbolButs()
{
    for(int i = 0; i < g_ttlSym; i++)
    {
        string symName = g_symSts[i].symbol_name;
        int col = i % g_clnCnt;
        int row = i / g_clnCnt;
        int xShift = col * Cln_Width;
        int yShift = row * Row_Height;

        int baseX = Dashboard_Base_X + xShift + Sht_SymbolBut_X;
        int baseY = Dashboard_Base_Y + Hdr_Height + 10 + yShift + Sht_SymbolBut_Y;

        color symbolBg = g_symSts[i].active ? Sym_ActiveClr : Sym_InactiveClr;
        int butW = g_symButW;
        int butH = SymbolBut_Height;

        CreateBut(PFX + "Symbol_" + symName, baseX, baseY, butW, butH, symbolBg, Sym_TextClr_work, symName, FntSize_SymbolButs);

        // Кнопка Buy/Sell
        color buySellBg = g_symSts[i].is_sell ? BuySell_SellClr_work : BuySell_BuyClr_work;
        string buySellText = g_symSts[i].is_sell ? BuySell_SellText : BuySell_BuyText;
        CreateBut(PFX + "BuySell_" + symName,
                     baseX + Sht_BuySellBut_X, baseY + Sht_BuySellBut_Y,
                     BuySellBut_Width, BuySellBut_Height,
                     buySellBg, BuySell_TextClr_work, buySellText, FntSize_BuySellButs);

        CreateBut(PFX + "Lot1_" + symName, baseX + Sht_LotMns01But_X, baseY + Sht_LotMns01But_Y,
                     VolMng_ButWidth, VolMng_ButHeight, VolMng_ButClr_work, VolMng_TextClr_work, VolMng_LotMns01Text, FntSize_VolButs);
        CreateBut(PFX + "Lot2_" + symName, baseX + Sht_LotMns001But_X, baseY + Sht_LotMns001But_Y,
                     VolMng_ButWidth, VolMng_ButHeight, VolMng_ButClr_work, VolMng_TextClr_work, VolMng_LotMns001Text, FntSize_VolButs);

        CreateInputField(PFX + "LotInput_" + symName, baseX + Sht_LotInput_X, baseY + Sht_LotInput_Y,
                         LotInput_Width, LotInput_Height, InputField_BgdClr_work, InputField_TextClr_work,
                         DoubleToString(g_symSts[i].lot_value, 2));

        CreateBut(PFX + "Lot3_" + symName, baseX + Sht_LotPls001But_X, baseY + Sht_LotPls001But_Y,
                     VolMng_ButWidth, VolMng_ButHeight, VolMng_ButClr_work, VolMng_TextClr_work, VolMng_LotPls001Text, FntSize_VolButs);
        CreateBut(PFX + "Lot4_" + symName, baseX + Sht_LotPls01But_X, baseY + Sht_LotPls01But_Y,
                     VolMng_ButWidth, VolMng_ButHeight, VolMng_ButClr_work, VolMng_TextClr_work, VolMng_LotPls01Text, FntSize_VolButs);
    }
}

void CreateBut(string name, int x, int y, int w, int h, color bg, color fg, string text, int baseFntSize = 10)
{
    int relX = x - Dashboard_Base_X;
    int relY = y - Dashboard_Base_Y;
    int sclX = Dashboard_Base_X + int(relX * g_scl);
    int sclY = Dashboard_Base_Y + int(relY * g_scl);
    int sclW = int(w * g_scl);
    int sclH = int(h * g_scl);
    int sclFntSize = MathMax(8, int(baseFntSize * g_scl));  // минимум 8 для читаемости

    if(ObjectCreate(0, name, OBJ_BUTTON, 0, 0, 0))
    {
        ObjectSetInteger(0, name, OBJPROP_XDISTANCE, sclX);
        ObjectSetInteger(0, name, OBJPROP_YDISTANCE, sclY);
        ObjectSetInteger(0, name, OBJPROP_XSIZE, sclW);
        ObjectSetInteger(0, name, OBJPROP_YSIZE, sclH);
        ObjectSetInteger(0, name, OBJPROP_BGCOLOR, bg);
        ObjectSetInteger(0, name, OBJPROP_COLOR, fg);
        ObjectSetInteger(0, name, OBJPROP_FONTSIZE, sclFntSize);
        ObjectSetInteger(0, name, OBJPROP_STATE, false);
        ObjectSetString(0, name, OBJPROP_TEXT, text);
    }
}

void CreateInputField(string name, int x, int y, int w, int h, color bg, color fg, string text)
{
    int relX = x - Dashboard_Base_X;
    int relY = y - Dashboard_Base_Y;
    int sclX = Dashboard_Base_X + int(relX * g_scl);
    int sclY = Dashboard_Base_Y + int(relY * g_scl);
    int sclW = int(w * g_scl);
    int sclH = int(h * g_scl);
    int sclFntSize = MathMax(8, int(FntSize_InputField * g_scl));

    if(ObjectCreate(0, name, OBJ_EDIT, 0, 0, 0))
    {
        ObjectSetInteger(0, name, OBJPROP_XDISTANCE, sclX);
        ObjectSetInteger(0, name, OBJPROP_YDISTANCE, sclY);
        ObjectSetInteger(0, name, OBJPROP_XSIZE, sclW);
        ObjectSetInteger(0, name, OBJPROP_YSIZE, sclH);
        ObjectSetInteger(0, name, OBJPROP_BGCOLOR, bg);
        ObjectSetInteger(0, name, OBJPROP_COLOR, fg);
        ObjectSetInteger(0, name, OBJPROP_FONTSIZE, sclFntSize);
        ObjectSetInteger(0, name, OBJPROP_ALIGN, ALIGN_CENTER);
        ObjectSetString(0, name, OBJPROP_TEXT, text);
    }
}

void CreateBgd(string name, int x, int y, int w, int h, color bgclr, color brdclr)
{
    int relX = x - Dashboard_Base_X;
    int relY = y - Dashboard_Base_Y;
    int sclX = Dashboard_Base_X + int(relX * g_scl);
    int sclY = Dashboard_Base_Y + int(relY * g_scl);
    int sclW = int(w * g_scl);
    int sclH = int(h * g_scl);

    if(ObjectCreate(0, name, OBJ_RECTANGLE_LABEL, 0, 0, 0))
    {
        ObjectSetInteger(0, name, OBJPROP_XDISTANCE, sclX);
        ObjectSetInteger(0, name, OBJPROP_YDISTANCE, sclY);
        ObjectSetInteger(0, name, OBJPROP_XSIZE, sclW);
        ObjectSetInteger(0, name, OBJPROP_YSIZE, sclH);
        ObjectSetInteger(0, name, OBJPROP_BGCOLOR, bgclr);
        ObjectSetInteger(0, name, OBJPROP_BORDER_COLOR, brdclr);
        ObjectSetInteger(0, name, OBJPROP_BORDER_TYPE, BORDER_FLAT);
        ObjectSetInteger(0, name, OBJPROP_BACK, false);
        ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
        ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
        ObjectSetInteger(0, name, OBJPROP_ZORDER, -1);
    }
}

void UpdateSymbolBut(int idx)
{
    string name = PFX + "Symbol_" + g_symSts[idx].symbol_name;
    color bg = g_symSts[idx].active ? Sym_ActiveClr_work : Sym_InactiveClr_work;
    ObjectSetInteger(0, name, OBJPROP_BGCOLOR, bg);
}

void UpdateBuySellBut(int idx)
{
    string name = PFX + "BuySell_" + g_symSts[idx].symbol_name;
    color bg = g_symSts[idx].is_sell ? BuySell_SellClr_work : BuySell_BuyClr_work;
    string text = g_symSts[idx].is_sell ? BuySell_SellText : BuySell_BuyText;
    ObjectSetInteger(0, name, OBJPROP_BGCOLOR, bg);
    ObjectSetString(0, name, OBJPROP_TEXT, text);
}

void UpdateLotInput(int idx)
{
    string name = PFX + "LotInput_" + g_symSts[idx].symbol_name;
    ObjectSetString(0, name, OBJPROP_TEXT, DoubleToString(g_symSts[idx].lot_value, 2));
}

void SetButState(string name, bool state)
{
    ObjectSetInteger(0, name, OBJPROP_STATE, state);
    ChartRedraw();
}


void InitializeSymbolNames()
{
    for(int i = 0; i < g_ttlSym; i++)
    {
        g_symSts[i].symbol_name = SymbolName(i, true);
    }
}

void DltInd()
{
    g_manualDeletion = true;
    SaveStates();
    DeleteAllObjects();

    int window = ChartWindowFind(0, g_indName);
    if(window != -1)
        ChartIndicatorDelete(0, window, g_indName);
}

void RstAllStates()
{
    for(int i = 0; i < g_ttlSym; i++)
    {
        g_symSts[i].active = false;
        g_symSts[i].is_sell = false;
        g_symSts[i].lot_value = 0.1;
    }
    ApplyStates();
    SaveStates();
}

void TogglePanel()
{
    g_panelExpanded = !g_panelExpanded;

    if(g_panelExpanded)
    {
        CreateClnBgds();
        CreateSymbolButs();
        ApplyStates();
    }
    else
    {
        DeleteSymbolObjects();
    }

    ObjectSetString(0, PFX + "HidBut", OBJPROP_TEXT,
                   g_panelExpanded ? Hid_CollapseText : Hid_ExpandText);
    SaveStates();
}

void ChangeClnCount(int newCount)
{
    g_clnCnt = newCount;
    DeleteSymbolObjects();
    CreateClnBgds();
    CreateSymbolButs();
    ApplyStates();
    SaveStates();
}

void CreateClnBgds()
{
    int total = g_ttlSym;
    int cln = g_clnCnt;

    int minRows = total / cln;
    int extra = total % cln;

    int gap = Cln_Width - Bgd_Width;

    for(int col = 0; col < cln; col++)
    {
        int rowsInCln = minRows + (col < extra ? 1 : 0);
        if(rowsInCln <= 0) continue;

        int x = Dashboard_Base_X + col * Cln_Width - gap * col + Sht_ClnBgd_X;
        int y = Dashboard_Base_Y + Hdr_Height + Sht_ClnBgd_Y;
        int w = Bgd_Width + gap * col;
        int h = rowsInCln * Row_Height + 5;

        CreateBgd(PFX + "ColBg_" + IntegerToString(col), x, y, w, h, Bgd_Clr_work, Bgd_BrdClr_work);
    }
}

void DeleteSymbolObjects()
{
    for(int i = ObjectsTotal(0, 0, -1) - 1; i >= 0; i--)
    {
        string name = ObjectName(0, i);
        if(StringFind(name, PFX) == 0 &&
           StringFind(name, "HdrBg") == -1 &&
           StringFind(name, "HdrTitle") == -1 &&          
           StringFind(name, "RstAllBut") == -1 &&
           StringFind(name, "ThemeSwitchBut") == -1 &&
           StringFind(name, "SclPlsBut") == -1 &&
           StringFind(name, "SclMnsBut") == -1 &&
           StringFind(name, "HidBut") == -1 &&
           StringFind(name, "IcrClnsBut") == -1 &&
           StringFind(name, "DcrClnsBut") == -1 && 
           StringFind(name, "DltIndBut") == -1)
        {
            ObjectDelete(0, name);
        }
    }
}

void DeleteAllObjects()
{
    for(int i = ObjectsTotal(0, 0, -1) - 1; i >= 0; i--)
    {
        string name = ObjectName(0, i);
        if(StringFind(name, PFX) == 0)
            ObjectDelete(0, name);
    }
}

void ApplyStates()
{
    for(int i = 0; i < g_ttlSym; i++)
    {
        UpdateSymbolBut(i);
        UpdateBuySellBut(i);
        UpdateLotInput(i);
    }
}

void SaveStates()
{
    GlobalVariableSet(PFX + "ClnCount", g_clnCnt);
    GlobalVariableSet(PFX + "PanelExpanded", g_panelExpanded);

    for(int i = 0; i < g_ttlSym; i++)
    {
        string base = PFX + IntegerToString(i);
        GlobalVariableSet(base + "_Active", g_symSts[i].active);
        GlobalVariableSet(base + "_Sell", g_symSts[i].is_sell);
        GlobalVariableSet(base + "_Lot", g_symSts[i].lot_value);
    }
}

void LoadStates()
{
    if(GlobalVariableCheck(PFX + "ClnCount"))
        g_clnCnt = (int)GlobalVariableGet(PFX + "ClnCount");

    if(GlobalVariableCheck(PFX + "PanelExpanded"))
        g_panelExpanded = (bool)GlobalVariableGet(PFX + "PanelExpanded");

    for(int i = 0; i < g_ttlSym; i++)
    {
        string base = PFX + IntegerToString(i);

        if(GlobalVariableCheck(base + "_Active"))
            g_symSts[i].active = (bool)GlobalVariableGet(base + "_Active");

        if(GlobalVariableCheck(base + "_Sell"))
            g_symSts[i].is_sell = (bool)GlobalVariableGet(base + "_Sell");

        if(GlobalVariableCheck(base + "_Lot"))
            g_symSts[i].lot_value = GlobalVariableGet(base + "_Lot");
    }
}

void GetActiveSymbols(string& sym[], int& directions[], double& lots[])
{
    int cnt = 0;
    for(int i = 0; i < g_ttlSym; i++)
    {
        if(g_symSts[i].active)
            cnt++;
    }

    ArrayResize(sym, cnt);
    ArrayResize(directions, cnt);
    ArrayResize(lots, cnt);

    int idx = 0;
    for(int i = 0; i < g_ttlSym; i++)
    {
        if(g_symSts[i].active)
        {
            sym[idx] = g_symSts[i].symbol_name;
            directions[idx] = g_symSts[i].is_sell ? -1 : 1;
            lots[idx] = g_symSts[i].lot_value;
            idx++;
        }
    }
}

void UpdateHdrTitle()
{
    bool hasActivePair = false;
    for(int i = 0; i < g_ttlSym; i++)
    {
        if(g_symSts[i].active)
        {
            hasActivePair = true;
            break;
        }
    }

    bool isBufferEmpty = true;
    int bufSize = ArraySize(E_buf);
    if(bufSize > 0)
    {
        if(E_buf[0] != 0 && E_buf[0] != EMPTY_VALUE)
            isBufferEmpty = false;
        else Comment("");
    }

    string newTitle = "EQ";
    bool needShowLabel = false;

    if(hasActivePair && isBufferEmpty)
    {
        newTitle = "EQ (Loading...)";
        needShowLabel = true;
    }

    if(newTitle != g_hdrTitle)
    {
        g_hdrTitle = newTitle;
        string name = PFX + "HdrTitle";
        if(ObjectFind(0, name) != -1)
        {
            ObjectSetString(0, name, OBJPROP_TEXT, g_hdrTitle);
            ChartRedraw();
        }
    }

    ShowLoadHistoryLabel(needShowLabel);
}

void ShowLoadHistoryLabel(bool show)
{
    if(!show)
    {
        if(ObjectFind(0, g_loadHistoryLabel) != -1)
            {ObjectDelete(0, g_loadHistoryLabel); ChartRedraw();}
        return;
    }

    int wnd = ChartWindowFind(0, g_indName);
    if(wnd == -1) wnd = 1;

    long width = ChartGetInteger(0, CHART_WIDTH_IN_PIXELS, wnd);
    long height = ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS, wnd);

    long x = width / 2;
    long y = height / 2;

    if(ObjectFind(0, g_loadHistoryLabel) == -1)
    {
        ObjectCreate(0, g_loadHistoryLabel, OBJ_LABEL, wnd, 0, 0);
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_CORNER, 0);
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_XDISTANCE, x);
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_YDISTANCE, y);
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_FONTSIZE, 24);
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_COLOR, clrOrange);
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_SELECTABLE, false);
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_HIDDEN, false);
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_BACK, false);
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_ALIGN, ALIGN_CENTER);
        ObjectSetString(0, g_loadHistoryLabel, OBJPROP_TEXT, "Loading history...");
    }
    else
    {
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_XDISTANCE, x);
        ObjectSetInteger(0, g_loadHistoryLabel, OBJPROP_YDISTANCE, y);
    }
}

void SyncAndRebuildDashboard()
{
    int marketCount = SymbolsTotal(true);  
    if(marketCount != g_ttlSym)
    {
        RebuildDashboard(marketCount);
        return;
    }

    for(int i = 0; i < marketCount; i++)
    {
        string marketSym = SymbolName(i, true);
        if(i >= g_ttlSym || g_symSts[i].symbol_name != marketSym)
        {
            RebuildDashboard(marketCount);
            return;
        }
    }
}

void RebuildDashboard(int marketCount)
{
    g_ttlSym = marketCount;
    ArrayResize(g_symSts, g_ttlSym);
    for(int i = 0; i < g_ttlSym; i++)
    {
        g_symSts[i].symbol_name = SymbolName(i, true);
        g_symSts[i].active = false;
        g_symSts[i].is_sell = false;
        g_symSts[i].lot_value = 0.1;
    }

    CalcSymbolButWidth();

    DeleteAllObjects();
    CreateUI();
    ApplyStates();

    SaveStates();
    ChartRedraw();
}



void SwitchTheme()
{
    g_theme = (ThemeType)((g_theme + 1) % 3);
    ApplyThemeColors();
    RecreateUI();
}
void ApplyThemeColors()
{
    if(g_theme == THEME_DARK)
    {
        Hdr_BgdClr_work           = C'38,43,51';
        Hdr_BrdClr_work           = C'60,65,75';
        Hdr_TitleClr_work         = C'220,230,240';

        RstSet_ButClr_work        = C'48,54,63';
        RstSet_TextClr_work       = C'200,90,100';

        SclPlsBut_Clr_work        = C'48,54,63';
        SclPlsBut_TextClr_work    = C'100,140,180';

        SclMnsBut_Clr_work        = C'48,54,63';
        SclMnsBut_TextClr_work    = C'100,140,180';

        ClnMng_ButClr_work        = C'48,54,63';
        ClnMng_TextClr_work       = C'120,90,160';

        Hid_ButClr_work           = C'48,54,63';
        Hid_TextClr_work          = C'200,180,60';

        CloseDelete_ButClr_work   = C'48,54,63';
        CloseDelete_TextClr_work  = C'255,99,132';

        Sym_ActiveClr_work        = C'0,184,148';
        Sym_InactiveClr_work      = C'38,43,51';
        Sym_TextClr_work          = C'220,230,240';

        BuySell_BuyClr_work       = C'9,132,227';
        BuySell_SellClr_work      = C'255,107,107';
        BuySell_TextClr_work      = C'255,255,255';

        VolMng_ButClr_work        = C'48,54,63';
        VolMng_TextClr_work       = C'220,230,240';

        InputField_BgdClr_work    = C'60,65,75';
        InputField_TextClr_work   = C'220,230,240';

        Bgd_Clr_work             = C'44,49,60';
        Bgd_BrdClr_work          = C'60,65,75';

        ThemeSwitch_ButClr_work   = C'48,54,63';
        ThemeSwitch_TextClr_work  = C'0,184,148';
    }
    else if(g_theme == THEME_LIGHT)
    {
        Hdr_BgdClr_work           = C'200,200,200';
        Hdr_BrdClr_work           = C'180,180,180';
        Hdr_TitleClr_work         = C'60,60,60';

        RstSet_ButClr_work        = C'200,90,100';
        RstSet_TextClr_work       = C'255,255,255';

        SclPlsBut_Clr_work        = C'100,140,180';
        SclPlsBut_TextClr_work    = C'255,255,255';

        SclMnsBut_Clr_work        = C'100,140,180';
        SclMnsBut_TextClr_work    = C'255,255,255';

        ClnMng_ButClr_work        = C'120,90,160';
        ClnMng_TextClr_work       = C'255,255,255';

        Hid_ButClr_work           = C'200,180,60';
        Hid_TextClr_work          = C'50,50,50';

        CloseDelete_ButClr_work   = C'180,60,60';
        CloseDelete_TextClr_work  = C'255,255,255';

        Sym_ActiveClr_work        = C'0,150,130';
        Sym_InactiveClr_work      = C'170,175,180';
        Sym_TextClr_work          = C'50,50,50';

        BuySell_BuyClr_work       = C'30,110,170';
        BuySell_SellClr_work      = C'180,40,45';
        BuySell_TextClr_work      = C'255,255,255';

        VolMng_ButClr_work        = C'170,175,180';
        VolMng_TextClr_work       = C'60,60,60';

        InputField_BgdClr_work    = C'220,225,230';
        InputField_TextClr_work   = C'50,50,50';

        Bgd_Clr_work             = C'210,215,220';
        Bgd_BrdClr_work          = C'160,165,170';

        ThemeSwitch_ButClr_work   = C'70,110,90';
        ThemeSwitch_TextClr_work  = C'255,255,255';
    }
    else
    {
        Hdr_BgdClr_work           = Hdr_BgdClr;
        Hdr_BrdClr_work           = Hdr_BrdClr;
        Hdr_TitleClr_work         = Hdr_TitleClr;

        RstSet_ButClr_work        = RstSet_ButClr;
        RstSet_TextClr_work       = RstSet_TextClr;

        SclPlsBut_Clr_work        = SclPlsBut_Clr;
        SclPlsBut_TextClr_work    = SclPlsBut_TextClr;

        SclMnsBut_Clr_work        = SclMnsBut_Clr;
        SclMnsBut_TextClr_work    = SclMnsBut_TextClr;

        ClnMng_ButClr_work        = ClnMng_ButClr;
        ClnMng_TextClr_work       = ClnMng_TextClr;

        Hid_ButClr_work           = Hid_ButClr;
        Hid_TextClr_work          = Hid_TextClr;

        CloseDelete_ButClr_work   = CloseDelete_ButClr;
        CloseDelete_TextClr_work  = CloseDelete_TextClr;

        Sym_ActiveClr_work        = Sym_ActiveClr;
        Sym_InactiveClr_work      = Sym_InactiveClr;
        Sym_TextClr_work          = Sym_TextClr;

        BuySell_BuyClr_work       = BuySell_BuyClr;
        BuySell_SellClr_work      = BuySell_SellClr;
        BuySell_TextClr_work      = BuySell_TextClr;

        VolMng_ButClr_work        = VolMng_ButClr;
        VolMng_TextClr_work       = VolMng_TextClr;

        InputField_BgdClr_work    = InputField_BgdClr;
        InputField_TextClr_work   = InputField_TextClr;

        Bgd_Clr_work             = Bgd_Clr;
        Bgd_BrdClr_work          = Bgd_BrdClr;

        ThemeSwitch_ButClr_work   = ThemeSwitch_ButClr;
        ThemeSwitch_TextClr_work  = ThemeSwitch_TextClr;
    }
}