//+------------------------------------------------------------------+
//|                                             TesteFootprint.mq5   |
//|                 Footprint Chart nativo MT5 — porta fiel do React |
//+------------------------------------------------------------------+
#property copyright "TesteFootprint"
#property version   "1.85"
#property description "Footprint Chart"
#property stacksize 4194304

#include <Canvas\Canvas.mqh>

//--- Formação
input group "=== Formação ==="
input string InpCloseMode      = "delta";   // Modo: delta|volume|range|time
input double InpDeltaMax       = 800;       // Delta máximo por cluster
input double InpVolumeMax      = 100000;    // Volume máximo (modo volume)
input double InpRangePoints    = 50;        // Range em pontos (modo range)
input int    InpTimeSeconds    = 300;       // Tempo em segundos (modo time)
input double InpStepMultiplier = 75.0;      // Agrupamento de níveis — 75 para USTEC
input int    InpHistoryBars    = 200;       // Clusters no buffer circular
input int    InpHistoryHours   = 4;         // Horas de histórico ao iniciar

//--- Exibição
input group "=== Exibição ==="
enum ENUM_VIEW { VIEW_BIDASK=0, VIEW_DELTA=1 };
input ENUM_VIEW InpViewMode    = VIEW_BIDASK; // Modo: Bid x Ask | Delta
input int    InpClusterWidth   = 120;       // Largura base do cluster (px)
input int    InpLevelHeight    = 16;        // Altura por nível (zoom vertical)
input int    InpFontSize       = 8;         // Tamanho da fonte
input int    InpBottomPanel    = 100;       // Altura do painel inferior (px) — igual React

//--- Cores
input group "=== Cores ==="
input color  InpColorAsk  = 0x3B82F6;
input color  InpColorBid  = 0xEC4899;
input color  InpColorPoc  = clrWhite;
input color  InpColorBg   = 0x0B0E14;
input color  InpColorText = 0x94A3B8;

//+------------------------------------------------------------------+
//| Estruturas                                                        |
//+------------------------------------------------------------------+
struct SLevel { double price, ask, bid; };

struct SCluster
{
    datetime open_time, close_time;
    double   open_price, close_price, delta, total_volume;
    double   price_high, price_low, poc_price;
    bool     is_closed;
    SLevel   levels[2000];
    int      level_count;
};

#define VP_LEVELS  500
#define ZONE_MAX   20
#define VP_MAX     5
// Color picker grid
#define PICK_COLS  16
#define PICK_ROWS  10
#define PICK_SW    14   // swatch width px
#define PICK_SH    14   // swatch height px
#define PICK_GAP   2    // gap between swatches
#define PICK_PAD   8    // panel padding
#define PICK_W     (PICK_PAD*2 + PICK_COLS*(PICK_SW+PICK_GAP) - PICK_GAP)  // 270
#define PICK_H     (32 + PICK_PAD + PICK_ROWS*(PICK_SH+PICK_GAP) - PICK_GAP + PICK_PAD)  // 206

struct SZone {
    double price_high, price_low;
    int    ci_from, ci_to;   // índices absolutos de histórico (ci_from <= ci_to)
    color  border_clr;
    bool   raio_dir;          // estende até a direita (borda do gráfico)
    bool   raio_esq;          // estende até a esquerda
    bool   sobre_clusters;    // z-order: desenha sobre os clusters
    bool   active;
};

struct SVProfile {
    double price_high, price_low;
    int    ci_from, ci_to;
    // Visualizar
    bool   show_volume;       // barras de volume
    bool   show_delta;        // barras de delta
    bool   delta_espelhado;   // delta espelhado (bid esquerda, ask direita)
    bool   volume_soma;       // soma bid+ask em barra única
    // Linhas
    bool   show_poc;
    bool   show_va;           // value area
    double va_pct;            // % value area (padrão 70)
    bool   show_vwap;
    // Z-order
    bool   sobre_clusters;
    // Cores
    color  clr_bid, clr_ask;  // cores das barras de volume
    color  clr_poc;           // linha do POC
    color  clr_borda;         // borda do painel
    // Dados calculados
    double prices[VP_LEVELS];
    double vol_bid[VP_LEVELS];
    double vol_ask[VP_LEVELS];
    int    count;
    double poc_price, vah_price, val_price, vwap_price;
    bool   active;
};

//+------------------------------------------------------------------+
//| Globais                                                           |
//+------------------------------------------------------------------+
SCluster  g_history[200];
int       g_history_count = 0;
int       g_history_start = 0;
SCluster  g_active;
bool      g_active_valid  = false;

double    g_tick_size  = 0.01;
double    g_step       = 1.0;
double    g_step_mult  = 1.0;
double    g_delta_max  = 800;
int       g_scroll     = 0;       // navegação L/R (em clusters)
int       g_zoom_v     = 16;      // altura de nível em px (drag barra de preço)
int       g_zoom_h     = 100;     // zoom horizontal % (drag painel inferior)
ulong     g_last_draw_msc = 0;

CCanvas   g_canvas;
string    g_canvas_name = "TesteFootprint_BMP";
int       g_canvas_w    = 0;
int       g_canvas_h    = 0;

ulong     g_last_tick_msc  = 0;
double    g_last_bid_price = 0;
double    g_last_mid_price = 0;
bool      g_last_is_buy    = true;
double    g_last_bid       = 0;
double    g_last_ask       = 0;
double    g_current_price  = 0;

// Drag: barra de preço → zoom vertical
bool      g_vaxis_drag = false;
int       g_vdrag_y0   = 0;
int       g_vdrag_z0   = 16;

// Drag: painel inferior → zoom horizontal
bool      g_haxis_drag = false;
int       g_hdrag_x0   = 0;
int       g_hdrag_zh0  = 100;

// Pan vertical (arrastar área principal)
bool      g_pan_drag   = false;
int       g_pan_y0     = 0;
double    g_pan_off0   = 0.0;
double    g_pan_offset = 0.0;   // offset em preço aplicado ao viewport
double    g_last_prange= 1.0;   // prange da última renderização (para converter px → preço)

// Runtime overrides (alterados pelo menu em tempo real)
ENUM_VIEW g_view_mode  = VIEW_BIDASK;
string    g_close_mode = "delta";
color     g_color_ask  = (color)0x3B82F6;
color     g_color_bid  = (color)0xEC4899;
color     g_color_poc  = clrWhite;

// Menu de configurações
bool   g_menu_open  = false;
int    g_menu_tab   = 0;         // 0=Formação 1=Cores
double g_form_step  = 75.0;
double g_form_delta = 800.0;
int    g_form_view  = 0;
string g_form_mode  = "delta";
bool   g_prev_btn   = false;     // estado anterior do botão (detecção de click)

// Ferramentas de desenho — Zona e VP
SZone     g_zones[ZONE_MAX];
int       g_zone_count = 0;
SVProfile g_vprofiles[VP_MAX];
int       g_vp_count    = 0;

// Estado do último Redraw — conversão pixel↔cluster/preço
int    g_rdr_cw=0, g_rdr_col_step=0, g_rdr_chart_x1=0, g_rdr_chart_h=0;
int    g_rdr_last_idx=0, g_rdr_active_off=0;
double g_rdr_pmin=0, g_rdr_pmax=0;

// Seleção de área para ferramentas de desenho (right-drag ou Ctrl+left-drag)
bool   g_rbtn_prev   = false;
bool   g_sel_drag    = false;
bool   g_sel_is_right= false;  // true=iniciado por right-drag, false=Ctrl+left-drag
int    g_sel_x0=0, g_sel_y0=0;
int    g_sel_x1=0, g_sel_y1=0;
bool   g_sel_ready   = false;
int    g_seltb_x=0, g_seltb_y=0;  // posição da toolbar (para hit-test)

// Presets de cor para o menu (cycling)
color g_bid_presets[] = {(color)0xEC4899,(color)0xFF1744,(color)0xEC464F,(color)0xE53935};
color g_ask_presets[] = {(color)0x3B82F6,(color)0x29B6F6,(color)0x3BA6F7,(color)0x1565C0};
color g_poc_presets[] = {clrWhite,(color)0xFFD600,(color)0x00E5FF,(color)0x76FF03};
int   g_bid_pi=0, g_ask_pi=0, g_poc_pi=0;

// Painel de configuração de zona
int   g_zone_sel   = -1;    // índice da zona selecionada, -1=nenhuma
bool  g_zone_panel = false; // painel de config aberto
int   g_zpx=0, g_zpy=0;    // posição do painel (ponto de clique)

color g_zone_clr_presets[] = {(color)0xFF4081,(color)0x3B82F6,(color)0x22C55E,
                               (color)0xFFD600,(color)0xEF4444,(color)0xA855F7};
int   g_zone_clr_pi=0;

// Painel de configuração de VP
int   g_vp_sel    = -1;
bool  g_vp_panel  = false;
int   g_vppx=0, g_vppy=0;

color g_vp_clr_presets[] = {(color)0xFFD600,(color)0xF59E0B,(color)0xFF4081,
                             (color)0x22C55E,(color)0x00E5FF};
int   g_vp_poc_pi=0;

// Right-click: distingue click (abre config) vs drag (inicia seleção)
bool g_rclick_wait = false;
int  g_rclick_xi=0, g_rclick_yi=0;
int  g_rclick_vi=-1;   // índice VP sob cursor no momento do right-press
int  g_rclick_zi=-1;   // índice Zone sob cursor no momento do right-press

// Color picker
enum EPICK_TARGET { PICK_NONE=0, PICK_ZONE_BORDER,
                    PICK_VP_BID, PICK_VP_ASK, PICK_VP_POC,
                    PICK_GLOBAL_BID, PICK_GLOBAL_ASK, PICK_GLOBAL_POC };
EPICK_TARGET g_pick_target = PICK_NONE;
bool g_pick_open = false;
int  g_pick_px=0, g_pick_py=0;

color g_pick_palette[160] = {
    // Row 0: Grayscale
    0x000000,0x111111,0x222222,0x333333,0x444444,0x666666,0x808080,0x999999,0xBBBBBB,0xCCCCCC,0xDDDDDD,0xEEEEEE,0xFFFFFF,0xF5F5DC,0xFFF8DC,0xFFFAF0,
    // Row 1: Red
    0xFF0000,0xFF1744,0xF50057,0xE53935,0xC62828,0xB71C1C,0x8B0000,0xFF5252,0xFF8A80,0xFFCDD2,0xFF4081,0xFC3158,0xE91E63,0xC2185B,0xAD1457,0x880E4F,
    // Row 2: Orange
    0xFF6600,0xFF5722,0xF4511E,0xE64A19,0xBF360C,0xFF3D00,0xFF6D00,0xFF9100,0xFFAB40,0xFF8C00,0xFFA726,0xFB8C00,0xF57C00,0xEF6C00,0xE65100,0xDD2C00,
    // Row 3: Yellow/Amber
    0xFFD600,0xFFEA00,0xFFFF00,0xFFF176,0xFFEB3B,0xFFC107,0xFFB300,0xFFA000,0xFF8F00,0xFF6F00,0xF9A825,0xF57F17,0xFDD835,0xF9D71C,0xFFEE58,0xFFF9C4,
    // Row 4: Green
    0x00C853,0x00E676,0x69F0AE,0x22C55E,0x4CAF50,0x43A047,0x388E3C,0x2E7D32,0x1B5E20,0x76FF03,0xB2FF59,0x8BC34A,0x558B2F,0x33691E,0x00BFA5,0x1DE9B6,
    // Row 5: Teal/Cyan
    0x00E5FF,0x18FFFF,0x00B8D4,0x00838F,0x00BCD4,0x00ACC1,0x0097A7,0x006064,0x009688,0x00897B,0x00796B,0x004D40,0x80DEEA,0x4DD0E1,0x26C6DA,0x84FFFF,
    // Row 6: Blue
    0x3B82F6,0x2563EB,0x1D4ED8,0x448AFF,0x2196F3,0x1976D2,0x1565C0,0x0D47A1,0x29B6F6,0x03A9F4,0x039BE5,0x0288D1,0x0277BD,0x01579B,0x82B1FF,0x40C4FF,
    // Row 7: Purple/Violet
    0xA855F7,0x9333EA,0x7E22CE,0x6200EA,0x651FFF,0x7C4DFF,0xD500F9,0xAA00FF,0xCE93D8,0xBA68C8,0xAB47BC,0x9C27B0,0x8E24AA,0x7B1FA2,0x4A148C,0x311B92,
    // Row 8: Pink/Magenta
    0xFF80AB,0xF48FB1,0xF06292,0xEC407A,0xE91E63,0xD81B60,0xC2185B,0xAD1457,0xFF4081,0xFF1744,0xF50057,0xC51162,0xD81B60,0xC2185B,0xAD1457,0x880E4F,
    // Row 9: Trading / acentos úteis
    0xFFD600,0xEC4899,0x3B82F6,0x22C55E,0xEF4444,0xA855F7,0x00E5FF,0xF97316,0x14B8A6,0x8B5CF6,0x6366F1,0x06B6D4,0x10B981,0xF59E0B,0x84CC16,0x795548
};

//+------------------------------------------------------------------+
//| Cores                                                             |
//+------------------------------------------------------------------+
uint Argb(color c, int a)
{ return ((uint)a<<24)|((c>>16)&0xFF)<<16|((c>>8)&0xFF)<<8|(c&0xFF); }

// Único jeito correto de semi-transparência em XRGB_NOALPHA
uint Blend(color bc, color bg, double t)
{
    t=MathMax(0.0,MathMin(1.0,t));
    uint r=(uint)(((bg>>16)&0xFF)*(1-t)+((bc>>16)&0xFF)*t);
    uint g=(uint)(((bg>>8)&0xFF)*(1-t)+((bc>>8)&0xFF)*t);
    uint b=(uint)((bg&0xFF)*(1-t)+(bc&0xFF)*t);
    return 0xFF000000|(r<<16)|(g<<8)|b;
}

