gavindiaz/yuclusters-mt5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
yuclusters-mt5/mql5/TesteFootprint.mq5
T
rufinomec-afk a6a9164788 feat: Footprint Chart MT5 v1.85 — EA nativo MQL5 
Porta fiel do YuClusters em MQL5 puro via CCanvas, sem dependências externas.

Funcionalidades:
- Clusters bid/ask por nível com POC, modo delta, painel inferior
- Ferramentas de desenho: Zona e Volume Profile de região (right-drag)
- Painéis de configuração via right-click com color picker inline (160 cores)
- Zoom vertical/horizontal, pan, eixo de preço customizado
- Menu de configurações (formação + cores) com gear button
2026-06-09 16:48:37 -03:00

1996 lines
81 KiB
Plaintext
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//+------------------------------------------------------------------+
//| 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;
}
}
Reference in New Issue View Git Blame Copy Permalink