//+------------------------------------------------------------------+
//| Cluster helpers                                                   |
//+------------------------------------------------------------------+
int CFindOrInsert(SCluster &c, double price)
{
    for(int i=0;i<c.level_count;i++) if(MathAbs(c.levels[i].price-price)<1e-8) return i;
    if(c.level_count>=2000) return -1;
    int pos=c.level_count;
    for(int i=0;i<c.level_count;i++) if(price<c.levels[i].price){pos=i;break;}
    for(int i=c.level_count;i>pos;i--) c.levels[i]=c.levels[i-1];
    c.levels[pos].price=price; c.levels[pos].ask=0; c.levels[pos].bid=0;
    c.level_count++; return pos;
}

void CCalcPoc(SCluster &c)
{
    // Usa max(ask,bid) — mesma métrica do local_max/barra — para que POC = nível sempre cheio
    double mx=-1; c.poc_price=(c.level_count>0)?c.levels[0].price:0;
    for(int i=0;i<c.level_count;i++){double t=MathMax(c.levels[i].ask,c.levels[i].bid);if(t>mx){mx=t;c.poc_price=c.levels[i].price;}}
}

void CAddVol(SCluster &c, double price, double volume, bool is_buy)
{
    double b=NormalizeDouble(MathRound(price/g_step)*g_step,_Digits);
    int idx=CFindOrInsert(c,b); if(idx<0) return;
    if(is_buy){c.levels[idx].ask+=volume;c.delta+=volume;}
    else      {c.levels[idx].bid+=volume;c.delta-=volume;}
    c.total_volume+=volume; c.close_price=price;
    if(c.level_count==1||b>c.price_high) c.price_high=b;
    if(c.level_count==1||b<c.price_low)  c.price_low=b;
}

void ActiveReset()
{
    g_active.open_time=0;g_active.close_time=0;g_active.open_price=0;g_active.close_price=0;
    g_active.delta=0;g_active.total_volume=0;g_active.price_high=0;g_active.price_low=0;
    g_active.poc_price=0;g_active.is_closed=false;g_active.level_count=0;g_active_valid=false;
}

int HIdx(int logical) { return (g_history_start + logical) % InpHistoryBars; }

void CloseActive(string reason)
{
    if(!g_active_valid) return;
    CCalcPoc(g_active); g_active.is_closed=true; g_active.close_time=(datetime)(g_last_tick_msc/1000);
    if(g_history_count < InpHistoryBars)
    {
        g_history[g_history_count] = g_active;
        g_history_count++;
    }
    else
    {
        g_history[g_history_start] = g_active;
        g_history_start = (g_history_start + 1) % InpHistoryBars;
    }
    ActiveReset();
}

bool ShouldClose(ulong msc)
{
    if(!g_active_valid) return false;
    if(g_close_mode=="delta")  return MathAbs(g_active.delta)>=g_delta_max;
    if(g_close_mode=="range")  return (g_active.price_high-g_active.price_low)>=InpRangePoints*g_tick_size;
    if(g_close_mode=="time")   return (msc/1000-(ulong)g_active.open_time)>=(ulong)InpTimeSeconds;
    if(g_close_mode=="volume") return g_active.total_volume>=InpVolumeMax;
    return false;
}

void ProcessTick(double price, double volume, bool is_buy, ulong msc)
{
    g_current_price=price;
    if(g_close_mode!="delta")
    {
        if(!g_active_valid){ActiveReset();g_active.open_time=(datetime)(msc/1000);g_active.open_price=price;g_active_valid=true;}
        CAddVol(g_active,price,volume,is_buy);
        if(ShouldClose(msc)) CloseActive(g_close_mode);
        return;
    }
    double rem=volume;
    while(rem>0.0)
    {
        if(g_active_valid&&MathAbs(g_active.delta)>=g_delta_max){CloseActive("delta");continue;}
        if(!g_active_valid){ActiveReset();g_active.open_time=(datetime)(msc/1000);g_active.open_price=price;g_active_valid=true;}
        double cur=g_active.delta,contrib=is_buy?rem:-rem;
        if(MathAbs(cur+contrib)<=g_delta_max){CAddVol(g_active,price,rem,is_buy);if(ShouldClose(msc))CloseActive("delta");break;}
        double cap=MathMax(is_buy?(g_delta_max-cur):(cur+g_delta_max),0.0);
        if(cap>0) CAddVol(g_active,price,cap,is_buy);
        CloseActive("delta"); rem-=cap;
    }
}

bool ClassifyTick(MqlTick &t)
{
    if((t.flags&TICK_FLAG_BUY) !=0) return true;
    if((t.flags&TICK_FLAG_SELL)!=0) return false;
    return g_last_is_buy;
}

bool ParseTick(MqlTick &t, double &p, double &v, bool &b)
{
    double bid=t.bid,ask=t.ask,last=t.last;
    if(bid>0) g_last_bid=bid;
    if(ask>0) g_last_ask=ask;
    double mid=(bid>0&&ask>0)?(bid+ask)/2.0:0;
    double pb=g_last_bid_price,pm=g_last_mid_price;
    if(bid>0){if(bid>g_last_bid_price)g_last_is_buy=true;else if(bid<g_last_bid_price)g_last_is_buy=false;g_last_bid_price=bid;}
    else if(mid>0){if(mid>g_last_mid_price)g_last_is_buy=true;else if(mid<g_last_mid_price)g_last_is_buy=false;}
    if(mid>0) g_last_mid_price=mid;
    p=(last>0)?last:(mid>0?mid:(bid>0?bid:ask));
    if(p<=0) return false;
    double ts=(g_tick_size>0)?g_tick_size:0.01;
    if(pb>0&&bid>0)     v=MathMax(MathAbs(bid-pb)/ts,1.0);
    else if(pm>0&&mid>0)v=MathMax(MathAbs(mid-pm)/ts,1.0);
    else                v=1.0;
    b=ClassifyTick(t); return true;
}

void Reload()
{
    g_step = g_tick_size * g_step_mult;
    g_pan_offset = 0.0;
    ActiveReset();
    g_history_count = 0;
    g_history_start = 0;
    g_last_bid_price = 0;
    g_last_mid_price = 0;
    g_last_is_buy    = true;
    LoadHistory();
    Redraw();
}

void LoadHistory()
{
    datetime from=TimeCurrent()-InpHistoryHours*3600;
    Print("TesteFootprint: carregando desde ",TimeToString(from));
    MqlTick ticks[];
    int count=CopyTicksRange(_Symbol,ticks,COPY_TICKS_ALL,(ulong)from*1000,(ulong)TimeCurrent()*1000);
    if(count<=0){Print("TesteFootprint: sem ticks históricos.");return;}
    Print("TesteFootprint: processando ",count," ticks...");
    for(int i=0;i<count;i++)
    {
        double p,v; bool b;
        g_last_tick_msc=ticks[i].time_msc;
        if(ParseTick(ticks[i],p,v,b)) ProcessTick(p,v,b,ticks[i].time_msc);
    }
    if(count>0) g_last_tick_msc=ticks[count-1].time_msc;
    Print("TesteFootprint: ",g_history_count," clusters prontos.");
}

//+------------------------------------------------------------------+
//| Canvas helpers                                                    |
//+------------------------------------------------------------------+
void TxtOut(int x, int y, string text, uint clr, string font="Arial", int sz=8)
{
    g_canvas.FontSet(font, sz);
    g_canvas.TextOut(x, y, text, clr);
}

bool ResizeCanvas()
{
    int w=(int)ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
    int h=(int)ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);
    if(w==g_canvas_w&&h==g_canvas_h) return false;
    if(w<=0||h<=0) return false;
    g_canvas_w=w; g_canvas_h=h;
    g_canvas.Resize(w,h); return true;
}

//+------------------------------------------------------------------+
//| Renderiza cluster — porta fiel do React FootprintCanvas.jsx      |
//+------------------------------------------------------------------+
void DrawCluster(SCluster &c, int cx, int cw, int chart_h,
                 double pmin, double pmax, double max_side, bool is_active)
{
    if(c.level_count==0) return;
    double prange=pmax-pmin; if(prange<=0) return;

    int cw2 = cw - 4;  // largura interna (2px margem cada lado, como colX+1 no React)
    if(cw2<4) cw2=4;

    // Máximo local para proporção das barras (igual React: por cluster, não global)
    double local_max=1;
    for(int li=0;li<c.level_count;li++)
    {
        double d=MathMax(c.levels[li].ask,c.levels[li].bid);
        if(d>local_max)local_max=d;
    }

    // Body bounds para wick detection (open/close, igual React)
    double body_low =MathMin(c.open_price,c.close_price);
    double body_high=MathMax(c.open_price,c.close_price);
    bool   is_bull  =(c.close_price>=c.open_price);

    // row_h: espaçamento real entre níveis em px — igual ao React (rowHeight=zoomV, sem cap)
    double px_step=(g_step>0&&prange>0)?((double)(chart_h-4)*g_step/prange):(double)g_zoom_v;
    int row_h=MathMax(2,(int)px_step);

    //--- Células de nível (bid/ask bars) ---
    for(int li=0;li<c.level_count;li++)
    {
        double price=c.levels[li].price;
        double ask_v=c.levels[li].ask;
        double bid_v=c.levels[li].bid;
        double dom  =MathMax(ask_v,bid_v);
        bool   is_ask=(ask_v>=bid_v);

        int yc=chart_h-1-(int)((price-pmin)/prange*(chart_h-4));
        int yt=yc-row_h/2, yb=yt+row_h-1;
        if(yt<0)yt=0; if(yb>=chart_h)yb=chart_h-1; if(yt>=yb)continue;

        // Wick: fora do corpo → alpha 0.65, dentro → alpha 0.85
        // Tolerância = g_step*0.5 (igual React: actualTickSize = tick_size * stepMultiplier)
        bool   is_wick=(price<body_low-g_step*0.5)||(price>body_high+g_step*0.5);
        double alpha  =is_wick?0.65:0.85;

        // Barra proporcional lado dominante — igual em ambos os modos (fiel ao React)
        {
            int bw=(int)(dom/local_max*(double)cw2); if(bw<1)bw=1;
            g_canvas.FillRectangle(cx+2,yt+1,cx+2+bw-1,yb-1,
                Blend(is_ask?g_color_ask:g_color_bid,InpColorBg,alpha));
        }

        // POC: borda + número — sempre, inclusive no pavio
        // BidAsk: mostra dominantVal | Delta: mostra ask-bid com cor verde/vermelho
        if(MathAbs(price-c.poc_price)<1e-8)
        {
            g_canvas.Rectangle(cx+2,yt,cx+cw2+1,yb,Argb(g_color_poc,255));
            double delta_poc=ask_v-bid_v;
            string s=(g_view_mode==VIEW_DELTA)
                ? ((delta_poc>=0?"+":"")+IntegerToString((int)delta_poc))
                : IntegerToString((int)dom);
            uint txt_clr=(g_view_mode==VIEW_DELTA)
                ? Argb(delta_poc>=0?(color)0x00E676:(color)0xFF1744,255)
                : Argb(0xFFFFFF,255);
            g_canvas.FontSet("Arial Bold",InpFontSize);
            int tx=cx+cw2-(int)StringLen(s)*(InpFontSize-1);
            if(row_h>=InpFontSize)
                g_canvas.TextOut(tx,yt+(row_h-InpFontSize)/2,s,txt_clr);
        }

    }

    //--- Borda OHLC do cluster (open_price → close_price = CORPO) ---
    // Igual ao React: strokeRect ao redor do corpo, NÃO do high/low
    int y_open  =chart_h-1-(int)((c.open_price -pmin)/prange*(chart_h-4));
    int y_close =chart_h-1-(int)((c.close_price-pmin)/prange*(chart_h-4));
    int candle_top=MathMin(y_open,y_close)-row_h/2;
    int candle_bot=MathMax(y_open,y_close)+row_h/2;
    if(candle_top<0)candle_top=0;
    if(candle_bot>=chart_h)candle_bot=chart_h-1;
    if(candle_bot>candle_top)
        g_canvas.Rectangle(cx,candle_top,cx+cw,candle_bot,
            Blend(is_bull?(color)0x00E676:(color)0xFF1744,InpColorBg,0.55));

    //--- Linhas de pavio (centro da coluna, igual candle do React) ---
    int cx_mid=cx+cw/2;
    int y_high=chart_h-1-(int)((c.price_high-pmin)/prange*(chart_h-4));
    int y_low =chart_h-1-(int)((c.price_low -pmin)/prange*(chart_h-4));
    uint wick_clr=Blend(is_bull?(color)0x00E676:(color)0xFF1744,InpColorBg,0.4);
    if(c.price_high>body_high+g_tick_size*0.5&&y_high<candle_top)
        g_canvas.Line(cx_mid,y_high,cx_mid,candle_top,wick_clr);
    if(c.price_low <body_low -g_tick_size*0.5&&y_low >candle_bot)
        g_canvas.Line(cx_mid,candle_bot,cx_mid,y_low+row_h,wick_clr);


    //--- Painel inferior ---
    double total_bid=0,total_ask=0;
    for(int li=0;li<c.level_count;li++){total_bid+=c.levels[li].bid;total_ask+=c.levels[li].ask;}

    // Layout dinâmico: usa o espaço disponível do painel
    int panel_top  = chart_h + 2;                        // topo do painel (logo abaixo do separador)
    int ts_h       = 12;                                 // reserva p/ timestamp no fundo
    int panel_bot  = g_canvas_h - ts_h;                 // fundo disponível
    int panel_h    = panel_bot - panel_top;              // altura total usável
    if(panel_h < 10) return;

    int bar_zone_h = panel_h * 65 / 100;                // 65% p/ barras de volume
    int bar_base   = panel_top + bar_zone_h;             // piso das barras
    int pw         = cw;                                 // largura total da coluna (sem margens)
    int half_w     = pw / 2;

    int bid_bh=MathMax(2,(int)(total_bid/MathMax(max_side,1)*bar_zone_h));
    int ask_bh=MathMax(2,(int)(total_ask/MathMax(max_side,1)*bar_zone_h));

    // Bid (esquerda) e Ask (direita) — sem margem interna
    g_canvas.FillRectangle(cx,       bar_base-bid_bh, cx+half_w-1,  bar_base, Argb(0xD22626,255));
    g_canvas.FillRectangle(cx+half_w,bar_base-ask_bh, cx+pw-1,      bar_base, Argb(0x2563EB,255));

    // Label de volume dentro das barras
    double dom_vol=MathMax(total_bid,total_ask);
    string vol_lbl=(dom_vol>=1000)?(DoubleToString(dom_vol/1000.0,1)+"K"):IntegerToString((int)dom_vol);
    int vol_fs=MathMax(10,InpFontSize+4);
    g_canvas.FontSet("Arial Bold",vol_fs);
    int ly=bar_base-2-vol_fs;
    if(ly>panel_top) g_canvas.TextOut(cx+pw/2,ly,vol_lbl,Argb(0xFFFFFF,255),TA_CENTER|TA_TOP);

    // Bloco delta — ocupa o resto do painel até o timestamp
    int delta_y = bar_base + 1;
    int delta_b = panel_bot;
    if(delta_b > delta_y + 4)
    {
        g_canvas.FillRectangle(cx,delta_y,cx+pw-1,delta_b,
            Argb((c.delta>=0)?0x2563EB:0xF97316,255));
        string ds=(c.delta>=0?"+":"")+IntegerToString((int)c.delta);
        g_canvas.FontSet("Arial Bold",InpFontSize);
        int dh=delta_b-delta_y;
        g_canvas.TextOut(cx+pw/2,delta_y+(dh-InpFontSize)/2,ds,Argb(0xFFFFFF,255),TA_CENTER|TA_TOP);
    }

    // Horário no fundo
    if(c.open_time>0&&g_canvas_h-11>chart_h)
    {
        g_canvas.FontSet("Arial",InpFontSize-1);
        g_canvas.TextOut(cx+2,g_canvas_h-11,
            TimeToString(c.open_time,TIME_MINUTES),Argb(InpColorText,255));
    }
}

//+------------------------------------------------------------------+
//| Menu de Configurações                                             |
//+------------------------------------------------------------------+
#define MNU_X    20
#define MNU_Y    45
#define MNU_W    280
#define MNU_BG   0x0D1220
#define MNU_CARD 0x182032
#define MNU_BTN  0x253348
#define MNU_GRN  0x00C853

void MnuLabel(int y, string txt)
{
    g_canvas.FontSet("Arial Bold",7);
    g_canvas.TextOut(MNU_X+10,y,txt,Argb(0x7A8EA8,255));
}

void MnuToggle(int y, string l, string r, int sel)
{
    int lx=MNU_X+10, mid=MNU_X+MNU_W/2, rx=MNU_X+MNU_W-10, h=30;
    g_canvas.FillRectangle(lx,y,mid,y+h,sel==0?Argb(MNU_BTN,255):Argb(MNU_CARD,255));
    g_canvas.FillRectangle(mid,y,rx,y+h,sel==1?Argb(MNU_BTN,255):Argb(MNU_CARD,255));
    g_canvas.Rectangle(lx,y,rx,y+h,Argb(0x334155,255));
    g_canvas.Line(mid,y,mid,y+h,Argb(0x334155,255));
    g_canvas.FontSet("Arial Bold",9);
    g_canvas.TextOut(lx+(mid-lx)/2-(int)StringLen(l)*5/2,y+9,l,Argb(0xFFFFFF,255));
    g_canvas.TextOut(mid+(rx-mid)/2-(int)StringLen(r)*5/2,y+9,r,Argb(0xFFFFFF,255));
}

void MnuStepper(int y, double val)
{
    int lx=MNU_X+10, rx=MNU_X+MNU_W-10, w=rx-lx;
    g_canvas.FillRectangle(lx,y,rx,y+32,Argb(MNU_CARD,255));
    g_canvas.Rectangle(lx,y,rx,y+32,Argb(0x334155,255));
    g_canvas.FillRectangle(lx+1,y+1,lx+32,y+31,Argb(MNU_BTN,255));
    g_canvas.FillRectangle(rx-32,y+1,rx-1,y+31,Argb(MNU_BTN,255));
    g_canvas.FontSet("Arial Bold",13); g_canvas.TextOut(lx+8,y+5,"−",Argb(0xFFFFFF,255));
    g_canvas.FontSet("Arial Bold",13); g_canvas.TextOut(rx-22,y+5,"+",Argb(0xFFFFFF,255));
    string sv=IntegerToString((int)val);
    g_canvas.FontSet("Arial Bold",10);
    g_canvas.TextOut(lx+w/2-(int)StringLen(sv)*6/2,y+9,sv,Argb(0xFFFFFF,255));
}

void MnuDropdown(int y, string val)
{
    int lx=MNU_X+10, rx=MNU_X+MNU_W-10;
    g_canvas.FillRectangle(lx,y,rx,y+32,Argb(MNU_CARD,255));
    g_canvas.Rectangle(lx,y,rx,y+32,Argb(0x334155,255));
    string cap=val;
    StringSetCharacter(cap,0,(ushort)(StringGetCharacter(cap,0)-32));
    g_canvas.FontSet("Arial",10); g_canvas.TextOut(lx+10,y+9,cap,Argb(0xFFFFFF,255));
    g_canvas.FontSet("Arial",9);  g_canvas.TextOut(rx-18,y+10,"▼",Argb(0x94A3B8,255));
}

void MnuColorRow(int y, string lbl, color c)
{
    int rx=MNU_X+MNU_W-10;
    g_canvas.FontSet("Arial Bold",9); g_canvas.TextOut(MNU_X+10,y+10,lbl,Argb(0xFFFFFF,255));
    string hs=StringFormat("#%02X%02X%02X",(c>>16)&0xFF,(c>>8)&0xFF,c&0xFF);
    g_canvas.FontSet("Arial",8); g_canvas.TextOut(rx-96,y+12,hs,Argb(0x64748B,255));
    g_canvas.FillRectangle(rx-40,y+4,rx-4,y+36,Argb(c,255));
    g_canvas.Rectangle(rx-40,y+4,rx-4,y+36,Argb(0x475569,255));
}

void DrawGearBtn()
{
    uint bg=g_menu_open?Argb(MNU_GRN,255):Argb(0x1E293B,255);
    g_canvas.FillRectangle(5,8,33,36,bg);
    g_canvas.Rectangle(5,8,33,36,Argb(0x334155,255));
    g_canvas.FontSet("Arial",15); g_canvas.TextOut(9,10,"⚙",Argb(0xFFFFFF,255));
}

void DrawMenu()
{
    int tabY=MNU_Y+42, cy=tabY+38;
    int panH=(g_menu_tab==0)?418:255;
    g_canvas.FillRectangle(MNU_X,MNU_Y,MNU_X+MNU_W,MNU_Y+panH,Argb(MNU_BG,255));
    g_canvas.Rectangle(MNU_X,MNU_Y,MNU_X+MNU_W,MNU_Y+panH,Argb(0x2A364F,255));
    // Header
    g_canvas.FillRectangle(MNU_X,MNU_Y,MNU_X+MNU_W,MNU_Y+34,Argb(0x080E18,255));
    g_canvas.FontSet("Arial Bold",11); g_canvas.TextOut(MNU_X+14,MNU_Y+9,"CONFIGURAÇÕES",Argb(0xFFFFFF,255));
    g_canvas.FontSet("Arial Bold",13); g_canvas.TextOut(MNU_X+MNU_W-18,MNU_Y+7,"×",Argb(0x94A3B8,255));
    // Tabs
    int mid=MNU_X+MNU_W/2;
    g_canvas.FillRectangle(MNU_X+10,tabY,mid-2,tabY+30,g_menu_tab==0?Argb(MNU_GRN,255):Argb(MNU_CARD,255));
    g_canvas.FillRectangle(mid+2,tabY,MNU_X+MNU_W-10,tabY+30,g_menu_tab==1?Argb(MNU_GRN,255):Argb(MNU_CARD,255));
    g_canvas.Rectangle(MNU_X+10,tabY,MNU_X+MNU_W-10,tabY+30,Argb(0x334155,255));
    g_canvas.Line(mid,tabY,mid,tabY+30,Argb(0x334155,255));
    g_canvas.FontSet("Arial Bold",9);
    g_canvas.TextOut(MNU_X+30,tabY+9,"Formação",Argb(0xFFFFFF,255));
    g_canvas.TextOut(mid+22,tabY+9,"Cores",Argb(0xFFFFFF,255));
    if(g_menu_tab==0)
    {
        MnuLabel(cy,"MODO DE EXIBIÇÃO"); cy+=16;
        MnuToggle(cy,"Bid x Ask","Delta",g_form_view); cy+=38;
        MnuLabel(cy,"PASSO DO PREÇO (ticks)"); cy+=16;
        MnuStepper(cy,g_form_step); cy+=40;
        MnuLabel(cy,"MODO DE FECHAMENTO"); cy+=16;
        MnuDropdown(cy,g_form_mode); cy+=40;
        MnuLabel(cy,"DELTA MÁX"); cy+=16;
        MnuStepper(cy,g_form_delta); cy+=44;
        bool dirty=(g_form_step!=g_step_mult||g_form_delta!=g_delta_max||g_form_view!=(int)g_view_mode||g_form_mode!=g_close_mode);
        uint abg=dirty?Argb(0x1E40AF,255):Argb(0x1A2234,255);
        g_canvas.FillRectangle(MNU_X+10,cy,MNU_X+MNU_W-10,cy+34,abg);
        g_canvas.Rectangle(MNU_X+10,cy,MNU_X+MNU_W-10,cy+34,Argb(0x334155,255));
        g_canvas.FontSet("Arial Bold",10);
        g_canvas.TextOut(MNU_X+MNU_W/2-22,cy+10,"Aplicar",Argb(dirty?(color)0xFFFFFF:(color)0x475569,255));
    }
    else
    {
        MnuColorRow(cy,"BID (VENDA)",g_color_bid);  cy+=50;
        MnuColorRow(cy,"ASK (COMPRA)",g_color_ask); cy+=50;
        MnuColorRow(cy,"POC (BORDA)",g_color_poc);  cy+=50;
        g_canvas.FontSet("Arial",8);
        g_canvas.TextOut(MNU_X+32,cy+6,"Cores salvas automaticamente",Argb(0x475569,255));
    }
}

void HandleMenuClick(int mx, int my)
{
    // Gear button
    if(mx>=5&&mx<=33&&my>=8&&my<=36)
    {
        g_menu_open=!g_menu_open;
        if(g_menu_open){g_form_step=g_step_mult;g_form_delta=g_delta_max;g_form_view=(int)g_view_mode;g_form_mode=g_close_mode;}
        Redraw(); return;
    }
    if(!g_menu_open) return;
    // X button
    if(mx>=MNU_X+MNU_W-22&&my>=MNU_Y&&my<=MNU_Y+34){g_menu_open=false;Redraw();return;}
    // Tabs
    int tabY=MNU_Y+42, mid=MNU_X+MNU_W/2;
    if(my>=tabY&&my<=tabY+30)
    {
        if(mx>=MNU_X+10&&mx<mid){g_menu_tab=0;Redraw();return;}
        if(mx>=mid&&mx<=MNU_X+MNU_W-10){g_menu_tab=1;Redraw();return;}
    }
    int cy=tabY+38;
    if(g_menu_tab==0)
    {
        cy+=16;
        if(my>=cy&&my<=cy+30){if(mx<mid)g_form_view=0;else g_form_view=1;Redraw();return;}
        cy+=38+16;
        if(my>=cy&&my<=cy+32){if(mx<=MNU_X+42)g_form_step=MathMax(1,g_form_step-50);else if(mx>=MNU_X+MNU_W-42)g_form_step+=50;Redraw();return;}
        cy+=40+16;
        if(my>=cy&&my<=cy+32){if(g_form_mode=="delta")g_form_mode="volume";else if(g_form_mode=="volume")g_form_mode="range";else if(g_form_mode=="range")g_form_mode="time";else g_form_mode="delta";Redraw();return;}
        cy+=40+16;
        if(my>=cy&&my<=cy+32){if(mx<=MNU_X+42)g_form_delta=MathMax(200,g_form_delta-200);else if(mx>=MNU_X+MNU_W-42)g_form_delta+=200;Redraw();return;}
        cy+=44;
        if(my>=cy&&my<=cy+34&&mx>=MNU_X+10&&mx<=MNU_X+MNU_W-10)
        {
            g_step_mult=g_form_step; g_delta_max=g_form_delta;
            g_view_mode=(ENUM_VIEW)g_form_view; g_close_mode=g_form_mode;
            Reload(); return;
        }
    }
    else
    {
        int rx=MNU_X+MNU_W-10;
        if(my>=cy+4&&my<=cy+36&&mx>=rx-40&&mx<=rx-4){ OpenColorPicker(PICK_GLOBAL_BID, rx-40, cy+36); return; }
        cy+=50;
        if(my>=cy+4&&my<=cy+36&&mx>=rx-40&&mx<=rx-4){ OpenColorPicker(PICK_GLOBAL_ASK, rx-40, cy+36); return; }
        cy+=50;
        if(my>=cy+4&&my<=cy+36&&mx>=rx-40&&mx<=rx-4){ OpenColorPicker(PICK_GLOBAL_POC, rx-40, cy+36); return; }
    }
}

//+------------------------------------------------------------------+
//| Eixo de preço                                                     |
//+------------------------------------------------------------------+
void DrawPriceAxis(int x0, int chart_h, double pmin, double pmax)
{
    double prange=pmax-pmin; if(prange<=0) return;
    g_canvas.FillRectangle(x0,0,g_canvas_w-1,chart_h,Argb(InpColorBg,255));
    g_canvas.Line(x0,0,x0,chart_h,Argb(0x2A364F,255));
    double step=g_step*10,nL=prange/step;
    if(nL>20) step*=MathCeil(nL/20.0);
    for(double p=MathCeil(pmin/step)*step;p<=pmax;p+=step)
    {
        int y=chart_h-1-(int)((p-pmin)/prange*(chart_h-4));
        if(y<5||y>chart_h-5) continue;
        g_canvas.Line(x0,y,x0+4,y,Argb(0x475569,255));
        TxtOut(x0+7,y-5,DoubleToString(p,_Digits),Argb(0x64748B,255),"Arial",InpFontSize);
    }
}

//+------------------------------------------------------------------+
//| Conversores pixel ↔ preço/cluster (usam estado do último Redraw) |
//+------------------------------------------------------------------+
int PriceToY(double price)
{
    if(g_rdr_chart_h<=0||g_rdr_pmax<=g_rdr_pmin) return 0;
    return g_rdr_chart_h-1-(int)((price-g_rdr_pmin)/(g_rdr_pmax-g_rdr_pmin)*(g_rdr_chart_h-4));
}
double YToPrice(int y)
{
    if(g_rdr_chart_h<=0||g_rdr_pmax<=g_rdr_pmin) return 0;
    return g_rdr_pmin+(double)(g_rdr_chart_h-1-y)*(g_rdr_pmax-g_rdr_pmin)/(g_rdr_chart_h-4);
}
// X canvas → índice absoluto do cluster no histórico
int XToClusterIdx(int x)
{
    if(g_rdr_col_step<=0) return 0;
    int ref_x=g_rdr_chart_x1-g_rdr_col_step*(3+g_rdr_active_off)-g_rdr_cw;
    int steps=(ref_x-x)/g_rdr_col_step;
    if(steps<0) steps=0;
    return MathMax(0,MathMin(g_history_count-1, g_rdr_last_idx-steps));
}
// Índice absoluto → X esquerdo do cluster no canvas (-1 = fora da área)
int ClusterToX(int ci)
{
    if(g_rdr_col_step<=0) return -1;
    int steps=g_rdr_last_idx-ci;
    if(steps<0) return -1;
    return g_rdr_chart_x1-g_rdr_col_step*(3+g_rdr_active_off+steps)-g_rdr_cw;
}

//+------------------------------------------------------------------+
//| Zona — fill antes dos clusters, borda depois                     |
//+------------------------------------------------------------------+
void DrawZoneFills(int chart_h, double pmin, double pmax)
{
    for(int zi=0;zi<g_zone_count;zi++)
    {
        if(!g_zones[zi].active) continue;
        if(g_zones[zi].sobre_clusters) continue;  // será desenhado após os clusters
        // ci_from = older (menor índice) = lado ESQUERDO (X menor)
        // ci_to   = newer (maior índice) = lado DIREITO  (X maior)
        int x1=ClusterToX(g_zones[zi].ci_from);
        int x2=ClusterToX(g_zones[zi].ci_to)+g_rdr_cw;
        if(g_zones[zi].raio_dir) x2=g_rdr_chart_x1;
        if(g_zones[zi].raio_esq) x1=0;
        if(x1<0) x1=0;
        if(x2<=x1||x2<0) continue;
        double prange=pmax-pmin;
        int y1=chart_h-1-(int)((g_zones[zi].price_high-pmin)/prange*(chart_h-4));
        int y2=chart_h-1-(int)((g_zones[zi].price_low -pmin)/prange*(chart_h-4));
        if(y1>y2){int t=y1;y1=y2;y2=t;}
        y1=MathMax(0,y1); y2=MathMin(chart_h-1,y2);
        uint fill=Blend(g_zones[zi].border_clr,(color)InpColorBg,0.10);
        g_canvas.FillRectangle(x1,y1,x2,y2,0xFF000000|fill);
    }
}
void DrawZoneBorders(int chart_h, double pmin, double pmax)
{
    for(int zi=0;zi<g_zone_count;zi++)
    {
        if(!g_zones[zi].active) continue;
        int x1=ClusterToX(g_zones[zi].ci_from);
        int x2=ClusterToX(g_zones[zi].ci_to)+g_rdr_cw;
        if(g_zones[zi].raio_dir) x2=g_rdr_chart_x1;
        if(g_zones[zi].raio_esq) x1=0;
        if(x1<0) x1=0;
        if(x2<=x1) continue;
        double prange=pmax-pmin;
        int y1=chart_h-1-(int)((g_zones[zi].price_high-pmin)/prange*(chart_h-4));
        int y2=chart_h-1-(int)((g_zones[zi].price_low -pmin)/prange*(chart_h-4));
        if(y1>y2){int t=y1;y1=y2;y2=t;}
        y1=MathMax(0,y1); y2=MathMin(chart_h-1,y2);
        if(g_zones[zi].sobre_clusters)
        {
            uint fill=Blend(g_zones[zi].border_clr,(color)InpColorBg,0.25);
            g_canvas.FillRectangle(x1,y1,x2,y2,0xFF000000|fill);
        }
        // Destacar zona selecionada
        if(g_zone_panel && zi==g_zone_sel)
            g_canvas.Rectangle(x1-1,y1-1,x2+1,y2+1,Argb(0xFFFFFF,255));
        g_canvas.Rectangle(x1,y1,x2,y2,Argb(g_zones[zi].border_clr,255));
    }
}

//+------------------------------------------------------------------+
//| Volume Profile — desenhado sobre os clusters                     |
//+------------------------------------------------------------------+
void CalcVProfile(SVProfile &vp, int ci_from, int ci_to,
                  double price_high, double price_low)
{
    vp.ci_from=ci_from; vp.ci_to=ci_to;
    vp.price_high=price_high; vp.price_low=price_low;
    vp.show_volume=true; vp.show_delta=false; vp.delta_espelhado=true; vp.volume_soma=false;
    vp.show_poc=true; vp.show_va=true; vp.va_pct=70.0; vp.show_vwap=false;
    vp.sobre_clusters=false;
    vp.clr_bid=g_color_bid; vp.clr_ask=g_color_ask; vp.clr_poc=(color)0xFFD600;
    vp.clr_borda=(color)0x2A364F; vp.count=0;
    ArrayInitialize(vp.prices,0); ArrayInitialize(vp.vol_bid,0); ArrayInitialize(vp.vol_ask,0);

    double cum_pv=0, cum_v=0;
    // Percorre clusters na faixa
    for(int ci=ci_from;ci<=ci_to&&ci<g_history_count;ci++)
    {
        int hi=HIdx(ci);
        for(int li=0;li<g_history[hi].level_count;li++)
        {
            double p=g_history[hi].levels[li].price;
            if(p<price_low-g_step||p>price_high+g_step) continue;
            double bin=MathRound(p/g_step)*g_step;
            int idx=-1;
            for(int k=0;k<vp.count;k++) if(MathAbs(vp.prices[k]-bin)<1e-8){idx=k;break;}
            if(idx<0)
            {
                if(vp.count>=VP_LEVELS) continue;
                idx=vp.count++;
                vp.prices[idx]=bin; vp.vol_bid[idx]=0; vp.vol_ask[idx]=0;
            }
            vp.vol_bid[idx]+=g_history[hi].levels[li].bid;
            vp.vol_ask[idx]+=g_history[hi].levels[li].ask;
            double vol=g_history[hi].levels[li].bid+g_history[hi].levels[li].ask;
            cum_pv+=bin*vol; cum_v+=vol;
        }
    }
    vp.vwap_price=(cum_v>0)?cum_pv/cum_v:0;

    // POC — nível com maior volume total
    double mx=-1; vp.poc_price=0;
    double total_vol=0;
    for(int i=0;i<vp.count;i++)
    {
        double t=vp.vol_bid[i]+vp.vol_ask[i];
        if(t>mx){mx=t;vp.poc_price=vp.prices[i];}
        total_vol+=t;
    }

    // VAH/VAL — expansão 70% a partir do POC
    vp.vah_price=vp.poc_price; vp.val_price=vp.poc_price;
    if(total_vol>0&&mx>0)
    {
        double poc_vol=0;
        for(int i=0;i<vp.count;i++) if(MathAbs(vp.prices[i]-vp.poc_price)<1e-8){poc_vol=vp.vol_bid[i]+vp.vol_ask[i];break;}
        double cum=poc_vol, target=total_vol*(vp.va_pct/100.0);
        double up=vp.poc_price+g_step, lo=vp.poc_price-g_step;
        while(cum<target)
        {
            double up_v=0,lo_v=0;
            for(int i=0;i<vp.count;i++)
            {
                if(MathAbs(vp.prices[i]-up)<1e-8) up_v=vp.vol_bid[i]+vp.vol_ask[i];
                if(MathAbs(vp.prices[i]-lo)<1e-8) lo_v=vp.vol_bid[i]+vp.vol_ask[i];
            }
            if(up_v<=0&&lo_v<=0) break;
            if(up_v>=lo_v){cum+=up_v;vp.vah_price=up;up+=g_step;}
            else           {cum+=lo_v;vp.val_price=lo;lo-=g_step;}
        }
    }
    vp.active=true;
}

// VA overlay: retângulo semi-transparente sobre TODA a largura do gráfico
// Deve ser chamado ANTES dos clusters
void DrawVAOverlays(int chart_h, double pmin, double pmax)
{
    double prange=pmax-pmin;
    for(int vi=0;vi<g_vp_count;vi++)
    {
        if(!g_vprofiles[vi].active||!g_vprofiles[vi].show_va||g_vprofiles[vi].poc_price<=0) continue;
        int vah_y=chart_h-1-(int)((g_vprofiles[vi].vah_price-pmin)/prange*(chart_h-4));
        int val_y=chart_h-1-(int)((g_vprofiles[vi].val_price-pmin)/prange*(chart_h-4));
        if(vah_y>val_y){int t=vah_y;vah_y=val_y;val_y=t;}
        vah_y=MathMax(0,vah_y); val_y=MathMin(chart_h-1,val_y);
        uint fill=Blend(g_vprofiles[vi].clr_ask,(color)InpColorBg,0.14);
        g_canvas.FillRectangle(0,vah_y,g_rdr_chart_x1,val_y,fill);
    }
}

// behind=true → desenha VPs que ficam ATRÁS dos clusters (sobre_clusters=false)
// behind=false → desenha VPs que ficam NA FRENTE dos clusters (sobre_clusters=true)
void DrawVProfiles(int chart_h, double pmin, double pmax, bool behind)
{
    int cw = g_rdr_chart_x1;  // largura total do gráfico (para linhas full-width)

    for(int vi=0;vi<g_vp_count;vi++)
    {
        if(!g_vprofiles[vi].active||g_vprofiles[vi].count<=0) continue;
        // Filtro de passe: sobre_clusters==behind significa que é o passe errado
        if(g_vprofiles[vi].sobre_clusters==behind) continue;

        int x1=ClusterToX(g_vprofiles[vi].ci_from);
        int x2=ClusterToX(g_vprofiles[vi].ci_to)+g_rdr_cw;
        if(x1<0) x1=0;
        if(x2<=x1) continue;

        // Painel do histograma: largura máxima 140px a partir de x1
        int bar_max=MathMin(140, x2-x1);
        int bx1=x1, bx2=x1+bar_max;

        color fundo=(color)0x080C16;
        g_canvas.FillRectangle(bx1,0,bx2,chart_h,Argb(fundo,255));
        if(g_vp_panel&&vi==g_vp_sel)
            g_canvas.Rectangle(bx1-1,0,bx2+1,chart_h-1,Argb(0xFFFFFF,255));
        g_canvas.Rectangle(bx1,0,bx2,chart_h-1,Argb(g_vprofiles[vi].clr_borda,255));

        double max_vol=1;
        for(int i=0;i<g_vprofiles[vi].count;i++){double t=g_vprofiles[vi].vol_bid[i]+g_vprofiles[vi].vol_ask[i];if(t>max_vol)max_vol=t;}
        double max_delta=1;
        for(int i=0;i<g_vprofiles[vi].count;i++){double d=MathAbs(g_vprofiles[vi].vol_ask[i]-g_vprofiles[vi].vol_bid[i]);if(d>max_delta)max_delta=d;}

        double prange=pmax-pmin;
        color clr_bid=g_vprofiles[vi].clr_bid;
        color clr_ask=g_vprofiles[vi].clr_ask;

        for(int i=0;i<g_vprofiles[vi].count;i++)
        {
            double price=g_vprofiles[vi].prices[i];
            int yt=chart_h-1-(int)((price+g_step*0.5-pmin)/prange*(chart_h-4));
            int yb=chart_h-1-(int)((price-g_step*0.5-pmin)/prange*(chart_h-4));
            if(yt>yb){int t=yt;yt=yb;yb=t;}
            if(yb<0||yt>chart_h) continue;
            yt=MathMax(0,yt); yb=MathMin(chart_h-1,yb);

            bool in_va=(g_vprofiles[vi].show_va&&price>=g_vprofiles[vi].val_price&&price<=g_vprofiles[vi].vah_price);
            double alpha_out=0.30;

            if(g_vprofiles[vi].show_volume)
            {
                double total=g_vprofiles[vi].vol_bid[i]+g_vprofiles[vi].vol_ask[i];
                int bw=(int)(total/max_vol*(bar_max-2));
                if(bw<1&&total>0) bw=1;
                if(g_vprofiles[vi].volume_soma)
                {
                    uint c=in_va?Argb(clr_ask,255):Blend(clr_ask,fundo,alpha_out);
                    if(bw>0) g_canvas.FillRectangle(bx1+1,yt,bx1+bw,yb,c);
                }
                else
                {
                    int bw_bid=(total>0)?(int)(g_vprofiles[vi].vol_bid[i]/total*bw):0;
                    int bw_ask=bw-bw_bid;
                    uint c_bid=in_va?Argb(clr_bid,255):Blend(clr_bid,fundo,alpha_out);
                    uint c_ask=in_va?Argb(clr_ask,255):Blend(clr_ask,fundo,alpha_out);
                    if(bw_bid>0) g_canvas.FillRectangle(bx1+1,yt,bx1+bw_bid,yb,c_bid);
                    if(bw_ask>0) g_canvas.FillRectangle(bx1+1+bw_bid,yt,bx1+bw,yb,c_ask);
                }
            }

            if(g_vprofiles[vi].show_delta)
            {
                double delta=g_vprofiles[vi].vol_ask[i]-g_vprofiles[vi].vol_bid[i];
                int bw=(int)(MathAbs(delta)/max_delta*(bar_max/2-2));
                if(bw<1&&delta!=0) bw=1;
                bool pos=(delta>=0);
                uint c=pos?(in_va?Argb(clr_ask,255):Blend(clr_ask,fundo,alpha_out))
                          :(in_va?Argb(clr_bid,255):Blend(clr_bid,fundo,alpha_out));
                int cx_delta=bx1+bar_max/2;
                if(g_vprofiles[vi].delta_espelhado)
                {
                    if(pos) g_canvas.FillRectangle(cx_delta,yt,cx_delta+bw,yb,c);
                    else    g_canvas.FillRectangle(cx_delta-bw,yt,cx_delta,yb,c);
                }
                else    g_canvas.FillRectangle(bx1+1,yt,bx1+bw,yb,c);
            }
        }

        // POC — linha no painel + linha pontilhada por todo o gráfico
        if(g_vprofiles[vi].show_poc&&g_vprofiles[vi].poc_price>0)
        {
            int poc_y=chart_h-1-(int)((g_vprofiles[vi].poc_price-pmin)/prange*(chart_h-4));
            if(poc_y>=0&&poc_y<chart_h)
            {
                for(int xx=bx1;xx<=bx2;xx++) g_canvas.PixelSet(xx,poc_y,Argb(g_vprofiles[vi].clr_poc,255));
                for(int xx=bx2;xx<cw;xx++) g_canvas.PixelSet(xx,poc_y,Argb(g_vprofiles[vi].clr_poc,255));
            }
        }
        // VAH/VAL — linhas pontilhadas por todo o gráfico
        if(g_vprofiles[vi].show_va&&g_vprofiles[vi].poc_price>0)
        {
            int vah_y=chart_h-1-(int)((g_vprofiles[vi].vah_price-pmin)/prange*(chart_h-4));
            for(int xx=0;xx<cw;xx+=8) g_canvas.Line(xx,vah_y,MathMin(xx+4,cw),vah_y,Argb(0x94A3B8,255));
            int val_y=chart_h-1-(int)((g_vprofiles[vi].val_price-pmin)/prange*(chart_h-4));
            for(int xx=0;xx<cw;xx+=8) g_canvas.Line(xx,val_y,MathMin(xx+4,cw),val_y,Argb(0x94A3B8,255));
        }
        // VWAP — linha pontilhada por todo o gráfico
        if(g_vprofiles[vi].show_vwap&&g_vprofiles[vi].vwap_price>0)
        {
            int vy=chart_h-1-(int)((g_vprofiles[vi].vwap_price-pmin)/prange*(chart_h-4));
            if(vy>=0&&vy<chart_h)
                for(int xx=bx2;xx<cw;xx+=8) g_canvas.Line(xx,vy,MathMin(xx+5,cw),vy,Argb(0xFF4081,255));
        }
    }
}

//+------------------------------------------------------------------+
//| Painel de configuração de zona                                   |
//+------------------------------------------------------------------+
void ZonePanelPos(int &px, int &py)
{
    int pw=244, ph=205;
    px=g_zpx; py=g_zpy;
    if(px+pw>g_canvas_w) px=g_canvas_w-pw-4;
    if(py+ph>g_canvas_h) py=g_canvas_h-ph-4;
    if(px<0) px=4;
    if(py<0) py=4;
}

void DrawZoneCheck(int x, int y, bool val, string lbl)
{
    g_canvas.Rectangle(x,y,x+12,y+12,Argb(0x475569,255));
    if(val)
    {
        g_canvas.Line(x+2,y+7,x+5,y+11,Argb(0x22C55E,255));
        g_canvas.Line(x+5,y+11,x+10,y+3,Argb(0x22C55E,255));
    }
    g_canvas.FontSet("Arial",9);
    g_canvas.TextOut(x+16,y,lbl,Argb(0xCBD5E1,255),TA_LEFT|TA_TOP);
}

void DrawZonePanel()
{
    if(!g_zone_panel||g_zone_sel<0||g_zone_sel>=g_zone_count) return;
    int pw=244, ph=205;
    int px, py; ZonePanelPos(px,py);

    g_canvas.FillRectangle(px,py,px+pw,py+ph,Argb(0x0F1520,255));
    g_canvas.Rectangle(px,py,px+pw,py+ph,Argb(0x2A364F,255));

    // Header
    g_canvas.FillRectangle(px,py,px+pw,py+30,Argb(0x080E18,255));
    g_canvas.FontSet("Arial Bold",10);
    g_canvas.TextOut(px+10,py+8,StringFormat("Zona #%d",g_zone_sel+1),Argb(0xFF4081,255),TA_LEFT|TA_TOP);
    g_canvas.FontSet("Arial Bold",14);
    g_canvas.TextOut(px+pw-18,py+5,"×",Argb(0x94A3B8,255),TA_LEFT|TA_TOP);

    // Info preço
    int cy=py+36; int lx=px+10; int vx=px+118;
    g_canvas.FontSet("Arial",9);
    g_canvas.TextOut(lx,cy,"Preço alto:",Argb(0x64748B,255),TA_LEFT|TA_TOP);
    g_canvas.TextOut(vx,cy,DoubleToString(g_zones[g_zone_sel].price_high,2),Argb(0xE2E8F0,255),TA_LEFT|TA_TOP);
    cy+=18;
    g_canvas.TextOut(lx,cy,"Preço baixo:",Argb(0x64748B,255),TA_LEFT|TA_TOP);
    g_canvas.TextOut(vx,cy,DoubleToString(g_zones[g_zone_sel].price_low,2),Argb(0xE2E8F0,255),TA_LEFT|TA_TOP);
    cy+=22;

    // Separador
    g_canvas.Line(px+4,cy,px+pw-4,cy,Argb(0x1E293B,255));
    cy+=8;

    // Cor borda
    g_canvas.TextOut(lx,cy,"Cor borda:",Argb(0x64748B,255),TA_LEFT|TA_TOP);
    color bc=g_zones[g_zone_sel].border_clr;
    g_canvas.FillRectangle(vx,cy,vx+32,cy+14,Argb(bc,255));
    g_canvas.Rectangle(vx,cy,vx+32,cy+14,Argb(0x475569,255));
    g_canvas.FontSet("Arial",8);
    g_canvas.TextOut(vx+36,cy+2,"← clique",Argb(0x475569,255),TA_LEFT|TA_TOP);
    cy+=24;

    // Separador
    g_canvas.Line(px+4,cy,px+pw-4,cy,Argb(0x1E293B,255));
    cy+=8;

    // Checkboxes
    DrawZoneCheck(lx,cy,g_zones[g_zone_sel].raio_esq,"Raio esquerdo");
    DrawZoneCheck(px+130,cy,g_zones[g_zone_sel].raio_dir,"Raio direito");
    cy+=22;
    DrawZoneCheck(px+130,cy,g_zones[g_zone_sel].sobre_clusters,"Sobre os clusters");
    cy+=26;

    // Separador
    g_canvas.Line(px+4,cy,px+pw-4,cy,Argb(0x1E293B,255));
    cy+=8;

    // Botão excluir
    g_canvas.FillRectangle(px+10,cy,px+pw-10,cy+24,Argb(0x7F1D1D,255));
    g_canvas.Rectangle(px+10,cy,px+pw-10,cy+24,Argb(0xEF4444,255));
    g_canvas.FontSet("Arial Bold",9);
    g_canvas.TextOut(px+pw/2,cy+6,"Excluir zona",Argb(0xFFFFFF,255),TA_CENTER|TA_TOP);
}

int HitTestZone(int mx, int my)
{
    if(g_rdr_col_step<=0) return -1;
    int chart_h=g_canvas_h-InpBottomPanel;
    if(my<0||my>=chart_h) return -1;
    for(int zi=0;zi<g_zone_count;zi++)
    {
        if(!g_zones[zi].active) continue;
        int x1=ClusterToX(g_zones[zi].ci_from);
        int x2=ClusterToX(g_zones[zi].ci_to)+g_rdr_cw;
        if(g_zones[zi].raio_dir) x2=g_rdr_chart_x1;
        if(g_zones[zi].raio_esq) x1=0;
        if(x1<0) x1=0;
        if(mx<x1||mx>x2) continue;
        int y1=PriceToY(g_zones[zi].price_high);
        int y2=PriceToY(g_zones[zi].price_low);
        if(y1>y2){int t=y1;y1=y2;y2=t;}
        if(my>=y1&&my<=y2) return zi;
    }
    return -1;
}

void DrawColorPicker()
{
    int px=g_pick_px, py=g_pick_py;
    g_canvas.FillRectangle(px,py,px+PICK_W,py+PICK_H,Argb(0x0F1520,255));
    g_canvas.Rectangle(px,py,px+PICK_W,py+PICK_H,Argb(0x475569,255));
    g_canvas.FillRectangle(px,py,px+PICK_W,py+30,Argb(0x080E18,255));
    g_canvas.FontSet("Arial Bold",9);
    g_canvas.TextOut(px+8,py+9,"Selecionar Cor",Argb(0xE2E8F0,255),TA_LEFT|TA_TOP);
    g_canvas.TextOut(px+PICK_W-18,py+8,"✕",Argb(0xEF4444,255),TA_LEFT|TA_TOP);
    g_canvas.Line(px,py+30,px+PICK_W,py+30,Argb(0x2A364F,255));
    int n=ArraySize(g_pick_palette);
    for(int r=0;r<PICK_ROWS;r++)
        for(int c=0;c<PICK_COLS;c++)
        {
            int idx=r*PICK_COLS+c; if(idx>=n) break;
            int sx=px+PICK_PAD+c*(PICK_SW+PICK_GAP);
            int sy=py+32+PICK_PAD/2+r*(PICK_SH+PICK_GAP);
            g_canvas.FillRectangle(sx,sy,sx+PICK_SW-1,sy+PICK_SH-1,Argb(g_pick_palette[idx],255));
            g_canvas.Rectangle(sx,sy,sx+PICK_SW-1,sy+PICK_SH-1,Argb(0x2A364F,255));
        }
}

void ApplyPickedColor(color c)
{
    switch(g_pick_target)
    {
        case PICK_ZONE_BORDER:  if(g_zone_sel>=0) g_zones[g_zone_sel].border_clr=c; break;
        case PICK_VP_BID:       if(g_vp_sel>=0)   g_vprofiles[g_vp_sel].clr_bid=c; break;
        case PICK_VP_ASK:       if(g_vp_sel>=0)   g_vprofiles[g_vp_sel].clr_ask=c; break;
        case PICK_VP_POC:       if(g_vp_sel>=0)   g_vprofiles[g_vp_sel].clr_poc=c; break;
        case PICK_GLOBAL_BID:   g_color_bid=c; break;
        case PICK_GLOBAL_ASK:   g_color_ask=c; break;
        case PICK_GLOBAL_POC:   g_color_poc=c; break;
        default: break;
    }
}

void HandleColorPickerClick(int mx, int my)
{
    int px=g_pick_px, py=g_pick_py;
    if(mx>=px+PICK_W-22&&my>=py&&my<=py+30){ g_pick_open=false; Redraw(); return; }
    int gx=mx-(px+PICK_PAD);
    int gy=my-(py+32+PICK_PAD/2);
    if(gx<0||gy<0) return;
    int col=gx/(PICK_SW+PICK_GAP), row=gy/(PICK_SH+PICK_GAP);
    if(col<0||col>=PICK_COLS||row<0||row>=PICK_ROWS) return;
    if(gx%(PICK_SW+PICK_GAP)>=PICK_SW||gy%(PICK_SH+PICK_GAP)>=PICK_SH) return;
    int idx=row*PICK_COLS+col;
    if(idx>=ArraySize(g_pick_palette)) return;
    ApplyPickedColor(g_pick_palette[idx]);
    g_pick_open=false;
    Redraw();
}

void OpenColorPicker(EPICK_TARGET target, int near_x, int near_y)
{
    g_pick_target=target;
    g_pick_px=near_x; g_pick_py=near_y;
    if(g_pick_px+PICK_W>g_canvas_w) g_pick_px=g_canvas_w-PICK_W-4;
    if(g_pick_py+PICK_H>g_canvas_h) g_pick_py=g_canvas_h-PICK_H-4;
    if(g_pick_px<0) g_pick_px=4;
    if(g_pick_py<0) g_pick_py=4;
    g_pick_open=true;
    Redraw();
}

void HandleZonePanelClick(int mx, int my)
{
    if(g_zone_sel<0||g_zone_sel>=g_zone_count) return;
    int pw=244, ph=205;
    int px, py; ZonePanelPos(px,py);

    // Botão ✕ fechar
    if(mx>=px+pw-22&&my>=py&&my<=py+30)
    { g_zone_panel=false; g_zone_sel=-1; Redraw(); return; }

    int cy=py+36+18+22+8;   // posição após preços e separador = py+84
    // Cor borda swatch (vx=px+118, cy..cy+14)
    if(mx>=px+118&&mx<=px+150&&my>=cy&&my<=cy+14)
    { OpenColorPicker(PICK_ZONE_BORDER, px+118, cy+16); return; }
    cy+=24+8;   // cy = py+116: checkboxes row 1

    // Raio esquerdo (px+10, cy)
    if(mx>=px+10&&mx<=px+22&&my>=cy&&my<=cy+12)
    { g_zones[g_zone_sel].raio_esq=!g_zones[g_zone_sel].raio_esq; Redraw(); return; }
    // Raio direito (px+130, cy)
    if(mx>=px+130&&mx<=px+142&&my>=cy&&my<=cy+12)
    { g_zones[g_zone_sel].raio_dir=!g_zones[g_zone_sel].raio_dir; Redraw(); return; }
    cy+=22;     // cy = py+138: checkboxes row 2

    // Sobre os clusters (px+130, cy)
    if(mx>=px+130&&mx<=px+142&&my>=cy&&my<=cy+12)
    { g_zones[g_zone_sel].sobre_clusters=!g_zones[g_zone_sel].sobre_clusters; Redraw(); return; }
    cy+=26+8;   // cy = py+172: excluir button

    // Botão excluir
    if(mx>=px+10&&mx<=px+pw-10&&my>=cy&&my<=cy+24)
    {
        for(int i=g_zone_sel;i<g_zone_count-1;i++) g_zones[i]=g_zones[i+1];
        g_zone_count--;
        g_zone_panel=false; g_zone_sel=-1; Redraw(); return;
    }
}

//+------------------------------------------------------------------+
//| Painel de configuração de VP                                     |
//+------------------------------------------------------------------+
void VPPanelPos(int &px, int &py)
{
    int pw=290, ph=280;
    px=g_vppx; py=g_vppy;
    if(px+pw>g_canvas_w) px=g_canvas_w-pw-4;
    if(py+ph>g_canvas_h) py=g_canvas_h-ph-4;
    if(px<0) px=4;
    if(py<0) py=4;
}

void DrawVPCheck(int x, int y, bool val, string lbl)
{
    g_canvas.Rectangle(x,y,x+12,y+12,Argb(0x475569,255));
    if(val){g_canvas.Line(x+2,y+7,x+5,y+11,Argb(0x22C55E,255));g_canvas.Line(x+5,y+11,x+10,y+3,Argb(0x22C55E,255));}
    g_canvas.FontSet("Arial",9);
    g_canvas.TextOut(x+16,y,lbl,Argb(0xCBD5E1,255),TA_LEFT|TA_TOP);
}

void DrawVPSwatch(int x, int y, color c, string lbl)
{
    g_canvas.FontSet("Arial",8);
    g_canvas.TextOut(x,y,lbl,Argb(0x64748B,255),TA_LEFT|TA_TOP);
    g_canvas.FillRectangle(x,y+12,x+28,y+26,Argb(c,255));
    g_canvas.Rectangle(x,y+12,x+28,y+26,Argb(0x475569,255));
}

void DrawVPPanel()
{
    if(!g_vp_panel||g_vp_sel<0||g_vp_sel>=g_vp_count) return;
    int pw=290, ph=280;
    int px, py; VPPanelPos(px,py);

    g_canvas.FillRectangle(px,py,px+pw,py+ph,Argb(0x0F1520,255));
    g_canvas.Rectangle(px,py,px+pw,py+ph,Argb(0x2A364F,255));

    // Header
    g_canvas.FillRectangle(px,py,px+pw,py+30,Argb(0x080E18,255));
    g_canvas.FontSet("Arial Bold",10);
    g_canvas.TextOut(px+10,py+8,StringFormat("VP #%d",g_vp_sel+1),Argb(0x22C55E,255),TA_LEFT|TA_TOP);
    g_canvas.FontSet("Arial Bold",14);
    g_canvas.TextOut(px+pw-18,py+5,"×",Argb(0x94A3B8,255),TA_LEFT|TA_TOP);

    int cy=py+36; int lx=px+10;

    // Linha: Visualizar — botões Volume / Delta
    g_canvas.FontSet("Arial",9);
    g_canvas.TextOut(lx,cy,"Visualizar:",Argb(0x64748B,255),TA_LEFT|TA_TOP);
    bool sv=g_vprofiles[g_vp_sel].show_volume;
    bool sd=g_vprofiles[g_vp_sel].show_delta;
    uint vol_bg=sv?Argb(0x1E40AF,255):Argb(0x1A2234,255);
    uint del_bg=sd?Argb(0x065F46,255):Argb(0x1A2234,255);
    g_canvas.FillRectangle(px+90,cy-1,px+140,cy+14,vol_bg);
    g_canvas.Rectangle(px+90,cy-1,px+140,cy+14,Argb(0x334155,255));
    g_canvas.TextOut(px+100,cy,"Volume",sv?Argb(0xFFFFFF,255):Argb(0x64748B,255),TA_LEFT|TA_TOP);
    g_canvas.FillRectangle(px+144,cy-1,px+192,cy+14,del_bg);
    g_canvas.Rectangle(px+144,cy-1,px+192,cy+14,Argb(0x334155,255));
    g_canvas.TextOut(px+154,cy,"Delta",sd?Argb(0xFFFFFF,255):Argb(0x64748B,255),TA_LEFT|TA_TOP);
    cy+=22;

    // Separador
    g_canvas.Line(px+4,cy,px+pw-4,cy,Argb(0x1E293B,255)); cy+=6;

    // Cores das barras
    DrawVPSwatch(lx,      cy,g_vprofiles[g_vp_sel].clr_bid,"Bid");
    DrawVPSwatch(lx+50,   cy,g_vprofiles[g_vp_sel].clr_ask,"Ask");
    DrawVPSwatch(lx+100,  cy,g_vprofiles[g_vp_sel].clr_poc,"POC");
    cy+=34;

    // Checkboxes linha 1
    DrawVPCheck(lx,     cy,g_vprofiles[g_vp_sel].volume_soma,    "Soma");
    DrawVPCheck(lx+80,  cy,g_vprofiles[g_vp_sel].delta_espelhado,"Espelhado");
    DrawVPCheck(lx+188, cy,g_vprofiles[g_vp_sel].sobre_clusters, "S/ clusters");
    cy+=22;

    // Separador
    g_canvas.Line(px+4,cy,px+pw-4,cy,Argb(0x1E293B,255)); cy+=6;

    // POC + VA
    DrawVPCheck(lx,    cy,g_vprofiles[g_vp_sel].show_poc, "POC");
    DrawVPCheck(lx+60, cy,g_vprofiles[g_vp_sel].show_va,  "VA");
    // VA% stepper
    g_canvas.FontSet("Arial",9);
    g_canvas.TextOut(lx+130,cy,StringFormat("%.0f%%",g_vprofiles[g_vp_sel].va_pct),Argb(0xE2E8F0,255),TA_LEFT|TA_TOP);
    g_canvas.FillRectangle(lx+152,cy,lx+164,cy+12,Argb(0x1A2234,255));
    g_canvas.Rectangle(lx+152,cy,lx+164,cy+12,Argb(0x334155,255));
    g_canvas.TextOut(lx+154,cy+1,"–",Argb(0xF59E0B,255),TA_LEFT|TA_TOP);
    g_canvas.FillRectangle(lx+166,cy,lx+178,cy+12,Argb(0x1A2234,255));
    g_canvas.Rectangle(lx+166,cy,lx+178,cy+12,Argb(0x334155,255));
    g_canvas.TextOut(lx+168,cy+1,"+",Argb(0x22C55E,255),TA_LEFT|TA_TOP);
    cy+=22;

    // VWAP
    DrawVPCheck(lx,cy,g_vprofiles[g_vp_sel].show_vwap,"VWAP");
    cy+=22;

    // Separador
    g_canvas.Line(px+4,cy,px+pw-4,cy,Argb(0x1E293B,255)); cy+=8;

    // Botão excluir
    g_canvas.FillRectangle(px+10,cy,px+pw-10,cy+24,Argb(0x7F1D1D,255));
    g_canvas.Rectangle(px+10,cy,px+pw-10,cy+24,Argb(0xEF4444,255));
    g_canvas.FontSet("Arial Bold",9);
    g_canvas.TextOut(px+pw/2,cy+6,"Excluir VP",Argb(0xFFFFFF,255),TA_CENTER|TA_TOP);
}

int HitTestVP(int mx, int my)
{
    if(g_rdr_col_step<=0) return -1;
    int chart_h=g_canvas_h-InpBottomPanel;
    if(my<0||my>=chart_h) return -1;
    for(int vi=0;vi<g_vp_count;vi++)
    {
        if(!g_vprofiles[vi].active) continue;
        int x1=ClusterToX(g_vprofiles[vi].ci_from);
        int x2=ClusterToX(g_vprofiles[vi].ci_to)+g_rdr_cw;
        if(x1<0) x1=0;
        if(mx>=x1&&mx<=x2) return vi;
    }
    return -1;
}

void HandleVPPanelClick(int mx, int my)
{
    if(g_vp_sel<0||g_vp_sel>=g_vp_count) return;
    int pw=290, ph=280;
    int px, py; VPPanelPos(px,py);

    // Fechar ×
    if(mx>=px+pw-22&&my>=py&&my<=py+30){g_vp_panel=false;g_vp_sel=-1;Redraw();return;}

    int cy=py+36; int lx=px+10;

    // Botões Volume / Delta (cy=py+36)
    if(my>=cy-1&&my<=cy+14)
    {
        if(mx>=px+90&&mx<=px+140){g_vprofiles[g_vp_sel].show_volume=!g_vprofiles[g_vp_sel].show_volume;Redraw();return;}
        if(mx>=px+144&&mx<=px+192){g_vprofiles[g_vp_sel].show_delta=!g_vprofiles[g_vp_sel].show_delta;Redraw();return;}
    }
    cy+=22+6; // cy=py+64: cores

    // Swatches de cor (cy=py+64)
    if(my>=cy+12&&my<=cy+26)
    {
        if(mx>=lx&&mx<=lx+28)      { OpenColorPicker(PICK_VP_BID, lx,      cy+28); return; }
        if(mx>=lx+50&&mx<=lx+78)   { OpenColorPicker(PICK_VP_ASK, lx+50,   cy+28); return; }
        if(mx>=lx+100&&mx<=lx+128) { OpenColorPicker(PICK_VP_POC, lx+100,  cy+28); return; }
    }
    cy+=34; // cy=py+98: checkboxes linha 1

    // Checkboxes: Soma / Espelhado / S/ clusters (cy=py+98)
    if(my>=cy&&my<=cy+12)
    {
        if(mx>=lx&&mx<=lx+12)       {g_vprofiles[g_vp_sel].volume_soma=!g_vprofiles[g_vp_sel].volume_soma;Redraw();return;}
        if(mx>=lx+80&&mx<=lx+92)    {g_vprofiles[g_vp_sel].delta_espelhado=!g_vprofiles[g_vp_sel].delta_espelhado;Redraw();return;}
        if(mx>=lx+188&&mx<=lx+200)  {g_vprofiles[g_vp_sel].sobre_clusters=!g_vprofiles[g_vp_sel].sobre_clusters;Redraw();return;}
    }
    cy+=22+6; // cy=py+126: POC/VA

    // POC / VA / stepper (cy=py+126)
    if(my>=cy&&my<=cy+12)
    {
        if(mx>=lx&&mx<=lx+12)       {g_vprofiles[g_vp_sel].show_poc=!g_vprofiles[g_vp_sel].show_poc;Redraw();return;}
        if(mx>=lx+60&&mx<=lx+72)    {g_vprofiles[g_vp_sel].show_va=!g_vprofiles[g_vp_sel].show_va;Redraw();return;}
        if(mx>=lx+152&&mx<=lx+164)  // VA% –
        {g_vprofiles[g_vp_sel].va_pct=MathMax(10,g_vprofiles[g_vp_sel].va_pct-5);Redraw();return;}
        if(mx>=lx+166&&mx<=lx+178)  // VA% +
        {g_vprofiles[g_vp_sel].va_pct=MathMin(100,g_vprofiles[g_vp_sel].va_pct+5);Redraw();return;}
    }
    cy+=22; // cy=py+148: VWAP

    if(my>=cy&&my<=cy+12&&mx>=lx&&mx<=lx+12)
    {g_vprofiles[g_vp_sel].show_vwap=!g_vprofiles[g_vp_sel].show_vwap;Redraw();return;}
    cy+=22+8; // cy=py+178: excluir

    if(mx>=px+10&&mx<=px+pw-10&&my>=cy&&my<=cy+24)
    {
        for(int i=g_vp_sel;i<g_vp_count-1;i++) g_vprofiles[i]=g_vprofiles[i+1];
        g_vp_count--;
        g_vp_panel=false; g_vp_sel=-1; Redraw(); return;
    }
}

//+------------------------------------------------------------------+
//| Ferramentas de desenho — seleção por Ctrl+drag                   |
//+------------------------------------------------------------------+
void HandleSelectionToolbar(int mx, int my)
{
    bool in_tb=(mx>=g_seltb_x && mx<g_seltb_x+100 && my>=g_seltb_y && my<g_seltb_y+26);
    if(!in_tb){ g_sel_ready=false; Redraw(); return; }

    int lx=mx-g_seltb_x;
    int sx1=MathMin(g_sel_x0,g_sel_x1), sy1=MathMin(g_sel_y0,g_sel_y1);
    int sx2=MathMax(g_sel_x0,g_sel_x1), sy2=MathMax(g_sel_y0,g_sel_y1);

    if(lx<37)  // Zona
    {
        if(g_zone_count<ZONE_MAX)
        {
            int ci_r=XToClusterIdx(sx2);  // lado direito = cluster mais novo
            int ci_l=XToClusterIdx(sx1);  // lado esquerdo = cluster mais antigo
            if(ci_r>ci_l){int t=ci_r;ci_r=ci_l;ci_l=t;}
            int zn=g_zone_count;
            g_zones[zn].price_high=YToPrice(sy1);
            g_zones[zn].price_low =YToPrice(sy2);
            g_zones[zn].ci_from=ci_r; g_zones[zn].ci_to=ci_l;
            g_zones[zn].border_clr=(color)0xFF4081;
            g_zones[zn].raio_dir=false; g_zones[zn].raio_esq=false;
            g_zones[zn].sobre_clusters=false; g_zones[zn].active=true;
            g_zone_count++;
        }
    }
    else if(lx<59)  // VP
    {
        if(g_vp_count<VP_MAX)
        {
            int ci_r=XToClusterIdx(sx2);
            int ci_l=XToClusterIdx(sx1);
            if(ci_r>ci_l){int t=ci_r;ci_r=ci_l;ci_l=t;}
            CalcVProfile(g_vprofiles[g_vp_count],ci_r,ci_l,YToPrice(sy1),YToPrice(sy2));
            g_vp_count++;
        }
    }
    else if(lx<78)  // Desfazer último
    {
        if(g_vp_count>0)   { g_vp_count--;   g_vprofiles[g_vp_count].active=false; }
        else if(g_zone_count>0){ g_zone_count--; g_zones[g_zone_count].active=false; }
    }
    // else ✕ → apenas fecha

    g_sel_ready=false;
    Redraw();
}

void DrawSelectionOverlay()
{
    if(!g_sel_drag && !g_sel_ready) return;

    int x1=MathMin(g_sel_x0,g_sel_x1), y1=MathMin(g_sel_y0,g_sel_y1);
    int x2=MathMax(g_sel_x0,g_sel_x1), y2=MathMax(g_sel_y0,g_sel_y1);

    // Borda verde da seleção
    g_canvas.Rectangle(x1,y1,x2,y2,Argb(0x00E676,255));

    if(!g_sel_ready) return;

    // Posiciona toolbar abaixo da seleção (ou acima se não cabe)
    int tbx=x1, tby=y2+6;
    if(tby+26>=g_canvas_h) tby=y1-30;
    if(tbx+100>=g_canvas_w) tbx=g_canvas_w-102;
    g_seltb_x=tbx; g_seltb_y=tby;

    // Fundo + borda da toolbar
    g_canvas.FillRectangle(tbx,tby,tbx+99,tby+25,Argb(0x0F1520,255));
    g_canvas.Rectangle(tbx,tby,tbx+99,tby+25,Argb(0x475569,255));

    // Separadores verticais
    for(int dy=3;dy<23;dy++)
    {
        g_canvas.PixelSet(tbx+36,tby+dy,Argb(0x475569,255));
        g_canvas.PixelSet(tbx+58,tby+dy,Argb(0x475569,255));
        g_canvas.PixelSet(tbx+77,tby+dy,Argb(0x475569,255));
    }

    // Rótulos dos botões
    g_canvas.FontSet("Arial Bold",9);
    g_canvas.TextOut(tbx+5, tby+6,"Zona",Argb(0xFF4081,255),TA_LEFT|TA_TOP);
    g_canvas.TextOut(tbx+41,tby+6,"VP",  Argb(0x00E676,255),TA_LEFT|TA_TOP);
    g_canvas.TextOut(tbx+62,tby+6,"↩",  Argb(0xF59E0B,255),TA_LEFT|TA_TOP);
    g_canvas.TextOut(tbx+82,tby+6,"✕",  Argb(0xEF4444,255),TA_LEFT|TA_TOP);
}

//+------------------------------------------------------------------+
//| Redraw                                                            |
//+------------------------------------------------------------------+
void Redraw()
{
    if(g_canvas_w<=0||g_canvas_h<=0) return;

    int cw      = MathMax(1, InpClusterWidth * g_zoom_h / 100);
    int col_gap = MathMax(2,  cw * 15 / 140);  // proporcional ao React (colGap=15*zoomH quando colWidth=140)
    int col_step= cw + col_gap;
    int axis_w  = 70;
    int chart_h = g_canvas_h - InpBottomPanel;

    g_canvas.Erase(Argb(InpColorBg,255));

    // Grade vertical sutil
    for(int x=0;x<g_canvas_w;x+=col_step)
        g_canvas.Line(x,0,x,chart_h,Argb(0x131820,255));

    // Separador painel inferior
    g_canvas.Line(0,chart_h,g_canvas_w,chart_h,Argb(0x1E293B,255));

    if(g_history_count==0&&!g_active_valid)
    {
        TxtOut(g_canvas_w/2-80,g_canvas_h/2,"Aguardando dados...",Argb(InpColorText,255),"Arial",14);
        g_canvas.Update(); return;
    }

    int chart_x1 = g_canvas_w - axis_w;
    int visible  = chart_x1 / col_step + 2;

    int last_idx  = g_history_count - 1 - g_scroll;
    int first_idx = MathMax(0, last_idx - visible + 1);

    // Range de preço dos clusters visíveis
    double pmax=-DBL_MAX, pmin=DBL_MAX;
    for(int ci=first_idx;ci<=last_idx;ci++)
    {
        if(g_history[HIdx(ci)].price_high>pmax)pmax=g_history[HIdx(ci)].price_high;
        if(g_history[HIdx(ci)].price_low <pmin)pmin=g_history[HIdx(ci)].price_low;
    }
    if(g_active_valid)
    {
        if(g_active.price_high>pmax)pmax=g_active.price_high;
        if(g_active.price_low <pmin)pmin=g_active.price_low;
    }
    if(pmax<=pmin){g_canvas.Update();return;}

    // Viewport vertical: SEMPRE max_levels * g_step — igual ao React (rowHeight=zoomV define o viewport)
    // Isso garante zoom out real: g_zoom_v pequeno → muitos níveis visíveis → clusters viram linhas
    {
        int max_levels=MathMax(4,(chart_h-4)/MathMax(g_zoom_v,1));
        double view_range=(double)max_levels*g_step;
        // Centro seguro: usa price_high/low do cluster ativo (nunca poc_price=0)
        double center=(g_active_valid&&g_active.price_high>0)
            ?(g_active.price_high+g_active.price_low)*0.5
            :(pmax+pmin)*0.5;
        pmin=center-view_range*0.5;
        pmax=center+view_range*0.5;
    }

    // Pan vertical: desloca o viewport pelo offset acumulado no drag
    pmin += g_pan_offset;
    pmax += g_pan_offset;
    g_last_prange = pmax - pmin;  // guarda para converter pixels → preço no drag handler

    // Salva estado do render — usado pelas ferramentas de desenho
    g_rdr_cw=cw; g_rdr_col_step=col_step; g_rdr_chart_x1=chart_x1; g_rdr_chart_h=chart_h;
    g_rdr_last_idx=last_idx; g_rdr_pmin=pmin; g_rdr_pmax=pmax;
    g_rdr_active_off=(g_active_valid&&g_scroll==0)?1:0;

    // Camada de fundo: zonas, VA overlay e VPs "atrás" — ANTES dos clusters
    DrawZoneFills(chart_h,pmin,pmax);
    DrawVAOverlays(chart_h,pmin,pmax);
    DrawVProfiles(chart_h,pmin,pmax,true);

    // max_side: escala global das barras do painel inferior
    double max_side=1;
    for(int ci=first_idx;ci<=last_idx;ci++)
    {
        double b=0,a=0;
        for(int li=0;li<g_history[HIdx(ci)].level_count;li++)
        { b+=g_history[HIdx(ci)].levels[li].bid; a+=g_history[HIdx(ci)].levels[li].ask; }
        if(b>max_side)max_side=b; if(a>max_side)max_side=a;
    }

    // Renderiza da direita para a esquerda (com margem direita de 3 colunas)
    int cx_right = chart_x1 - col_step * 3;
    if(g_active_valid && g_scroll==0)
    {
        CCalcPoc(g_active);
        DrawCluster(g_active, cx_right-cw, cw, chart_h, pmin, pmax, max_side, true);
        cx_right -= col_step;
    }
    for(int ci=last_idx; ci>=first_idx && cx_right>0; ci--)
    {
        DrawCluster(g_history[HIdx(ci)], cx_right-cw, cw, chart_h, pmin, pmax, max_side, false);
        cx_right -= col_step;
    }

    // Camada de frente: bordas das zonas + VPs "sobre clusters" — APÓS os clusters
    DrawZoneBorders(chart_h,pmin,pmax);
    DrawVProfiles(chart_h,pmin,pmax,false);

    DrawPriceAxis(chart_x1, chart_h, pmin, pmax);

    // Linha do preço atual (dashed ciano) — desenhada APÓS o eixo para não ser sobrescrita
    if(g_current_price>pmin && g_current_price<pmax)
    {
        double prange=pmax-pmin;
        int yc=chart_h-1-(int)((g_current_price-pmin)/prange*(chart_h-4));
        for(int x=0;x<chart_x1;x+=10)
            g_canvas.Line(x,yc,MathMin(x+6,chart_x1),yc,Argb(0x00E5FF,255));
        // tag na barra de preço
        g_canvas.FillRectangle(chart_x1+2,yc-8,g_canvas_w-2,yc+8,Argb(0x00E5FF,255));
        TxtOut(chart_x1+4,yc-5,DoubleToString(g_current_price,_Digits),Argb(InpColorBg,255),"Arial Bold",InpFontSize);
    }

    // Info atual (step/delta)
    string info="Step: "+DoubleToString(g_step_mult,1)+"x  |  Delta: "+DoubleToString(g_delta_max,0);
    TxtOut(40,5,info,Argb(InpColorText,255),"Arial",InpFontSize);

    DrawSelectionOverlay();
    DrawZonePanel();
    DrawVPPanel();
    DrawGearBtn();
    if(g_menu_open) DrawMenu();
    if(g_pick_open) DrawColorPicker();

    g_canvas.Update();
}

//+------------------------------------------------------------------+
//| OnInit                                                            |
//+------------------------------------------------------------------+
int OnInit()
{
    g_tick_size  = SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE);
    if(g_tick_size<=0) g_tick_size=_Point;
    g_step_mult  = InpStepMultiplier;
    g_delta_max  = InpDeltaMax;
    g_step       = g_tick_size * g_step_mult;
    g_zoom_v     = InpLevelHeight;
    g_view_mode  = InpViewMode;
    g_close_mode = InpCloseMode;
    g_color_ask  = InpColorAsk;
    g_color_bid  = InpColorBid;
    g_color_poc  = InpColorPoc;
    g_form_step  = InpStepMultiplier;
    g_form_delta = InpDeltaMax;
    g_form_view  = (int)InpViewMode;
    g_form_mode  = InpCloseMode;

    ChartSetInteger(0,CHART_MODE,CHART_LINE);
    ChartSetInteger(0,CHART_COLOR_BACKGROUND,(color)InpColorBg);
    ChartSetInteger(0,CHART_COLOR_FOREGROUND,(color)InpColorBg);
    ChartSetInteger(0,CHART_COLOR_CHART_LINE,(color)InpColorBg);
    ChartSetInteger(0,CHART_COLOR_CHART_UP,  (color)InpColorBg);
    ChartSetInteger(0,CHART_COLOR_CHART_DOWN,(color)InpColorBg);
    ChartSetInteger(0,CHART_COLOR_BID,  (color)InpColorBg);
    ChartSetInteger(0,CHART_COLOR_ASK,  (color)InpColorBg);
    ChartSetInteger(0,CHART_COLOR_LAST, (color)InpColorBg);
    ChartSetInteger(0,CHART_SHOW_GRID,        false);
    ChartSetInteger(0,CHART_SHOW_VOLUMES,     false);
    ChartSetInteger(0,CHART_SHOW_OHLC,        false);
    ChartSetInteger(0,CHART_SHOW_BID_LINE,    false);
    ChartSetInteger(0,CHART_SHOW_ASK_LINE,    false);
    ChartSetInteger(0,CHART_SHOW_LAST_LINE,   false);
    ChartSetInteger(0,CHART_SHOW_PERIOD_SEP,  false);
    ChartSetInteger(0,CHART_CROSSHAIR_TOOL,   false);
    ChartSetInteger(0,CHART_SHOW_DATE_SCALE,  false);  // remove eixo de tempo no fundo
    ChartSetInteger(0,CHART_SHOW_PRICE_SCALE, false);  // remove eixo de preço nativo (usamos o nosso)
    ChartSetInteger(0,CHART_SHIFT,            false);  // remove margem direita nativa do MT5
    ChartSetInteger(0,CHART_EVENT_MOUSE_MOVE,1);
    ChartSetInteger(0,CHART_EVENT_MOUSE_WHEEL,1);
    ChartSetInteger(0,CHART_CONTEXT_MENU,false);

    g_canvas_w=(int)ChartGetInteger(0,CHART_WIDTH_IN_PIXELS);
    g_canvas_h=(int)ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS);

    if(!g_canvas.CreateBitmapLabel(0,0,g_canvas_name,0,0,g_canvas_w,g_canvas_h,COLOR_FORMAT_XRGB_NOALPHA))
    { Print("TesteFootprint: erro canvas ",GetLastError()); return INIT_FAILED; }

    ObjectSetInteger(0,g_canvas_name,OBJPROP_ZORDER,10);
    ObjectSetInteger(0,g_canvas_name,OBJPROP_BACK,false);
    ObjectSetInteger(0,g_canvas_name,OBJPROP_SELECTABLE,false);
    ObjectSetInteger(0,g_canvas_name,OBJPROP_SELECTED,false);
    ObjectSetInteger(0,g_canvas_name,OBJPROP_HIDDEN,true);
    ObjectSetInteger(0,g_canvas_name,OBJPROP_XDISTANCE,0);
    ObjectSetInteger(0,g_canvas_name,OBJPROP_YDISTANCE,0);

    ActiveReset();
    LoadHistory();
    Redraw();
    EventSetTimer(1);
    return INIT_SUCCEEDED;
}

void OnTimer()  { ResizeCanvas(); Redraw(); }

void OnDeinit(const int reason)
{
    EventKillTimer();
    g_canvas.Destroy();
    ObjectDelete(0,g_canvas_name);
    ChartSetInteger(0,CHART_MODE,CHART_CANDLES);
    ChartSetInteger(0,CHART_SHOW_GRID,true);
    ChartSetInteger(0,CHART_SHOW_OHLC,true);
    ChartSetInteger(0,CHART_SHOW_BID_LINE,true);
    ChartSetInteger(0,CHART_SHOW_PERIOD_SEP,true);
    ChartSetInteger(0,CHART_CROSSHAIR_TOOL,true);
    ChartSetInteger(0,CHART_CONTEXT_MENU,true);
    ChartRedraw(0);
}

void OnTick()
{
    MqlTick tick;
    if(!SymbolInfoTick(_Symbol,tick)) return;
    if(tick.time_msc<=(long)g_last_tick_msc) return;
    g_last_tick_msc=tick.time_msc;
    double p,v; bool b;
    if(ParseTick(tick,p,v,b)) ProcessTick(p,v,b,tick.time_msc);
    ResizeCanvas();
    ulong now=GetTickCount64();
    if(now-g_last_draw_msc>=50){g_last_draw_msc=now;Redraw();}
}

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
    if(id==CHARTEVENT_CHART_CHANGE){ResizeCanvas();Redraw();return;}

    //--- Teclado ---
    if(id==CHARTEVENT_KEYDOWN)
    {
        if(lparam==37){g_scroll++;Redraw();}                                         // ← scroll
        if(lparam==39){g_scroll=MathMax(0,g_scroll-1);Redraw();}                    // → scroll
        if(lparam==36){g_scroll=0;Redraw();}                                         // Home
        if(lparam==38){g_zoom_v=MathMin(200,g_zoom_v+2);Redraw();}                  // ↑ zoom V+
        if(lparam==40){g_zoom_v=MathMax(1, g_zoom_v-2);Redraw();}                   // ↓ zoom V-
        if(lparam==219){g_step_mult=MathMax(0.5,g_step_mult/2.0);Reload();return;}  // [ step÷2
        if(lparam==221){g_step_mult=MathMin(200,g_step_mult*2.0);Reload();return;}  // ] step×2
        if(lparam==188){g_delta_max=MathMax(100,g_delta_max-200);Reload();return;}  // , delta-200
        if(lparam==190){g_delta_max=g_delta_max+200;Reload();return;}               // . delta+200
        return;
    }

    //--- Mouse Move ---
    if(id==CHARTEVENT_MOUSE_MOVE)
    {
        int mx=(int)lparam, my=(int)dparam;
        bool btn  = ((int)sparam&1)!=0;
        bool ctrl = (TerminalInfoInteger(TERMINAL_KEYSTATE_CONTROL)&0x8000)!=0;
        bool is_sel = ctrl && btn;  // Ctrl+left-drag = seleção de área
        int chart_h=g_canvas_h-InpBottomPanel;
        int axis_x0=g_canvas_w-70;

        // Detecção de click: botão acabou de ser pressionado
        bool just_pressed=(!g_prev_btn&&btn);
        g_prev_btn=btn;

        bool in_gear=(mx>=5&&mx<=33&&my>=8&&my<=36);
        bool in_menu=(g_menu_open&&mx>=MNU_X&&mx<=MNU_X+MNU_W&&my>=MNU_Y&&my<=MNU_Y+450);

        // Hit-test painel de zona
        int zpx=0,zpy=0; if(g_zone_panel&&g_zone_sel>=0) ZonePanelPos(zpx,zpy);
        bool in_zone_panel=(g_zone_panel&&mx>=zpx&&mx<=zpx+244&&my>=zpy&&my<=zpy+205);
        // Hit-test painel de VP
        int vppx=0,vppy=0; if(g_vp_panel&&g_vp_sel>=0) VPPanelPos(vppx,vppy);
        bool in_vp_panel=(g_vp_panel&&mx>=vppx&&mx<=vppx+290&&my>=vppy&&my<=vppy+280);

        // Color picker: prioridade máxima
        bool in_color_picker=(g_pick_open&&mx>=g_pick_px&&mx<=g_pick_px+PICK_W&&my>=g_pick_py&&my<=g_pick_py+PICK_H);
        if(g_pick_open)
        {
            if(just_pressed && in_color_picker){ HandleColorPickerClick(mx,my); return; }
            if(just_pressed && !in_color_picker){ g_pick_open=false; Redraw(); }
            if(in_color_picker) return;   // absorve hover
        }

        // Rastreamento do botão direito
        bool btn_r=((int)sparam&2)!=0;
        bool just_pressed_r=(!g_rbtn_prev && btn_r);
        g_rbtn_prev=btn_r;

        // ── Right-drag de seleção em andamento ──
        if(g_sel_drag && g_sel_is_right)
        {
            if(!btn_r)
            {
                g_sel_drag=false;
                if(MathAbs(g_sel_x1-g_sel_x0)>8||MathAbs(g_sel_y1-g_sel_y0)>8)
                    g_sel_ready=true;
                Redraw(); return;
            }
            if(mx!=g_sel_x1||my!=g_sel_y1){ g_sel_x1=mx; g_sel_y1=my; Redraw(); }
            return;
        }

        // ── Ctrl+left-drag de seleção em andamento ──
        if(g_sel_drag && !g_sel_is_right)
        {
            if(!is_sel)
            {
                g_sel_drag=false;
                if(MathAbs(g_sel_x1-g_sel_x0)>8||MathAbs(g_sel_y1-g_sel_y0)>8)
                    g_sel_ready=true;
                Redraw(); return;
            }
            if(mx!=g_sel_x1||my!=g_sel_y1){ g_sel_x1=mx; g_sel_y1=my; Redraw(); }
            return;
        }

        // ── Right-click-wait: pressionado sobre ferramenta, aguardando click vs drag ──
        if(g_rclick_wait)
        {
            if(!btn_r)
            {
                // Solto sem arrastar → abre config da ferramenta
                g_rclick_wait=false;
                if(g_rclick_vi>=0)
                { g_zone_panel=false; g_vp_sel=g_rclick_vi; g_vp_panel=true; g_vppx=g_rclick_xi+12; g_vppy=g_rclick_yi+12; Redraw(); }
                else if(g_rclick_zi>=0)
                { g_vp_panel=false; g_zone_sel=g_rclick_zi; g_zone_panel=true; g_zpx=g_rclick_xi+12; g_zpy=g_rclick_yi+12; Redraw(); }
                return;
            }
            if(MathAbs(mx-g_rclick_xi)>10||MathAbs(my-g_rclick_yi)>10)
            {
                // Arrastou → converte em drag de seleção
                g_rclick_wait=false;
                g_sel_drag=true; g_sel_is_right=true;
                g_sel_x0=g_rclick_xi; g_sel_y0=g_rclick_yi;
                g_sel_x1=mx; g_sel_y1=my; g_sel_ready=false;
                Redraw();
            }
            return;
        }

        // ── Nova pressão do botão direito ──
        if(just_pressed_r && !in_zone_panel && !in_vp_panel && !in_gear && !in_menu)
        {
            int vi=HitTestVP(mx,my);
            int zi=(vi<0)?HitTestZone(mx,my):-1;
            g_rclick_xi=mx; g_rclick_yi=my; g_rclick_vi=vi; g_rclick_zi=zi;
            if(vi>=0||zi>=0)
                g_rclick_wait=true;       // sobre ferramenta → esperar ver se é click ou drag
            else
            { g_sel_drag=true; g_sel_is_right=true; g_sel_x0=mx; g_sel_y0=my; g_sel_x1=mx; g_sel_y1=my; g_sel_ready=false; }
            return;
        }

        // ── Ctrl+left-drag start ──
        if(is_sel && !g_sel_drag)
        {
            g_sel_drag=true; g_sel_is_right=false;
            g_sel_x0=mx; g_sel_y0=my; g_sel_x1=mx; g_sel_y1=my; g_sel_ready=false;
            return;
        }

        if(just_pressed&&g_sel_ready)           { HandleSelectionToolbar(mx,my); return; }
        if(just_pressed&&in_zone_panel)          { HandleZonePanelClick(mx,my); return; }
        if(just_pressed&&in_vp_panel)            { HandleVPPanelClick(mx,my); return; }
        if(just_pressed&&(in_gear||in_menu))     { HandleMenuClick(mx,my); return; }
        if(in_zone_panel||in_vp_panel||in_gear||in_menu) return;

        // Clique esquerdo fora fecha painéis abertos
        if(just_pressed&&g_zone_panel){ g_zone_panel=false; g_zone_sel=-1; Redraw(); }
        if(just_pressed&&g_vp_panel)  { g_vp_panel=false;  g_vp_sel=-1;   Redraw(); }

        // Left-click em zona ou VP → apenas seleciona (destaque visual, sem abrir painel)
        if(just_pressed&&!ctrl)
        {
            int vi=HitTestVP(mx,my);
            if(vi>=0){ g_vp_sel=vi; g_vp_panel=false; Redraw(); return; }
            int zi=HitTestZone(mx,my);
            if(zi>=0){ g_zone_sel=zi; g_zone_panel=false; Redraw(); return; }
            // Clique em vazio → deseleciona
            if(g_vp_sel>=0||g_zone_sel>=0){ g_vp_sel=-1; g_zone_sel=-1; Redraw(); }
        }

        if(!btn)
        {
            g_vaxis_drag=false;
            g_haxis_drag=false;
            g_pan_drag=false;
            return;
        }

        // Pan vertical: arrastar área principal (esquerda da barra de preço, acima do painel)
        if(!g_vaxis_drag && !g_haxis_drag && !ctrl && mx<axis_x0 && my>=0 && my<chart_h)
        {
            if(!g_pan_drag)
                { g_pan_drag=true; g_pan_y0=my; g_pan_off0=g_pan_offset; return; }
            int dy=my-g_pan_y0;
            double price_per_px=g_last_prange/MathMax(1,chart_h-4);
            g_pan_offset=g_pan_off0+(double)dy*price_per_px;  // dy>0=arrastar baixo=pmin/pmax sobem=conteúdo desce
            Redraw(); return;
        }

        // Drag na barra de preço (direita) → zoom vertical
        if(!g_haxis_drag && mx>=axis_x0 && my>=0 && my<chart_h)
        {
            if(!g_vaxis_drag)
                { g_vaxis_drag=true; g_vdrag_y0=my; g_vdrag_z0=g_zoom_v; return; }
            int nz=MathMax(1,MathMin(200,(int)(g_vdrag_z0*(1.0+(g_vdrag_y0-my)*0.01))));
            if(nz!=g_zoom_v){g_zoom_v=nz;Redraw();}
            return;
        }

        // Drag no painel inferior → zoom horizontal (igual React timeAxis drag)
        if(!g_vaxis_drag && my>=chart_h && mx<axis_x0)
        {
            if(!g_haxis_drag)
                { g_haxis_drag=true; g_hdrag_x0=mx; g_hdrag_zh0=g_zoom_h; return; }
            double factor=1.0+(mx-g_hdrag_x0)*0.008;
            int nz=MathMax(1,MathMin(800,(int)((double)g_hdrag_zh0*factor)));
            if(nz!=g_zoom_h){g_zoom_h=nz;Redraw();}
            return;
        }

        return;
    }

    //--- Mouse Wheel ---
    if(id==CHARTEVENT_MOUSE_WHEEL)
    {
        // sparam = "flags;x;y;delta"
        string parts[]; int n=StringSplit(sparam,';',parts);
        int wheel=(n>=4)?(int)StringToInteger(parts[3]):((int)dparam>0?120:-120);

        bool ctrl=(TerminalInfoInteger(TERMINAL_KEYSTATE_CONTROL)&0x8000)!=0;
        if(ctrl)
        {
            // Ctrl+scroll = zoom horizontal
            if(wheel>0) g_zoom_h=MathMin(800,g_zoom_h+10);
            else        g_zoom_h=MathMax(1,  g_zoom_h-10);
        }
        else
        {
            // Scroll normal = navegar clusters L/R
            if(wheel>0) g_scroll=MathMax(0,g_scroll-3);
            else        g_scroll+=3;
            g_scroll=MathMax(0,MathMin(g_scroll,g_history_count-1));
        }
        Redraw(); return;
    }
}