RiskManagement/RiskManagement.mq5

//+------------------------------------------------------------------+
//|                    EnterpriseOrderPanel_Minimal.mq5               |
//|   Minimal MT5 panel: draggable window + minimize/close + buttons  |
//+------------------------------------------------------------------+
#property strict
#property version   "1.00"

//====================================================================
// Inputs
//====================================================================
input double InpUIScale = 1.00;
input int    InpStartX  = 20;
input int    InpStartY  = 30;
input ulong  InpMagicNumber=270927;
input uint   InpDeviationPoints=20;

//====================================================================
// Geometry
//====================================================================
#define BASE_W       270
#define HEADER_H      26
#define BODY_H       210
#define OUTER_PAD      6
#define BUTTON_H      24

//====================================================================
// Theme
//====================================================================
color C_SHADOW       = C'5,8,12';
color C_FRAME        = C'42,52,66';
color C_BODY         = C'12,19,28';
color C_HEADER       = C'17,27,39';
color C_HEADER_TOP   = C'24,38,53';

color C_TEXT         = C'236,241,248';
color C_TEXT2        = C'196,208,224';
color C_MUTED        = C'129,148,173';

color C_ACCENT       = C'30,132,255';
color C_ACCENT_DARK  = C'20,104,211';

color C_BTN          = C'22,31,43';
color C_BTN_PRESS    = C'34,47,63';

color C_CLOSE        = C'178,47,58';
color C_CLOSE_PRESS  = C'204,58,69';

//====================================================================
// State
//====================================================================
double g_scale=1.0;
int    g_x=20;
int    g_y=30;

bool g_minimized=false;

enum ERiskUnit { RISK_DOLLAR=0, RISK_PERCENT, RISK_LOT };
ERiskUnit g_risk_unit=RISK_DOLLAR;
double g_risk_value=0.0;
string g_risk_text="0";
string g_dollar_text="0",g_percent_text="1";
string g_lot_text="0.01";
string N_LOT_BG="MIN_LOT_BG",N_LOT_TX="MIN_LOT_TX";
bool g_state_ready=false;
bool g_restore_stop=false,g_restore_entry=false;
double g_saved_stop=0.0,g_saved_entry=0.0;
string N_STATE="";
string N_EXEC_LOCK="";
bool g_executing=false;

bool g_prev_left=false;
bool g_dragging=false;
int  g_drag_dx=0;
int  g_drag_dy=0;
bool g_chart_scroll_before=true;
bool g_stop_initialized=false;
double g_stop_price=0.0;
string g_stop_caption="";
int g_stop_label_x=-1,g_stop_label_y=-1;
bool g_stop_label_visible=false;
enum EEntryMode { ENTRY_MARKET=0, ENTRY_LIMIT };
EEntryMode g_entry_mode=ENTRY_MARKET;
bool g_entry_initialized=false;
double g_entry_price=0.0;
string g_entry_caption="";
int g_entry_label_x=-1,g_entry_label_y=-1;
bool g_entry_label_visible=false;
bool g_tp_rr=true,g_tp_initialized=false;
double g_tp_reward=3.0,g_tp_price=0.0,g_tp_last_set=0.0,g_calc_volume=0.0;
string g_tp_caption="";
int g_tp_x=-1,g_tp_y=-1;
bool g_tp_visible=false;
string N_TP_LINE="MIN_TP_LINE",N_TP_PRICE="MIN_TP_PRICE";
string N_TP_EDIT="MIN_TP_EDIT",N_TP_TITLE="MIN_TP_TITLE";
string N_TP_RR_BG="MIN_TP_RR_BG",N_TP_RR_TX="MIN_TP_RR_TX";
string N_TP_VALUE_BG="MIN_TP_VALUE_BG",N_TP_VALUE_TX="MIN_TP_VALUE_TX";
int g_steps=1;
bool g_lines_cleared=false;
string N_CLEAR_BG="MIN_CLEAR_BG",N_CLEAR_TX="MIN_CLEAR_TX";
string N_STEPS_TITLE="MIN_STEPS_TITLE";
string N_DAY_TITLE="MIN_DAY_TITLE",N_DAY_VALUE="MIN_DAY_VALUE";
ulong g_day_refresh=0;
string N_STEPS_BG[3]={"MIN_STEPS_1_BG","MIN_STEPS_2_BG","MIN_STEPS_3_BG"};
string N_STEPS_TX[3]={"MIN_STEPS_1_TX","MIN_STEPS_2_TX","MIN_STEPS_3_TX"};
string N_STAGE_LINE[2]={"MIN_ENTRY_2","MIN_ENTRY_3"};
string N_STAGE_LABEL[2]={"MIN_ENTRY_2_PRICE","MIN_ENTRY_3_PRICE"};
double g_stage_price[2]={0.0,0.0};
string g_stage_caption[2]={"",""};
int g_stage_x[2]={-1,-1},g_stage_y[2]={-1,-1};
bool g_stage_visible[2]={false,false};

//====================================================================
// Object names
//====================================================================
string N_SHADOW   ="MIN_SHADOW";
string N_FRAME    ="MIN_FRAME";
string N_BODY     ="MIN_BODY";
string N_HEADER   ="MIN_HEADER";
string N_TOPLINE  ="MIN_TOPLINE";

string N_TITLE    ="MIN_TITLE";
string N_SUBTITLE ="MIN_SUBTITLE";

string N_MIN_BG   ="MIN_MIN_BG";
string N_MIN_TX   ="MIN_MIN_TX";
string N_CLOSE_BG ="MIN_CLOSE_BG";
string N_CLOSE_TX ="MIN_CLOSE_TX";

string N_LEFT_BG  ="MIN_LEFT_BG";
string N_LEFT_TX  ="MIN_LEFT_TX";
string N_RIGHT_BG ="MIN_RIGHT_BG";
string N_RIGHT_TX ="MIN_RIGHT_TX";
string N_RISK_EDIT="MIN_RISK_EDIT";
string N_DOLLAR_BG="MIN_DOLLAR_BG";
string N_DOLLAR_TX="MIN_DOLLAR_TX";
string N_PERCENT_BG="MIN_PERCENT_BG";
string N_PERCENT_TX="MIN_PERCENT_TX";
string N_STOP_LINE="MIN_STOP_LINE";
string N_STOP_PRICE="MIN_STOP_PRICE";
string N_ENTRY_LINE="MIN_ENTRY_LINE";
string N_ENTRY_PRICE="MIN_ENTRY_PRICE";
string N_MARKET_BG="MIN_MARKET_BG";
string N_MARKET_TX="MIN_MARKET_TX";
string N_LIMIT_BG="MIN_LIMIT_BG";
string N_LIMIT_TX="MIN_LIMIT_TX";

//====================================================================
// Press targets
//====================================================================
enum EPressTarget
{
   PRESS_NONE=0,
   PRESS_MIN,
   PRESS_CLOSE,
   PRESS_HEADER,
   PRESS_LEFT,
   PRESS_RIGHT
};

EPressTarget g_pressed=PRESS_NONE;

//====================================================================
// Helpers
//====================================================================
int S(double v)
{
   return (int)MathRound(v*g_scale);
}

int FS(double v)
{
   int n=(int)MathRound((v+1.0)*g_scale);
   return n<7 ? 7 : n;
}

void Del(string name)
{
   if(ObjectFind(0,name)>=0)
      ObjectDelete(0,name);
}

bool Rect(string name,int x,int y,int w,int h,color bg,color edge,long z=1)
{
   if(!ObjectCreate(0,name,OBJ_RECTANGLE_LABEL,0,0,0))
      return false;

   ObjectSetInteger(0,name,OBJPROP_CORNER,CORNER_LEFT_UPPER);
   ObjectSetInteger(0,name,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(0,name,OBJPROP_YDISTANCE,y);
   ObjectSetInteger(0,name,OBJPROP_XSIZE,w);
   ObjectSetInteger(0,name,OBJPROP_YSIZE,h);
   ObjectSetInteger(0,name,OBJPROP_BGCOLOR,bg);
   ObjectSetInteger(0,name,OBJPROP_COLOR,edge);
   ObjectSetInteger(0,name,OBJPROP_BORDER_TYPE,BORDER_FLAT);
   ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
   ObjectSetInteger(0,name,OBJPROP_BACK,false);
   ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
   ObjectSetInteger(0,name,OBJPROP_ZORDER,z);
   return true;
}

bool Label(string name,string text,int x,int y,int font_size,color clr,
           string font="Segoe UI",long z=20)
{
   if(!ObjectCreate(0,name,OBJ_LABEL,0,0,0))
      return false;

   ObjectSetInteger(0,name,OBJPROP_CORNER,CORNER_LEFT_UPPER);
   ObjectSetInteger(0,name,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(0,name,OBJPROP_YDISTANCE,y);
   ObjectSetInteger(0,name,OBJPROP_COLOR,clr);
   ObjectSetInteger(0,name,OBJPROP_FONTSIZE,font_size);
   ObjectSetString(0,name,OBJPROP_FONT,font);
   ObjectSetString(0,name,OBJPROP_TEXT,text);
   // Chart-level captions use z=6; panel labels stay in the foreground.
   // ZORDER controls mouse priority, while BACK controls the drawing layer.
   ObjectSetInteger(0,name,OBJPROP_BACK,z<10);
   ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
   ObjectSetInteger(0,name,OBJPROP_ZORDER,z);
   return true;
}

void XYWH(string name,int x,int y,int w=-1,int h=-1)
{
   if(ObjectFind(0,name)<0)
      return;

   ObjectSetInteger(0,name,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(0,name,OBJPROP_YDISTANCE,y);

   if(w>=0) ObjectSetInteger(0,name,OBJPROP_XSIZE,w);
   if(h>=0) ObjectSetInteger(0,name,OBJPROP_YSIZE,h);
}

void XY(string name,int x,int y)
{
   XYWH(name,x,y);
}

void CenterText(string name,int x,int y,int w,int h)
{
   if(ObjectFind(0,name)<0)
      return;

   ObjectSetInteger(0,name,OBJPROP_ANCHOR,ANCHOR_CENTER);
   XY(name,x+w/2,y+h/2);
}

void Visible(string name,bool visible)
{
   if(ObjectFind(0,name)<0)
      return;

   ObjectSetInteger(
      0,
      name,
      OBJPROP_TIMEFRAMES,
      visible ? OBJ_ALL_PERIODS : OBJ_NO_PERIODS
   );
}

void RectStyle(string name,color bg,color edge)
{
   if(ObjectFind(0,name)<0)
      return;

   ObjectSetInteger(0,name,OBJPROP_BGCOLOR,bg);
   ObjectSetInteger(0,name,OBJPROP_COLOR,edge);
}

bool Hit(int px,int py,int x,int y,int w,int h)
{
   return (px>=x && px<x+w && py>=y && py<y+h);
}

bool HitObject(string name,int mx,int my)
{
   if(ObjectFind(0,name)<0)
      return false;

   if(ObjectGetInteger(0,name,OBJPROP_TIMEFRAMES)==OBJ_NO_PERIODS)
      return false;

   return Hit(
      mx,
      my,
      (int)ObjectGetInteger(0,name,OBJPROP_XDISTANCE),
      (int)ObjectGetInteger(0,name,OBJPROP_YDISTANCE),
      (int)ObjectGetInteger(0,name,OBJPROP_XSIZE),
      (int)ObjectGetInteger(0,name,OBJPROP_YSIZE)
   );
}

//====================================================================
// Stop line
//====================================================================
double StopPrice(double price)
{
   double step=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE);
   if(step>0.0) price=MathRound(price/step)*step;
   return NormalizeDouble(price,_Digits);
}

void UpdatePriceLabel(string line,string label,string prefix,bool below,
                      double &line_price,string &last_caption,
                      int &last_x,int &last_y,bool &last_visible)
{
   bool exists=(ObjectFind(0,line)>=0);
   bool show=false;
   int x=0,y=0;
   if(exists)
   {
      line_price=ObjectGetDouble(0,line,OBJPROP_PRICE);
      datetime time=0;
      double price=0.0;
      int window=0,unused_x=0;
      if(ChartXYToTimePrice(0,0,0,window,time,price) &&
         ChartTimePriceToXY(0,0,time,line_price,unused_x,y))
      {
         int height=(int)ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS,0);
         x=(int)ChartGetInteger(0,CHART_WIDTH_IN_PIXELS,0)-S(12);
         show=(y>=0 && y<height);
         y=below ? (int)MathMax(0,MathMin(height-S(18),y+S(3)))
                 : (int)MathMax(S(18),y-S(3));
      }
   }

   bool changed=false;
   if(show!=last_visible)
   {
      Visible(label,show);
      last_visible=show;
      changed=true;
   }
   if(show)
   {
      string caption=prefix+"  "+DoubleToString(line_price,_Digits);
      if(caption!=last_caption)
      {
         ObjectSetString(0,label,OBJPROP_TEXT,caption);
         last_caption=caption;
         changed=true;
      }
      if(x!=last_x || y!=last_y)
      {
         XY(label,x,y);
         last_x=x;
         last_y=y;
         changed=true;
      }
   }
   if(changed) ChartRedraw();
}

void UpdateStopLabel()
{
   if(g_stop_initialized)
      UpdatePriceLabel(N_STOP_LINE,N_STOP_PRICE,"SL | "+StopLossText()+" |",false,g_stop_price,
                       g_stop_caption,g_stop_label_x,g_stop_label_y,g_stop_label_visible);
}

double CurrentChartPrice()
{
   MqlTick tick;
   if(!SymbolInfoTick(_Symbol,tick)) return 0.0;
   // Match the price source used to initialize the stop line.
   if(tick.bid>0.0) return tick.bid;
   if(tick.last>0.0) return tick.last;
   return tick.ask;
}

void SaveState()
{
   if(!g_state_ready) return;
   bool has_stop=(ObjectFind(0,N_STOP_LINE)>=0);
   bool has_entry=(ObjectFind(0,N_ENTRY_LINE)>=0);
   if(has_stop) { g_saved_stop=ObjectGetDouble(0,N_STOP_LINE,OBJPROP_PRICE); g_restore_stop=true; }
   if(has_entry) { g_saved_entry=ObjectGetDouble(0,N_ENTRY_LINE,OBJPROP_PRICE); g_restore_entry=true; }
   for(int i=0;i<2;i++)
      if(ObjectFind(0,N_STAGE_LINE[i])>=0)
         g_stage_price[i]=ObjectGetDouble(0,N_STAGE_LINE[i],OBJPROP_PRICE);
   string state=IntegerToString(g_x)+"|"+IntegerToString(g_y)+"|"+
      IntegerToString((int)g_minimized)+"|"+IntegerToString((int)g_risk_unit)+"|"+
      IntegerToString((int)g_entry_mode)+"|"+g_dollar_text+"|"+g_percent_text+"|"+
      IntegerToString((int)g_restore_stop)+"|"+DoubleToString(g_saved_stop,16)+"|"+
      IntegerToString((int)g_restore_entry)+"|"+DoubleToString(g_saved_entry,16)+"|"+
      IntegerToString((int)g_tp_rr)+"|"+DoubleToString(g_tp_reward,8)+"|"+DoubleToString(g_tp_price,16)+"|"+
      IntegerToString(g_steps)+"|"+DoubleToString(g_stage_price[0],16)+"|"+DoubleToString(g_stage_price[1],16)+"|"+
      IntegerToString((int)g_lines_cleared)+"|"+g_lot_text;
   if(ObjectFind(0,N_STATE)<0)
   {
      if(!ObjectCreate(0,N_STATE,OBJ_LABEL,0,0,0)) return;
      ObjectSetInteger(0,N_STATE,OBJPROP_TIMEFRAMES,OBJ_NO_PERIODS);
      ObjectSetInteger(0,N_STATE,OBJPROP_HIDDEN,true);
      ObjectSetInteger(0,N_STATE,OBJPROP_SELECTABLE,false);
   }
   if(ObjectGetString(0,N_STATE,OBJPROP_TEXT)!=state)
      ObjectSetString(0,N_STATE,OBJPROP_TEXT,state);
}

void LoadState()
{
   // This invisible chart object is deliberately excluded from DeleteAll().
   // It survives timeframe/input reinitialization and belongs to this chart only.
   if(ObjectFind(0,N_STATE)<0) return;
   string fields[];
   int count=StringSplit(ObjectGetString(0,N_STATE,OBJPROP_TEXT),'|',fields);
   if(count!=11 && count!=14 && count!=17 && count!=18 && count!=19) return;
   g_x=(int)StringToInteger(fields[0]);
   g_y=(int)StringToInteger(fields[1]);
   g_minimized=(StringToInteger(fields[2])!=0);
   g_risk_unit=StringToInteger(fields[3])==1 ? RISK_PERCENT : RISK_DOLLAR;
   if(count>=19 && StringToInteger(fields[3])==2) g_risk_unit=RISK_LOT;
   g_entry_mode=StringToInteger(fields[4])==1 ? ENTRY_LIMIT : ENTRY_MARKET;
   g_dollar_text=fields[5];
   g_percent_text=fields[6];
   g_restore_stop=(StringToInteger(fields[7])!=0);
   g_saved_stop=StringToDouble(fields[8]);
   g_restore_entry=(StringToInteger(fields[9])!=0);
   g_saved_entry=StringToDouble(fields[10]);
   if(count>=14)
   {
      g_tp_rr=(StringToInteger(fields[11])!=0);
      g_tp_reward=StringToDouble(fields[12]);
      g_tp_price=StringToDouble(fields[13]);
      if(g_tp_reward<=0.0) g_tp_reward=3.0;
   }
   if(count>=17)
   {
      g_steps=(int)MathMax(1,MathMin(3,StringToInteger(fields[14])));
      g_stage_price[0]=StringToDouble(fields[15]);
      g_stage_price[1]=StringToDouble(fields[16]);
   }
   if(count>=18) g_lines_cleared=(StringToInteger(fields[17])!=0);
   if(count>=19) g_lot_text=fields[18];
}

void ClearLines()
{
   CommitRiskValue();
   CommitTP();
   SaveState();
   g_lines_cleared=true;
   Del(N_STOP_LINE); Del(N_STOP_PRICE);
   Del(N_ENTRY_LINE); Del(N_ENTRY_PRICE);
   Del(N_TP_LINE); Del(N_TP_PRICE);
   for(int i=0;i<2;i++)
   {
      Del(N_STAGE_LINE[i]); Del(N_STAGE_LABEL[i]);
      g_stage_caption[i]=""; g_stage_x[i]=-1; g_stage_y[i]=-1; g_stage_visible[i]=false;
   }
   g_stop_initialized=false; g_entry_initialized=false; g_tp_initialized=false;
   g_stop_caption=""; g_entry_caption=""; g_tp_caption="";
   g_stop_label_x=-1; g_stop_label_y=-1;
   g_entry_label_x=-1; g_entry_label_y=-1;
   g_tp_x=-1; g_tp_y=-1;
   g_stop_label_visible=false; g_entry_label_visible=false; g_tp_visible=false;
   SaveState();
   ChartRedraw();
}

void SetDefaults()
{
   g_x=InpStartX;
   g_y=InpStartY;
   g_minimized=false;
   g_risk_unit=RISK_DOLLAR;
   g_dollar_text=DoubleToString(AccountInfoDouble(ACCOUNT_BALANCE)*0.01,2);
   g_percent_text="1";
   g_lot_text=DoubleToString(SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN),8);
   g_risk_text=g_dollar_text;
   g_risk_value=StringToDouble(g_risk_text);
   g_entry_mode=ENTRY_MARKET;
   g_steps=1;
   g_restore_stop=false;
   g_restore_entry=false;
   g_saved_stop=0.0;
   g_saved_entry=0.0;
   g_stop_price=0.0;
   g_entry_price=0.0;
   for(int i=0;i<2;i++) g_stage_price[i]=0.0;
   g_tp_rr=true;
   g_tp_reward=3.0;
   g_tp_price=0.0;
   g_tp_last_set=0.0;
   g_calc_volume=0.0;
   g_lines_cleared=false;
}

void ResetAll()
{
   // Keep the panel and its inputs; only rebuild the chart levels.
   ClearLines();
   Del(N_EXEC_LOCK);
   g_restore_stop=false;
   g_restore_entry=false;
   g_saved_stop=0.0;
   g_saved_entry=0.0;
   g_stop_price=0.0;
   g_entry_price=0.0;
   for(int i=0;i<2;i++) g_stage_price[i]=0.0;
   g_tp_price=0.0;
   g_tp_last_set=0.0;
   g_lines_cleared=false;
   ObjectSetString(0,N_RIGHT_TX,OBJPROP_TEXT,"EXECUTE");
   ObjectSetString(0,N_RIGHT_BG,OBJPROP_TOOLTIP,"Execute the current trading plan");
   CreateStopLine();
   RefreshEntry();
   TPControls();
   SaveState();
   ChartRedraw();
}

void SetRiskUnit(ERiskUnit unit)
{
   CommitRiskValue();
   g_risk_unit=unit;
   g_risk_text=unit==RISK_DOLLAR ? g_dollar_text : (unit==RISK_PERCENT ? g_percent_text : g_lot_text);
   g_risk_value=StringToDouble(g_risk_text);
   ObjectSetString(0,N_RISK_EDIT,OBJPROP_TEXT,g_risk_text);
   UpdateRiskUnit();
   SaveState();
}

string EntryDirection(color &line_color)
{
   line_color=C_MUTED;
   bool market=(g_entry_mode==ENTRY_MARKET);
   string neutral=market ? "MARKET -" : "PENDING -";
   if(ObjectFind(0,N_ENTRY_LINE)<0 || ObjectFind(0,N_STOP_LINE)<0) return neutral;

   double current=CurrentChartPrice();
   if(current<=0.0) return neutral;
   double entry=market ? current : ObjectGetDouble(0,N_ENTRY_LINE,OBJPROP_PRICE);
   double stop=ObjectGetDouble(0,N_STOP_LINE,OBJPROP_PRICE);
   // Stop versus entry determines side; entry versus market determines order type.
   double distance=entry-stop;
   if(MathAbs(distance)<_Point*0.5) return neutral;
   bool buy=(distance>0.0);
   line_color=buy ? C'46,196,145' : C'232,103,113';
   if(market) return buy ? "BUY MARKET" : "SELL MARKET";
   double offset=entry-current;
   if(MathAbs(offset)<_Point*0.5)
      return buy ? "BUY PENDING" : "SELL PENDING";
   if(buy) return offset>0.0 ? "BUY STOP" : "BUY LIMIT";
   return offset<0.0 ? "SELL STOP" : "SELL LIMIT";
}

void SetTextIfChanged(string name,string value)
{
   if(ObjectGetString(0,name,OBJPROP_TEXT)!=value)
      ObjectSetString(0,name,OBJPROP_TEXT,value);
}

string PositionVolumeText(double &estimated_loss,string line="")
{
   if(line=="") line=N_ENTRY_LINE;
   estimated_loss=-1.0;
   g_calc_volume=0.0;
   if(ObjectFind(0,line)<0 || ObjectFind(0,N_STOP_LINE)<0) return "Lots: --";
   double entry=ObjectGetDouble(0,line,OBJPROP_PRICE);
   double stop=ObjectGetDouble(0,N_STOP_LINE,OBJPROP_PRICE);
   if(MathAbs(entry-stop)<_Point*0.5) return "Lots: --";
   bool buy=(entry>stop);
   if(line!=N_ENTRY_LINE && buy!=(ObjectGetDouble(0,N_ENTRY_LINE,OBJPROP_PRICE)>stop))
      return "Lots: -- (SL side)";
   if(g_entry_mode==ENTRY_MARKET && line==N_ENTRY_LINE)
   {
      MqlTick tick;
      if(!SymbolInfoTick(_Symbol,tick)) return "Lots: --";
      entry=buy ? tick.ask : tick.bid;
   }
   if(entry<=0.0 || stop<=0.0) return "Lots: --";

   // OrderCalcProfit returns money in account currency, including conversion.
   double risk=g_risk_unit==RISK_PERCENT
               ? AccountInfoDouble(ACCOUNT_BALANCE)*g_risk_value/100.0 : g_risk_value;
   double minimum=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   double maximum=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
   double step=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   if(!MathIsValidNumber(risk) || risk<0.0 || minimum<=0.0 ||
      maximum<minimum || step<=0.0) return "Lots: --";
   int digits=0;
   while(digits<8 && MathAbs(step-NormalizeDouble(step,digits))>1e-10) digits++;
   double loss=0.0;
   if(!OrderCalcProfit(buy ? ORDER_TYPE_BUY : ORDER_TYPE_SELL,
                      _Symbol,minimum,entry,stop,loss) ||
      !MathIsValidNumber(loss) || loss>=0.0) return "Lots: --";
   double raw=g_risk_unit==RISK_LOT ? MathMax(minimum,g_risk_value) : risk/(-loss)*minimum;
   if(!MathIsValidNumber(raw)) return "Lots: --";
   // Round down so the displayed volume does not exceed the requested risk.
   double volume=NormalizeDouble(MathFloor(MathMin(raw,maximum)/step)*step,digits);
   if(volume<minimum)
   {
      estimated_loss=0.0;
      return "Lots: "+DoubleToString(0.0,digits)+" (< min)";
   }
   estimated_loss=(-loss)*volume/minimum;
   g_calc_volume=volume;
   return "Lots: "+DoubleToString(volume,digits);
}

string MoneyUSD(double loss,string title)
{
   string currency=AccountInfoString(ACCOUNT_CURRENCY);
   if(currency!="USD" && loss!=0.0)
   {
      // Convert using an available direct/inverse quote, including broker suffixes.
      bool converted=false;
      for(int i=0;i<SymbolsTotal(false);i++)
      {
         string symbol=SymbolName(i,false);
         string base=SymbolInfoString(symbol,SYMBOL_CURRENCY_BASE);
         string quote=SymbolInfoString(symbol,SYMBOL_CURRENCY_PROFIT);
         bool direct=(base==currency && quote=="USD");
         bool inverse=(base=="USD" && quote==currency);
         if(!direct && !inverse) continue;
         if(!SymbolSelect(symbol,true)) continue;
         MqlTick tick;
         if(!SymbolInfoTick(symbol,tick)) continue;
         if(direct && tick.bid>0.0) { loss*=tick.bid; converted=true; break; }
         if(inverse && tick.ask>0.0) { loss/=tick.ask; converted=true; break; }
      }
      if(!converted) return title+" USD: --";
   }
   return title+": $"+DoubleToString(loss,2);
}

string StopLossText()
{
   double loss=0.0;
   for(int i=0;i<g_steps;i++)
   {
      double part;
      PositionVolumeText(part,i==0 ? N_ENTRY_LINE : N_STAGE_LINE[i-1]);
      if(part<0.0) return "Total loss: --";
      loss+=part;
   }
   return MoneyUSD(loss,g_steps>1 ? "Total loss" : "Loss");
}

void StepControls()
{
   for(int i=0;i<3;i++)
   {
      bool active=(g_steps==i+1);
      RectStyle(N_STEPS_BG[i],active ? C_ACCENT : C_BTN,active ? C_ACCENT : C_FRAME);
      ObjectSetInteger(0,N_STEPS_TX[i],OBJPROP_COLOR,active ? C_TEXT : C_MUTED);
   }
}

void RefreshStages()
{
   if(ObjectFind(0,N_ENTRY_LINE)<0 || ObjectFind(0,N_STOP_LINE)<0) return;
   double first=ObjectGetDouble(0,N_ENTRY_LINE,OBJPROP_PRICE);
   double stop=ObjectGetDouble(0,N_STOP_LINE,OBJPROP_PRICE);
   double current=CurrentChartPrice();
   for(int i=0;i<2;i++)
   {
      if(i+2>g_steps)
      {
         if(ObjectFind(0,N_STAGE_LINE[i])>=0)
            g_stage_price[i]=ObjectGetDouble(0,N_STAGE_LINE[i],OBJPROP_PRICE);
         Del(N_STAGE_LINE[i]); Del(N_STAGE_LABEL[i]);
         g_stage_caption[i]=""; g_stage_x[i]=-1; g_stage_y[i]=-1; g_stage_visible[i]=false;
         continue;
      }
      if(ObjectFind(0,N_STAGE_LINE[i])<0)
      {
         if(g_stage_price[i]<=0.0)
            g_stage_price[i]=StopPrice(first+(stop-first)*(i+1)/3.0);
         if(!ObjectCreate(0,N_STAGE_LINE[i],OBJ_HLINE,0,0,g_stage_price[i])) continue;
         ObjectSetInteger(0,N_STAGE_LINE[i],OBJPROP_BACK,true);
         ObjectSetInteger(0,N_STAGE_LINE[i],OBJPROP_STYLE,STYLE_DASHDOT);
         ObjectSetInteger(0,N_STAGE_LINE[i],OBJPROP_SELECTABLE,true);
         ObjectSetInteger(0,N_STAGE_LINE[i],OBJPROP_SELECTED,true);
         ObjectSetInteger(0,N_STAGE_LINE[i],OBJPROP_HIDDEN,true);
         ObjectSetInteger(0,N_STAGE_LINE[i],OBJPROP_ZORDER,5);
         if(!Label(N_STAGE_LABEL[i],"",0,0,FS(8),C_ACCENT,"Segoe UI Semibold",6))
         { Del(N_STAGE_LINE[i]); continue; }
         ObjectSetInteger(0,N_STAGE_LABEL[i],OBJPROP_ANCHOR,ANCHOR_RIGHT_UPPER);
         Visible(N_STAGE_LABEL[i],false);
      }
      double entry=ObjectGetDouble(0,N_STAGE_LINE[i],OBJPROP_PRICE);
      bool buy=(first>stop);
      string direction=buy ? (entry>current ? "BUY STOP" : "BUY LIMIT")
                           : (entry<current ? "SELL STOP" : "SELL LIMIT");
      if(MathAbs(entry-current)<_Point*0.5) direction=buy ? "BUY PENDING" : "SELL PENDING";
      double loss;
      string volume=PositionVolumeText(loss,N_STAGE_LINE[i]);
      color clr=loss<0.0 ? C_MUTED : (buy ? C'46,196,145' : C'232,103,113');
      ObjectSetInteger(0,N_STAGE_LINE[i],OBJPROP_COLOR,clr);
      ObjectSetInteger(0,N_STAGE_LABEL[i],OBJPROP_COLOR,clr);
      string caption="#"+IntegerToString(i+2)+" "+direction+" | "+volume+" |";
      UpdatePriceLabel(N_STAGE_LINE[i],N_STAGE_LABEL[i],caption,true,g_stage_price[i],
                       g_stage_caption[i],g_stage_x[i],g_stage_y[i],g_stage_visible[i]);
   }
}

void TPControls(bool text=true)
{
   RectStyle(N_TP_RR_BG,g_tp_rr ? C_ACCENT : C_BTN,g_tp_rr ? C_ACCENT : C_FRAME);
   RectStyle(N_TP_VALUE_BG,g_tp_rr ? C_BTN : C_ACCENT,g_tp_rr ? C_FRAME : C_ACCENT);
   ObjectSetInteger(0,N_TP_RR_TX,OBJPROP_COLOR,g_tp_rr ? C_TEXT : C_MUTED);
   ObjectSetInteger(0,N_TP_VALUE_TX,OBJPROP_COLOR,g_tp_rr ? C_MUTED : C_TEXT);
   if(text) ObjectSetString(0,N_TP_EDIT,OBJPROP_TEXT,
                           g_tp_rr ? DoubleToString(g_tp_reward,2) : DoubleToString(g_tp_price,_Digits));
}

void RefreshTP()
{
   if(g_lines_cleared) return;
   if(ObjectFind(0,N_ENTRY_LINE)<0 || ObjectFind(0,N_STOP_LINE)<0) return;
   // Native dragging changes the object price before OBJECT_DRAG is delivered.
   if(g_tp_initialized && ObjectFind(0,N_TP_LINE)>=0)
   {
      double moved=ObjectGetDouble(0,N_TP_LINE,OBJPROP_PRICE);
      if(MathAbs(moved-g_tp_last_set)>_Point*0.1)
      {
         g_tp_rr=false;
         g_tp_price=moved;
         g_tp_last_set=moved;
         TPControls();
      }
   }
   double entry=ObjectGetDouble(0,N_ENTRY_LINE,OBJPROP_PRICE);
   double stop=ObjectGetDouble(0,N_STOP_LINE,OBJPROP_PRICE);
   bool buy=entry>stop;
   if(g_entry_mode==ENTRY_MARKET)
   {
      MqlTick tick;
      if(!SymbolInfoTick(_Symbol,tick)) return;
      entry=buy ? tick.ask : tick.bid;
   }
   if(entry<=0.0 || MathAbs(entry-stop)<_Point*0.5) return;
   bool seed_price=(!g_tp_rr && g_tp_price<=0.0);
   double target=(g_tp_rr || seed_price) ? StopPrice(entry+(entry-stop)*g_tp_reward) : g_tp_price;
   if(!MathIsValidNumber(target) || target<=0.0) return;
   if(!g_tp_initialized)
   {
      if(!ObjectCreate(0,N_TP_LINE,OBJ_HLINE,0,0,target)) return;
      ObjectSetInteger(0,N_TP_LINE,OBJPROP_BACK,true);
      ObjectSetInteger(0,N_TP_LINE,OBJPROP_COLOR,C'46,196,145');
      ObjectSetInteger(0,N_TP_LINE,OBJPROP_STYLE,STYLE_DASH);
      ObjectSetInteger(0,N_TP_LINE,OBJPROP_SELECTABLE,true);
      ObjectSetInteger(0,N_TP_LINE,OBJPROP_SELECTED,true);
      ObjectSetInteger(0,N_TP_LINE,OBJPROP_HIDDEN,true);
      ObjectSetInteger(0,N_TP_LINE,OBJPROP_ZORDER,5);
      if(!Label(N_TP_PRICE,"",0,0,FS(8),C'46,196,145',"Segoe UI Semibold",6))
      { Del(N_TP_LINE); return; }
      ObjectSetInteger(0,N_TP_PRICE,OBJPROP_ANCHOR,ANCHOR_RIGHT_LOWER);
      Visible(N_TP_PRICE,false);
      g_tp_initialized=true;
   }
   if(ObjectGetDouble(0,N_TP_LINE,OBJPROP_PRICE)!=target)
      ObjectSetDouble(0,N_TP_LINE,OBJPROP_PRICE,target);
   g_tp_last_set=target;
   g_tp_price=target;
   if(seed_price) TPControls();
   double profit=0.0;
   bool valid=true;
   for(int i=0;i<g_steps;i++)
   {
      string line=i==0 ? N_ENTRY_LINE : N_STAGE_LINE[i-1];
      double loss,part=0.0;
      PositionVolumeText(loss,line);
      if(loss<0.0) { valid=false; break; }
      double open=i==0 ? entry : ObjectGetDouble(0,line,OBJPROP_PRICE);
      if(g_calc_volume>0.0 && !OrderCalcProfit(buy ? ORDER_TYPE_BUY : ORDER_TYPE_SELL,
                                             _Symbol,g_calc_volume,open,target,part))
      { valid=false; break; }
      profit+=part;
   }
   string money="Profit: --";
   if(valid) money=MoneyUSD(profit,g_steps>1 ? "Total profit" : "Profit");
   double rr=(target-entry)/(entry-stop);
   string prefix="TP | "+money+" | R:R "+DoubleToString(rr,2)+" |";
   UpdatePriceLabel(N_TP_LINE,N_TP_PRICE,prefix,false,g_tp_price,g_tp_caption,g_tp_x,g_tp_y,g_tp_visible);
}

void CommitTP()
{
   string value=ObjectGetString(0,N_TP_EDIT,OBJPROP_TEXT);
   StringTrimLeft(value); StringTrimRight(value);
   bool digit=false,decimal=false,valid=true;
   for(int i=0;i<StringLen(value);i++)
   {
      ushort c=StringGetCharacter(value,i);
      if(c>='0' && c<='9') digit=true;
      else if(c=='.' && !decimal) decimal=true;
      else { valid=false; break; }
   }
   double number=StringToDouble(value);
   if(valid && digit && MathIsValidNumber(number) && number>0.0)
   {
      if(g_tp_rr) g_tp_reward=number;
      else g_tp_price=StopPrice(number);
   }
   TPControls();
   RefreshTP();
   SaveState();
   ChartRedraw();
}

void UpdateEntryLabel()
{
   if(g_entry_initialized)
   {
      color line_color;
      double estimated_loss;
      string direction=EntryDirection(line_color);
      if((color)ObjectGetInteger(0,N_ENTRY_LINE,OBJPROP_COLOR)!=line_color)
      {
         ObjectSetInteger(0,N_ENTRY_LINE,OBJPROP_COLOR,line_color);
         ObjectSetInteger(0,N_ENTRY_PRICE,OBJPROP_COLOR,line_color);
      }
      UpdatePriceLabel(N_ENTRY_LINE,N_ENTRY_PRICE,
                       (g_steps>1 ? "#1 " : "")+direction+" | "+PositionVolumeText(estimated_loss)+" |",true,
                       g_entry_price,g_entry_caption,g_entry_label_x,
                       g_entry_label_y,g_entry_label_visible);
      RefreshStages();
      UpdateStopLabel();
      RefreshTP();
   }
}

void RefreshEntry()
{
   if(g_lines_cleared) return;
   bool market=(g_entry_mode==ENTRY_MARKET);
   double current=CurrentChartPrice();
   if(!g_entry_initialized)
   {
      if(current<=0.0 && (market || !g_restore_entry)) return;
      double price=current;
      if(!market)
      {
         if(g_restore_entry) price=g_saved_entry;
         else
         {
            if(ObjectFind(0,N_STOP_LINE)<0) return;
            price=StopPrice((current+ObjectGetDouble(0,N_STOP_LINE,OBJPROP_PRICE))*0.5);
         }
      }
      if(!ObjectCreate(0,N_ENTRY_LINE,OBJ_HLINE,0,0,price)) return;
      ObjectSetInteger(0,N_ENTRY_LINE,OBJPROP_COLOR,C_ACCENT);
      ObjectSetInteger(0,N_ENTRY_LINE,OBJPROP_STYLE,STYLE_SOLID);
      ObjectSetInteger(0,N_ENTRY_LINE,OBJPROP_WIDTH,1);
      ObjectSetInteger(0,N_ENTRY_LINE,OBJPROP_BACK,true);
      ObjectSetInteger(0,N_ENTRY_LINE,OBJPROP_SELECTABLE,!market);
      ObjectSetInteger(0,N_ENTRY_LINE,OBJPROP_SELECTED,!market);
      ObjectSetInteger(0,N_ENTRY_LINE,OBJPROP_HIDDEN,true);
      ObjectSetInteger(0,N_ENTRY_LINE,OBJPROP_ZORDER,5);
      ObjectSetString(0,N_ENTRY_LINE,OBJPROP_TOOLTIP,
                      market ? "Market entry | follows current price" : "Pending entry | Limit / Stop | drag to move");
      if(!Label(N_ENTRY_PRICE,"",0,0,FS(8),C_ACCENT,"Segoe UI Semibold",6))
      {
         Del(N_ENTRY_LINE);
         return;
      }
      ObjectSetInteger(0,N_ENTRY_PRICE,OBJPROP_ANCHOR,ANCHOR_RIGHT_UPPER);
      Visible(N_ENTRY_PRICE,false);
      g_entry_initialized=true;
   }
   // Limit placement happens only on mode entry; ticks never move a manual limit.
   if(market && current>0.0 && ObjectFind(0,N_ENTRY_LINE)>=0 &&
      ObjectGetDouble(0,N_ENTRY_LINE,OBJPROP_PRICE)!=current)
      ObjectSetDouble(0,N_ENTRY_LINE,OBJPROP_PRICE,current);
   UpdateEntryLabel();
}

void UpdateEntryModeStyle()
{
   bool market=(g_entry_mode==ENTRY_MARKET);
   RectStyle(N_MARKET_BG,market ? C_ACCENT : C_BTN,market ? C_ACCENT : C_FRAME);
   RectStyle(N_LIMIT_BG,market ? C_BTN : C_ACCENT,market ? C_FRAME : C_ACCENT);
   ObjectSetInteger(0,N_MARKET_TX,OBJPROP_COLOR,market ? C_TEXT : C_MUTED);
   ObjectSetInteger(0,N_LIMIT_TX,OBJPROP_COLOR,market ? C_MUTED : C_TEXT);
   SetTextIfChanged(N_MARKET_TX,"Market");
   SetTextIfChanged(N_LIMIT_TX,"Limit");
}

void SetEntryMode(EEntryMode mode)
{
   if(mode==g_entry_mode) return;
   g_entry_mode=mode;
   g_restore_entry=false;
   Del(N_ENTRY_LINE);
   Del(N_ENTRY_PRICE);
   g_entry_initialized=false;
   g_entry_caption="";
   g_entry_label_x=-1;
   g_entry_label_y=-1;
   g_entry_label_visible=false;
   UpdateEntryModeStyle();
   RefreshEntry();
   ChartRedraw();
}

bool CreateStopLine()
{
   if(g_lines_cleared) return false;
   double price=g_saved_stop;
   if(!g_restore_stop)
   {
   double low=ChartGetDouble(0,CHART_PRICE_MIN,0);
   double high=ChartGetDouble(0,CHART_PRICE_MAX,0);
   MqlTick tick;
   if(high<=low || !SymbolInfoTick(_Symbol,tick)) return false;
   double current=tick.bid;
   if(current<=0.0) current=tick.last;
   if(current<=0.0) current=tick.ask;
   if(current<=0.0) return false;

   // In the bottom 20% of the visible range, place the stop above price.
   double edge=(current-low<=(high-low)*0.20) ? high : low;
   price=StopPrice((current+edge)*0.5);
   }
   if(!ObjectCreate(0,N_STOP_LINE,OBJ_HLINE,0,0,price)) return false;
   ObjectSetInteger(0,N_STOP_LINE,OBJPROP_COLOR,C'232,103,113');
   ObjectSetInteger(0,N_STOP_LINE,OBJPROP_STYLE,STYLE_DASH);
   ObjectSetInteger(0,N_STOP_LINE,OBJPROP_WIDTH,1);
   ObjectSetInteger(0,N_STOP_LINE,OBJPROP_BACK,true);
   ObjectSetInteger(0,N_STOP_LINE,OBJPROP_SELECTABLE,true);
   ObjectSetInteger(0,N_STOP_LINE,OBJPROP_SELECTED,true);
   ObjectSetInteger(0,N_STOP_LINE,OBJPROP_HIDDEN,true);
   ObjectSetInteger(0,N_STOP_LINE,OBJPROP_ZORDER,5);
   ObjectSetString(0,N_STOP_LINE,OBJPROP_TOOLTIP,"Stop loss | drag to move");
   if(!Label(N_STOP_PRICE,"",0,0,FS(8),C'232,103,113',"Segoe UI Semibold",6))
   {
      Del(N_STOP_LINE);
      return false;
   }
   ObjectSetInteger(0,N_STOP_PRICE,OBJPROP_ANCHOR,ANCHOR_RIGHT_LOWER);
   Visible(N_STOP_PRICE,false);
   g_stop_initialized=true;
   UpdateStopLabel();
   ChartRedraw();
   return true;
}

//====================================================================
// Size / layout
//====================================================================
void UpdateRiskUnit()
{
   bool dollar=(g_risk_unit==RISK_DOLLAR);
   RectStyle(N_DOLLAR_BG,dollar ? C_ACCENT : C_BTN,dollar ? C_ACCENT : C_FRAME);
   bool percent=(g_risk_unit==RISK_PERCENT);
   bool lot=(g_risk_unit==RISK_LOT);
   RectStyle(N_PERCENT_BG,percent ? C_ACCENT : C_BTN,percent ? C_ACCENT : C_FRAME);
   RectStyle(N_LOT_BG,lot ? C_ACCENT : C_BTN,lot ? C_ACCENT : C_FRAME);
   ObjectSetInteger(0,N_DOLLAR_TX,OBJPROP_COLOR,dollar ? C_TEXT : C_MUTED);
   ObjectSetInteger(0,N_PERCENT_TX,OBJPROP_COLOR,percent ? C_TEXT : C_MUTED);
   ObjectSetInteger(0,N_LOT_TX,OBJPROP_COLOR,lot ? C_TEXT : C_MUTED);
   ChartRedraw();
}

void CommitRiskValue()
{
   string value=ObjectGetString(0,N_RISK_EDIT,OBJPROP_TEXT);
   StringTrimLeft(value);
   StringTrimRight(value);
   bool digit=false,decimal=false,valid=true;
   for(int i=0;i<StringLen(value);i++)
   {
      ushort c=StringGetCharacter(value,i);
      if(c>='0' && c<='9') digit=true;
      else if(c=='.' && !decimal) decimal=true;
      else { valid=false; break; }
   }
   double number=StringToDouble(value);
   if(valid && digit && MathIsValidNumber(number) && number>=0.0)
   {
      // Preserve the user's numeric text; broker volume limits are applied by PositionVolumeText.
      g_risk_value=number;
      g_risk_text=value;
      if(g_risk_unit==RISK_DOLLAR) g_dollar_text=value;
      else if(g_risk_unit==RISK_PERCENT) g_percent_text=value;
      else g_lot_text=value;
   }
   ObjectSetString(0,N_RISK_EDIT,OBJPROP_TEXT,g_risk_text);
   SaveState();
   ChartRedraw();
}

int PanelHeight()
{
   if(g_minimized)
      return S(HEADER_H);

   return S(HEADER_H + BODY_H);
}

void Layout(bool redraw=true)
{
   int w=S(BASE_W);
   int h=PanelHeight();

   XYWH(N_SHADOW,g_x+S(3),g_y+S(4),w,h);
   XYWH(N_FRAME,g_x,g_y,w,h);
   XYWH(N_BODY,g_x+S(1),g_y+S(1),w-S(2),h-S(2));

   XYWH(N_HEADER,g_x+S(1),g_y+S(1),w-S(2),S(HEADER_H)-S(1));
   XYWH(N_TOPLINE,g_x+S(1),g_y+S(1),w-S(2),S(2));

   XY(N_TITLE,g_x+S(6),g_y+S(5));
   XY(N_SUBTITLE,g_x+S(176),g_y+S(6));

   XYWH(N_MIN_BG,g_x+w-S(46),g_y+S(3),S(20),S(20));
   CenterText(N_MIN_TX,g_x+w-S(46),g_y+S(3),S(20),S(20));

   XYWH(N_CLOSE_BG,g_x+w-S(24),g_y+S(3),S(20),S(20));
   CenterText(N_CLOSE_TX,g_x+w-S(24),g_y+S(3),S(20),S(20));

   ObjectSetString(0,N_MIN_TX,OBJPROP_TEXT,g_minimized ? "+" : "–");

   bool show=!g_minimized;
   Visible(N_LEFT_BG,show);
   Visible(N_CLEAR_BG,show); Visible(N_CLEAR_TX,show);
   Visible(N_LEFT_TX,show);
   Visible(N_RIGHT_BG,show);
   Visible(N_RIGHT_TX,show);
   Visible(N_RISK_EDIT,show);
   Visible(N_DOLLAR_BG,show);
   Visible(N_DOLLAR_TX,show);
   Visible(N_PERCENT_BG,show);
   Visible(N_PERCENT_TX,show);
   Visible(N_LOT_BG,show); Visible(N_LOT_TX,show);
   Visible(N_MARKET_BG,show);
   Visible(N_MARKET_TX,show);
   Visible(N_LIMIT_BG,show);
   Visible(N_LIMIT_TX,show);
   Visible(N_TP_TITLE,show); Visible(N_TP_EDIT,show);
   Visible(N_TP_RR_BG,show); Visible(N_TP_RR_TX,show);
   Visible(N_TP_VALUE_BG,show); Visible(N_TP_VALUE_TX,show);
   Visible(N_STEPS_TITLE,show);
   Visible(N_DAY_TITLE,show); Visible(N_DAY_VALUE,show);
   for(int i=0;i<3;i++) { Visible(N_STEPS_BG[i],show); Visible(N_STEPS_TX[i],show); }

   if(show)
   {
      int left =g_x+S(OUTER_PAD);
      int right=g_x+w-S(OUTER_PAD);
      int y=g_y+S(HEADER_H+BODY_H-OUTER_PAD-BUTTON_H);

      int risk_y=g_y+S(HEADER_H+8);
      XYWH(N_RISK_EDIT,left,risk_y,S(126),S(28));
      XYWH(N_DOLLAR_BG,left+S(134),risk_y,S(36),S(28));
      CenterText(N_DOLLAR_TX,left+S(134),risk_y,S(36),S(28));
      XYWH(N_PERCENT_BG,left+S(174),risk_y,S(36),S(28));
      CenterText(N_PERCENT_TX,left+S(174),risk_y,S(36),S(28));
      XYWH(N_LOT_BG,left+S(214),risk_y,S(44),S(28));
      CenterText(N_LOT_TX,left+S(214),risk_y,S(44),S(28));

      int mode_y=risk_y+S(34);
      XYWH(N_MARKET_BG,left,mode_y,S(127),S(26));
      CenterText(N_MARKET_TX,left,mode_y,S(127),S(26));
      XYWH(N_LIMIT_BG,left+S(131),mode_y,S(127),S(26));
      CenterText(N_LIMIT_TX,left+S(131),mode_y,S(127),S(26));

      int tp_y=mode_y+S(34);
      XY(N_TP_TITLE,left,tp_y+S(6));
      XYWH(N_TP_EDIT,left+S(24),tp_y,S(120),S(28));
      XYWH(N_TP_RR_BG,left+S(150),tp_y,S(48),S(28));
      CenterText(N_TP_RR_TX,left+S(150),tp_y,S(48),S(28));
      XYWH(N_TP_VALUE_BG,left+S(202),tp_y,S(56),S(28));
      CenterText(N_TP_VALUE_TX,left+S(202),tp_y,S(56),S(28));
      int steps_y=tp_y+S(34);
      XY(N_DAY_TITLE,left,steps_y+S(34));
      ObjectSetInteger(0,N_DAY_VALUE,OBJPROP_ANCHOR,ANCHOR_RIGHT_UPPER);
      XY(N_DAY_VALUE,right,steps_y+S(34));
      XY(N_STEPS_TITLE,left,steps_y+S(5));
      for(int i=0;i<3;i++)
      {
         XYWH(N_STEPS_BG[i],left+S(102+i*52),steps_y,S(50),S(26));
         CenterText(N_STEPS_TX[i],left+S(102+i*52),steps_y,S(50),S(26));
      }

      XYWH(N_LEFT_BG,left,y,S(72),S(BUTTON_H));
      CenterText(N_LEFT_TX,left,y,S(72),S(BUTTON_H));
      XYWH(N_CLEAR_BG,left+S(78),y,S(70),S(BUTTON_H));
      CenterText(N_CLEAR_TX,left+S(78),y,S(70),S(BUTTON_H));

      XYWH(N_RIGHT_BG,right-S(104),y,S(104),S(BUTTON_H));
      CenterText(N_RIGHT_TX,right-S(104),y,S(104),S(BUTTON_H));
   }

   if(redraw)
      ChartRedraw();
}

//====================================================================
// Build / delete
//====================================================================
void DeleteAll()
{
   string names[]=
   {
      N_SHADOW,N_FRAME,N_BODY,N_HEADER,N_TOPLINE,
      N_TITLE,N_SUBTITLE,
      N_MIN_BG,N_MIN_TX,N_CLOSE_BG,N_CLOSE_TX,
      N_LEFT_BG,N_LEFT_TX,N_RIGHT_BG,N_RIGHT_TX,N_CLEAR_BG,N_CLEAR_TX,
      N_RISK_EDIT,N_DOLLAR_BG,N_DOLLAR_TX,N_PERCENT_BG,N_PERCENT_TX,N_LOT_BG,N_LOT_TX,
      N_STOP_LINE,N_STOP_PRICE,N_ENTRY_LINE,N_ENTRY_PRICE,
      N_MARKET_BG,N_MARKET_TX,N_LIMIT_BG,N_LIMIT_TX,
      N_TP_LINE,N_TP_PRICE,N_TP_TITLE,N_TP_EDIT,N_TP_RR_BG,N_TP_RR_TX,N_TP_VALUE_BG,N_TP_VALUE_TX
   };

   for(int i=0;i<ArraySize(names);i++)
      Del(names[i]);
   Del(N_STEPS_TITLE);
   Del(N_DAY_TITLE); Del(N_DAY_VALUE);
   for(int i=0;i<3;i++) { Del(N_STEPS_BG[i]); Del(N_STEPS_TX[i]); }
   for(int i=0;i<2;i++)
   {
      Del(N_STAGE_LINE[i]); Del(N_STAGE_LABEL[i]);
      g_stage_caption[i]=""; g_stage_x[i]=-1; g_stage_y[i]=-1; g_stage_visible[i]=false;
   }

   g_stop_initialized=false;
   g_stop_caption="";
   g_stop_label_x=-1;
   g_stop_label_y=-1;
   g_stop_label_visible=false;
   g_entry_initialized=false;
   g_entry_caption="";
   g_entry_label_x=-1;
   g_entry_label_y=-1;
   g_entry_label_visible=false;

   g_tp_initialized=false; g_tp_caption="";
   g_tp_x=-1; g_tp_y=-1; g_tp_visible=false;

   ChartRedraw();
}

bool Build()
{
   DeleteAll();

   int w=S(BASE_W);
   int h=PanelHeight();

   if(!Rect(N_SHADOW,g_x+S(3),g_y+S(4),w,h,C_SHADOW,C_SHADOW,0)) return false;
   if(!Rect(N_FRAME,g_x,g_y,w,h,C_FRAME,C_FRAME,1)) return false;
   if(!Rect(N_BODY,g_x+S(1),g_y+S(1),w-S(2),h-S(2),C_BODY,C_BODY,2)) return false;

   if(!Rect(N_HEADER,g_x,g_y,w,S(HEADER_H),C_HEADER,C_HEADER,10)) return false;
   if(!Rect(N_TOPLINE,g_x,g_y,w,S(2),C_HEADER_TOP,C_HEADER_TOP,11)) return false;

   if(!Label(N_TITLE,"Risk Management",g_x,g_y,FS(8),C_TEXT,"Segoe UI Semibold",20)) return false;
   if(!Label(N_SUBTITLE,"| WINDOW",g_x,g_y,FS(5),C_MUTED,"Segoe UI",20)) return false;

   if(!Rect(N_MIN_BG,g_x,g_y,S(14),S(14),C_BTN,C_BTN,30)) return false;
   if(!Label(N_MIN_TX,"–",g_x,g_y,FS(8),C_TEXT2,"Segoe UI Semibold",31)) return false;

   if(!Rect(N_CLOSE_BG,g_x,g_y,S(14),S(14),C_CLOSE,C_CLOSE,30)) return false;
   if(!Label(N_CLOSE_TX,"×",g_x,g_y,FS(8),C_TEXT,"Segoe UI Semibold",31)) return false;

   if(!ObjectCreate(0,N_RISK_EDIT,OBJ_EDIT,0,0,0)) return false;
   ObjectSetInteger(0,N_RISK_EDIT,OBJPROP_CORNER,CORNER_LEFT_UPPER);
   ObjectSetInteger(0,N_RISK_EDIT,OBJPROP_BGCOLOR,C_BODY);
   ObjectSetInteger(0,N_RISK_EDIT,OBJPROP_BORDER_COLOR,C_FRAME);
   ObjectSetInteger(0,N_RISK_EDIT,OBJPROP_COLOR,C_TEXT);
   ObjectSetInteger(0,N_RISK_EDIT,OBJPROP_FONTSIZE,FS(9));
   ObjectSetInteger(0,N_RISK_EDIT,OBJPROP_ALIGN,ALIGN_CENTER);
   ObjectSetInteger(0,N_RISK_EDIT,OBJPROP_READONLY,false);
   ObjectSetInteger(0,N_RISK_EDIT,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(0,N_RISK_EDIT,OBJPROP_HIDDEN,true);
   ObjectSetInteger(0,N_RISK_EDIT,OBJPROP_ZORDER,30);
   ObjectSetString(0,N_RISK_EDIT,OBJPROP_FONT,"Segoe UI");
   ObjectSetString(0,N_RISK_EDIT,OBJPROP_TEXT,g_risk_text);
   ObjectSetString(0,N_RISK_EDIT,OBJPROP_TOOLTIP,"Risk amount (e.g. 10 or 2.5)");
   if(!Rect(N_DOLLAR_BG,g_x,g_y,S(36),S(28),C_BTN,C_FRAME,30)) return false;
   if(!Label(N_DOLLAR_TX,"$",g_x,g_y,FS(10),C_TEXT,"Segoe UI Semibold",31)) return false;
   if(!Rect(N_PERCENT_BG,g_x,g_y,S(36),S(28),C_BTN,C_FRAME,30)) return false;
   if(!Label(N_PERCENT_TX,"%",g_x,g_y,FS(10),C_TEXT,"Segoe UI Semibold",31)) return false;
   if(!Rect(N_LOT_BG,g_x,g_y,S(44),S(28),C_BTN,C_FRAME,30)) return false;
   if(!Label(N_LOT_TX,"Lot",g_x,g_y,FS(8),C_TEXT,"Segoe UI Semibold",31)) return false;
   UpdateRiskUnit();

   if(!Rect(N_MARKET_BG,g_x,g_y,S(127),S(26),C_BTN,C_FRAME,30)) return false;
   if(!Label(N_MARKET_TX,"Market",g_x,g_y,FS(8),C_TEXT,"Segoe UI Semibold",31)) return false;
   if(!Rect(N_LIMIT_BG,g_x,g_y,S(127),S(26),C_BTN,C_FRAME,30)) return false;
   if(!Label(N_LIMIT_TX,"Limit",g_x,g_y,FS(8),C_TEXT,"Segoe UI Semibold",31)) return false;
   UpdateEntryModeStyle();

   // Bottom buttons retained from the original panel.
   if(!Label(N_TP_TITLE,"TP",g_x,g_y,FS(8),C_MUTED)) return false;
   if(!ObjectCreate(0,N_TP_EDIT,OBJ_EDIT,0,0,0)) return false;
   ObjectSetInteger(0,N_TP_EDIT,OBJPROP_CORNER,CORNER_LEFT_UPPER);
   ObjectSetInteger(0,N_TP_EDIT,OBJPROP_BGCOLOR,C_BODY);
   ObjectSetInteger(0,N_TP_EDIT,OBJPROP_BORDER_COLOR,C_FRAME);
   ObjectSetInteger(0,N_TP_EDIT,OBJPROP_COLOR,C_TEXT);
   ObjectSetInteger(0,N_TP_EDIT,OBJPROP_FONTSIZE,FS(9));
   ObjectSetInteger(0,N_TP_EDIT,OBJPROP_ALIGN,ALIGN_CENTER);
   ObjectSetInteger(0,N_TP_EDIT,OBJPROP_READONLY,false);
   ObjectSetInteger(0,N_TP_EDIT,OBJPROP_SELECTABLE,false);
   ObjectSetInteger(0,N_TP_EDIT,OBJPROP_HIDDEN,true);
   ObjectSetInteger(0,N_TP_EDIT,OBJPROP_ZORDER,30);
   ObjectSetString(0,N_TP_EDIT,OBJPROP_FONT,"Segoe UI");
   if(!Rect(N_TP_RR_BG,g_x,g_y,S(48),S(28),C_BTN,C_FRAME,30)) return false;
   if(!Label(N_TP_RR_TX,"R:R",g_x,g_y,FS(8),C_TEXT,"Segoe UI Semibold",31)) return false;
   if(!Rect(N_TP_VALUE_BG,g_x,g_y,S(56),S(28),C_BTN,C_FRAME,30)) return false;
   if(!Label(N_TP_VALUE_TX,"Price",g_x,g_y,FS(8),C_TEXT,"Segoe UI Semibold",31)) return false;
   TPControls();

   if(!Label(N_STEPS_TITLE,"Entries",g_x,g_y,FS(8),C_MUTED)) return false;
   for(int i=0;i<3;i++)
   {
      if(!Rect(N_STEPS_BG[i],g_x,g_y,S(50),S(26),C_BTN,C_FRAME,30)) return false;
      if(!Label(N_STEPS_TX[i],IntegerToString(i+1),g_x,g_y,FS(8),C_TEXT,"Segoe UI Semibold",31)) return false;
   }
   StepControls();
   if(!Label(N_DAY_TITLE,"Today P/L",g_x,g_y,FS(7),C_MUTED)) return false;
   if(!Label(N_DAY_VALUE,"--  |  --%",g_x,g_y,FS(7),C_MUTED,"Segoe UI Semibold")) return false;
   g_day_refresh=0;
   if(!Rect(N_LEFT_BG,g_x,g_y,S(72),S(BUTTON_H),C_BTN,C_FRAME,20)) return false;
   if(!Label(N_LEFT_TX,"Reset",g_x,g_y,FS(7),C_TEXT2,"Segoe UI",21)) return false;
   if(!Rect(N_CLEAR_BG,g_x,g_y,S(70),S(BUTTON_H),C_BTN,C_FRAME,20)) return false;
   if(!Label(N_CLEAR_TX,"Clear",g_x,g_y,FS(7),C_TEXT2,"Segoe UI",21)) return false;

   if(!Rect(N_RIGHT_BG,g_x,g_y,S(104),S(BUTTON_H),C_ACCENT,C_ACCENT,20)) return false;
   if(!Label(N_RIGHT_TX,"EXECUTE",g_x,g_y,FS(7),C_TEXT,"Segoe UI Semibold",21)) return false;

   Layout();
   return true;
}

//====================================================================
// Hit testing
//====================================================================
bool OverMin(int mx,int my)
{
   return HitObject(N_MIN_BG,mx,my);
}

bool OverClose(int mx,int my)
{
   return HitObject(N_CLOSE_BG,mx,my);
}

bool OverHeader(int mx,int my)
{
   if(!Hit(mx,my,g_x,g_y,S(BASE_W),S(HEADER_H)))
      return false;

   if(OverMin(mx,my) || OverClose(mx,my))
      return false;

   return true;
}

bool OverLeft(int mx,int my)
{
   return !g_minimized && HitObject(N_LEFT_BG,mx,my);
}

bool OverRight(int mx,int my)
{
   return !g_minimized && HitObject(N_RIGHT_BG,mx,my);
}

//====================================================================
// Dragging
//====================================================================
void KeepInside()
{
   long cw=0,ch=0;
   ChartGetInteger(0,CHART_WIDTH_IN_PIXELS,0,cw);
   ChartGetInteger(0,CHART_HEIGHT_IN_PIXELS,0,ch);

   int w=S(BASE_W);
   int visible_h=PanelHeight();

   if(g_x<0) g_x=0;
   if(g_y<0) g_y=0;

   if(g_x+w>(int)cw)
      g_x=(int)MathMax(0,cw-w);

   if(g_y+visible_h>(int)ch)
      g_y=(int)MathMax(0,ch-visible_h);
}

void BeginDrag(int mx,int my)
{
   g_dragging=true;
   g_drag_dx=mx-g_x;
   g_drag_dy=my-g_y;

   long scroll=1;
   ChartGetInteger(0,CHART_MOUSE_SCROLL,0,scroll);
   g_chart_scroll_before=(scroll!=0);
   ChartSetInteger(0,CHART_MOUSE_SCROLL,false);
}

void EndDrag()
{
   if(!g_dragging)
      return;

   g_dragging=false;
   KeepInside();
   Layout();
   ChartSetInteger(0,CHART_MOUSE_SCROLL,g_chart_scroll_before);
}

color ExecuteRiskColor(double percent)
{
   if(percent<=1.0) return C'164,224,180';
   if(percent<3.0) return C'24,142,72';
   double t=MathMin(1.0,(percent-3.0)/7.0);
   int red=(int)MathRound(24+(230-24)*t);
   int green=(int)MathRound(142*(1.0-t));
   int blue=(int)MathRound(72*(1.0-t));
   return (color)(red | (green<<8) | (blue<<16));
}

void UpdateExecuteRisk()
{
   if(ObjectFind(0,N_RIGHT_BG)<0) return;
   double balance=AccountInfoDouble(ACCOUNT_BALANCE);
   double total=0.0;
   bool valid=(!g_lines_cleared && balance>0.0);
   for(int i=0;i<g_steps && valid;i++)
   {
      double loss;
      PositionVolumeText(loss,i==0 ? N_ENTRY_LINE : N_STAGE_LINE[i-1]);
      if(loss<0.0 || !MathIsValidNumber(loss)) valid=false;
      else total+=loss;
   }
   double percent=valid ? total/balance*100.0 : 0.0;
   color bg=valid ? ExecuteRiskColor(percent) : C_BTN;
   color fg=valid && percent<=1.0 ? C'16,55,29' : C_TEXT;
   // Preserve the risk hue while the button is held down.
   if(g_pressed==PRESS_RIGHT)
   {
      uint rgb=(uint)bg;
      bg=(color)(((rgb&255)*4/5) | ((((rgb>>8)&255)*4/5)<<8) | ((((rgb>>16)&255)*4/5)<<16));
   }
   string tip=valid ? "Total risk: "+DoubleToString(percent,2)+"% of balance | "+
      DoubleToString(total,2)+" "+AccountInfoString(ACCOUNT_CURRENCY)+
      " | "+IntegerToString(g_steps)+" entries" : "Risk unavailable: check entry, stop and balance";
   if(valid && percent>=10.0) tip+=" | HIGH RISK";
   bool changed=((color)ObjectGetInteger(0,N_RIGHT_BG,OBJPROP_BGCOLOR)!=bg ||
                 (color)ObjectGetInteger(0,N_RIGHT_TX,OBJPROP_COLOR)!=fg ||
                 ObjectGetString(0,N_RIGHT_BG,OBJPROP_TOOLTIP)!=tip);
   if(!changed) return;
   RectStyle(N_RIGHT_BG,bg,bg);
   ObjectSetInteger(0,N_RIGHT_TX,OBJPROP_COLOR,fg);
   ObjectSetString(0,N_RIGHT_BG,OBJPROP_TOOLTIP,tip);
   ObjectSetString(0,N_RIGHT_TX,OBJPROP_TOOLTIP,tip);
   ChartRedraw();
}

void ResetPressed()
{
   RectStyle(N_MIN_BG,C_BTN,C_BTN);
   RectStyle(N_CLOSE_BG,C_CLOSE,C_CLOSE);
   RectStyle(N_LEFT_BG,C_BTN,C_FRAME);
   UpdateExecuteRisk();
   ChartRedraw();
}

//====================================================================
// Lifecycle
//====================================================================
void ExecutionError(string message)
{
   Print("RiskManagement: ",message);
   Alert("RiskManagement: ",message);
   ObjectSetString(0,N_RIGHT_BG,OBJPROP_TOOLTIP,message);
}

bool PrepareRequest(int stage,MqlTradeRequest &request,string &error)
{
   ZeroMemory(request);
   string line=stage==0 ? N_ENTRY_LINE : N_STAGE_LINE[stage-1];
   if(ObjectFind(0,line)<0 || ObjectFind(0,N_STOP_LINE)<0 || ObjectFind(0,N_TP_LINE)<0)
   { error="Missing entry, SL or TP line."; return false; }
   MqlTick tick;
   if(!SymbolInfoTick(_Symbol,tick) || tick.ask<=0.0 || tick.bid<=0.0)
   { error="No valid quote."; return false; }
   double first=ObjectGetDouble(0,N_ENTRY_LINE,OBJPROP_PRICE);
   double sl=StopPrice(ObjectGetDouble(0,N_STOP_LINE,OBJPROP_PRICE));
   double tp=StopPrice(ObjectGetDouble(0,N_TP_LINE,OBJPROP_PRICE));
   bool buy=first>sl;
   bool market=(stage==0 && g_entry_mode==ENTRY_MARKET);
   double price=market ? (buy ? tick.ask : tick.bid) : StopPrice(ObjectGetDouble(0,line,OBJPROP_PRICE));
   double loss;
   PositionVolumeText(loss,line);
   if(loss<0.0 || g_calc_volume<=0.0)
   { error="Invalid risk/SL or volume below broker minimum."; return false; }
   if(price<=0.0 || sl<=0.0 || tp<=0.0 ||
      (buy && (sl>=price || tp<=price)) || (!buy && (sl<=price || tp>=price)))
   { error="SL and TP must be on the correct sides of every entry."; return false; }
   double gap=SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)*_Point;
   double reference=market ? (buy ? tick.bid : tick.ask) : price;
   if((buy && (reference-sl<gap || tp-reference<gap)) ||
      (!buy && (sl-reference<gap || reference-tp<gap)))
   { error="SL/TP is too close for the broker's stop distance."; return false; }
   request.action=market ? TRADE_ACTION_DEAL : TRADE_ACTION_PENDING;
   request.type=buy ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
   if(!market)
   {
      double quote=buy ? tick.ask : tick.bid;
      if(MathAbs(price-quote)<MathMax(gap,_Point*0.5))
      { error="Pending entry is too close to the current quote."; return false; }
      request.type=buy ? (price<quote ? ORDER_TYPE_BUY_LIMIT : ORDER_TYPE_BUY_STOP)
                       : (price>quote ? ORDER_TYPE_SELL_LIMIT : ORDER_TYPE_SELL_STOP);
   }
   request.symbol=_Symbol;
   request.magic=InpMagicNumber;
   request.volume=g_calc_volume;
   request.price=price;
   request.sl=sl; request.tp=tp;
   request.deviation=InpDeviationPoints;
   request.type_time=ORDER_TIME_GTC;
   request.type_filling=ORDER_FILLING_RETURN;
   if(market)
   {
      long flags=SymbolInfoInteger(_Symbol,SYMBOL_FILLING_MODE);
      if((flags&SYMBOL_FILLING_FOK)!=0) request.type_filling=ORDER_FILLING_FOK;
      else if((flags&SYMBOL_FILLING_IOC)!=0) request.type_filling=ORDER_FILLING_IOC;
      else if(SymbolInfoInteger(_Symbol,SYMBOL_TRADE_EXEMODE)==SYMBOL_TRADE_EXECUTION_MARKET)
      { error="No supported market filling policy."; return false; }
   }
   request.comment="RiskManagement #"+IntegerToString(stage+1);
   return true;
}

void ExecutePlan()
{
   if(g_executing) return;
   if(g_lines_cleared)
   { ExecutionError("Use Reset to create a trading plan first."); return; }
   if(!TerminalInfoInteger(TERMINAL_CONNECTED) || !TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) ||
      !MQLInfoInteger(MQL_TRADE_ALLOWED) || !AccountInfoInteger(ACCOUNT_TRADE_ALLOWED) ||
      !AccountInfoInteger(ACCOUNT_TRADE_EXPERT))
   { ExecutionError("Trading is unavailable. Check connection and Algo Trading permissions."); return; }
   // Netting adds to or offsets an existing position, including unrelated trades.
   if(AccountInfoInteger(ACCOUNT_MARGIN_MODE)!=ACCOUNT_MARGIN_MODE_RETAIL_HEDGING && PositionSelect(_Symbol))
   { ExecutionError("An existing netting position on this symbol must be managed before starting a new plan."); return; }
   CommitRiskValue(); CommitTP(); RefreshEntry();
   MqlTradeRequest requests[3];
   string error;
   double total_margin=0.0;
   for(int i=0;i<g_steps;i++)
   {
      if(!PrepareRequest(i,requests[i],error))
      { ExecutionError("Entry "+IntegerToString(i+1)+": "+error); return; }
      MqlTradeCheckResult check={};
      if(!OrderCheck(requests[i],check))
      { ExecutionError("Entry "+IntegerToString(i+1)+": "+check.comment+" ("+IntegerToString(check.retcode)+")"); return; }
      double margin=0.0;
      bool buy=requests[i].type==ORDER_TYPE_BUY || requests[i].type==ORDER_TYPE_BUY_LIMIT || requests[i].type==ORDER_TYPE_BUY_STOP;
      if(!OrderCalcMargin(buy ? ORDER_TYPE_BUY : ORDER_TYPE_SELL,_Symbol,requests[i].volume,requests[i].price,margin))
      { ExecutionError("Cannot calculate margin for entry "+IntegerToString(i+1)); return; }
      total_margin+=margin;
   }
   if(total_margin>AccountInfoDouble(ACCOUNT_MARGIN_FREE))
   { ExecutionError("Insufficient free margin for all entries."); return; }
   // Guard only the active submission; later clicks may execute the same plan again.
   g_executing=true;
   int accepted=0;
   string details="";
   for(int i=0;i<g_steps;i++)
   {
      MqlTradeCheckResult check={};
      if(!OrderCheck(requests[i],check))
      { details="Entry "+IntegerToString(i+1)+" check failed: "+check.comment; break; }
      MqlTradeResult result={};
      bool sent=OrderSend(requests[i],result);
      PrintFormat("Entry %d: sent=%s retcode=%u order=%I64u deal=%I64u volume=%.8f %s",
                  i+1,sent ? "true" : "false",result.retcode,result.order,result.deal,result.volume,result.comment);
      if(sent && (result.retcode==TRADE_RETCODE_DONE || result.retcode==TRADE_RETCODE_PLACED ||
                  result.retcode==TRADE_RETCODE_DONE_PARTIAL))
      {
         accepted++;
         if(result.retcode==TRADE_RETCODE_DONE_PARTIAL)
         { details="Entry "+IntegerToString(i+1)+" partially filled; remaining entries were not sent."; break; }
      }
      else
      { details="Entry "+IntegerToString(i+1)+": "+result.comment+" ("+IntegerToString(result.retcode)+"). Check Trade/History before retrying."; break; }
   }
   g_executing=false;
   string summary=IntegerToString(accepted)+"/"+IntegerToString(g_steps)+" entries accepted. "+details;
   ObjectSetString(0,N_RIGHT_BG,OBJPROP_TOOLTIP,summary);
   if(accepted<g_steps || details!="") ExecutionError(summary);
   else
   {
      Print(summary);
      ClearLines();
      UpdateExecuteRisk();
   }
   ChartRedraw();
}

int OnInit()
{
   g_scale=InpUIScale;
   if(g_scale<0.70) g_scale=0.70;
   if(g_scale>1.50) g_scale=1.50;

   // Chart-local storage is also symbol-specific; never reuse another symbol's prices.
   // Legacy state has no symbol identity and therefore cannot be safely migrated.
   N_STATE="RM_STATE_V2_"+_Symbol;
   N_EXEC_LOCK="RM_EXEC_"+IntegerToString(AccountInfoInteger(ACCOUNT_LOGIN))+"_"+_Symbol;
   // Remove the persistent submission guard left by earlier versions.
   Del(N_EXEC_LOCK);
   SetDefaults();
   LoadState();
   g_risk_text=g_risk_unit==RISK_DOLLAR ? g_dollar_text : (g_risk_unit==RISK_PERCENT ? g_percent_text : g_lot_text);
   g_risk_value=StringToDouble(g_risk_text);
   g_prev_left=false;
   g_dragging=false;
   g_pressed=PRESS_NONE;

   ChartSetInteger(0,CHART_EVENT_MOUSE_MOVE,true);

   if(!Build())
      return INIT_FAILED;

   // Retry from the timer if chart geometry or quotes are not ready yet.
   CreateStopLine();
   RefreshEntry();
   if(!EventSetMillisecondTimer(50)) return INIT_FAILED;

   g_state_ready=true;
   SaveState();

   return INIT_SUCCEEDED;
}

void OnDeinit(const int reason)
{
   EventKillTimer();
   if(g_state_ready && ObjectFind(0,N_RISK_EDIT)>=0) CommitRiskValue();
   if(g_state_ready && ObjectFind(0,N_TP_EDIT)>=0) CommitTP();
   SaveState();
   g_state_ready=false;
   if(g_dragging)
      ChartSetInteger(0,CHART_MOUSE_SCROLL,g_chart_scroll_before);

   DeleteAll();
}

void OnTick()
{
   RefreshEntry();
}

void UpdateDailyPL()
{
   ulong now_ms=GetTickCount64();
   if(g_day_refresh!=0 && now_ms-g_day_refresh<5000) return;
   g_day_refresh=now_ms;
   datetime now=TimeTradeServer();
   if(now<=0) now=TimeCurrent();
   MqlDateTime day;
   if(now<=0 || !TimeToStruct(now,day)) return;
   day.hour=0; day.min=0; day.sec=0;
   datetime start=StructToTime(day);
   if(!HistorySelect(start,now))
   {
      SetTextIfChanged(N_DAY_VALUE,"--  |  --%");
      ObjectSetInteger(0,N_DAY_VALUE,OBJPROP_COLOR,C_MUTED);
      return;
   }
   double net=0.0,balance_change=0.0;
   for(int i=0;i<HistoryDealsTotal();i++)
   {
      ulong ticket=HistoryDealGetTicket(i);
      if(ticket==0) continue;
      ENUM_DEAL_TYPE type=(ENUM_DEAL_TYPE)HistoryDealGetInteger(ticket,DEAL_TYPE);
      double amount=HistoryDealGetDouble(ticket,DEAL_PROFIT)+HistoryDealGetDouble(ticket,DEAL_COMMISSION)+
                    HistoryDealGetDouble(ticket,DEAL_SWAP)+HistoryDealGetDouble(ticket,DEAL_FEE);
      // Deposits/withdrawals affect the opening-balance reconstruction, not trading P/L.
      if(type!=DEAL_TYPE_CREDIT) balance_change+=amount;
      bool trade=(type==DEAL_TYPE_BUY || type==DEAL_TYPE_SELL);
      bool commission=(type==DEAL_TYPE_COMMISSION || type==DEAL_TYPE_COMMISSION_DAILY ||
                       type==DEAL_TYPE_COMMISSION_MONTHLY || type==DEAL_TYPE_COMMISSION_AGENT_DAILY ||
                       type==DEAL_TYPE_COMMISSION_AGENT_MONTHLY);
      if(trade || commission) net+=amount;
   }
   double opening=AccountInfoDouble(ACCOUNT_BALANCE)-balance_change;
   string percent=opening>0.0 ? (net>0.0 ? "+" : "")+DoubleToString(net/opening*100.0,2)+"%" : "--%";
   string money=MoneyUSD(net,"");
   if(StringFind(money,": $")==0) money=StringSubstr(money,2);
   else money="USD --";
   if(net>0.0 && StringFind(money,"$")==0) money="+"+money;
   string text=money+"  |  "+percent;
   SetTextIfChanged(N_DAY_VALUE,text);
   ObjectSetInteger(0,N_DAY_VALUE,OBJPROP_COLOR,net>0.005 ? C'46,196,145' : (net< -0.005 ? C'232,103,113' : C_MUTED));
   ObjectSetString(0,N_DAY_VALUE,OBJPROP_TOOLTIP,
      "All account trades | Broker day "+TimeToString(start,TIME_DATE)+
      " | Realized P/L + commissions, swap and fees booked today (including entry fees). Floating P/L excluded."+
      " | Opening balance: "+DoubleToString(opening,2)+" "+AccountInfoString(ACCOUNT_CURRENCY));
   ChartRedraw();
}

void OnTradeTransaction(const MqlTradeTransaction &transaction,const MqlTradeRequest &request,const MqlTradeResult &result)
{
   g_day_refresh=0;
}

void OnTimer()
{
   UpdateDailyPL();
   if(!g_stop_initialized) CreateStopLine();
   else UpdateStopLabel();
   RefreshEntry();
   SaveState();
   UpdateExecuteRisk();
}

//====================================================================
// Events
//====================================================================
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
{
   if(id==CHARTEVENT_OBJECT_CLICK && !g_minimized && (sparam==N_CLEAR_BG || sparam==N_CLEAR_TX))
   { ClearLines(); return; }
   for(int i=0;i<2;i++)
      if((id==CHARTEVENT_OBJECT_DRAG || id==CHARTEVENT_OBJECT_CHANGE) && sparam==N_STAGE_LINE[i])
      {
         ObjectSetDouble(0,N_STAGE_LINE[i],OBJPROP_PRICE,StopPrice(ObjectGetDouble(0,N_STAGE_LINE[i],OBJPROP_PRICE)));
         UpdateEntryLabel(); SaveState(); ChartRedraw(); return;
      }
   if(id==CHARTEVENT_OBJECT_CLICK && !g_minimized)
      for(int i=0;i<3;i++)
         if(sparam==N_STEPS_BG[i] || sparam==N_STEPS_TX[i])
         {
            CommitRiskValue(); g_steps=i+1; StepControls();
            UpdateEntryLabel(); SaveState(); ChartRedraw(); return;
         }
   if(id==CHARTEVENT_OBJECT_ENDEDIT && sparam==N_TP_EDIT)
   { CommitTP(); return; }
   if((id==CHARTEVENT_OBJECT_DRAG || id==CHARTEVENT_OBJECT_CHANGE) && sparam==N_TP_LINE)
   {
      g_tp_rr=false;
      g_tp_price=StopPrice(ObjectGetDouble(0,N_TP_LINE,OBJPROP_PRICE));
      ObjectSetDouble(0,N_TP_LINE,OBJPROP_PRICE,g_tp_price);
      g_tp_last_set=g_tp_price;
      TPControls(); RefreshTP(); SaveState(); ChartRedraw();
      return;
   }
   if(id==CHARTEVENT_CHART_CHANGE)
   {
      KeepInside();
      Layout();
      UpdateStopLabel();
      UpdateEntryLabel();
      return;
   }
   if((id==CHARTEVENT_OBJECT_DRAG || id==CHARTEVENT_OBJECT_CHANGE) && sparam==N_ENTRY_LINE)
   {
      if(g_entry_mode==ENTRY_LIMIT)
         ObjectSetDouble(0,N_ENTRY_LINE,OBJPROP_PRICE,
                         StopPrice(ObjectGetDouble(0,N_ENTRY_LINE,OBJPROP_PRICE)));
      RefreshEntry();
      ChartRedraw();
      return;
   }
   if((id==CHARTEVENT_OBJECT_DRAG || id==CHARTEVENT_OBJECT_CHANGE) && sparam==N_STOP_LINE)
   {
      double price=StopPrice(ObjectGetDouble(0,N_STOP_LINE,OBJPROP_PRICE));
      ObjectSetDouble(0,N_STOP_LINE,OBJPROP_PRICE,price);
      UpdateStopLabel();
      UpdateEntryLabel();
      ChartRedraw();
      return;
   }
   if(id==CHARTEVENT_OBJECT_ENDEDIT && sparam==N_RISK_EDIT)
   {
      CommitRiskValue();
      return;
   }
   if(id==CHARTEVENT_OBJECT_CLICK && !g_minimized)
   {
      if(sparam==N_DOLLAR_BG || sparam==N_DOLLAR_TX)
      {
         SetRiskUnit(RISK_DOLLAR);
      }
      else if(sparam==N_PERCENT_BG || sparam==N_PERCENT_TX)
      {
         SetRiskUnit(RISK_PERCENT);
      }
      else if(sparam==N_LOT_BG || sparam==N_LOT_TX)
         SetRiskUnit(RISK_LOT);
      else if(sparam==N_MARKET_BG || sparam==N_MARKET_TX)
         SetEntryMode(ENTRY_MARKET);
      else if(sparam==N_LIMIT_BG || sparam==N_LIMIT_TX)
         SetEntryMode(ENTRY_LIMIT);
      else if(sparam==N_TP_RR_BG || sparam==N_TP_RR_TX ||
              sparam==N_TP_VALUE_BG || sparam==N_TP_VALUE_TX)
      {
         CommitTP();
         g_tp_rr=(sparam==N_TP_RR_BG || sparam==N_TP_RR_TX);
         TPControls(); RefreshTP(); SaveState(); ChartRedraw();
      }
      return;
   }
   if(id!=CHARTEVENT_MOUSE_MOVE)
      return;

   int mx=(int)lparam;
   int my=(int)dparam;

   // Read the actual line position during native dragging, not only on release.
   UpdateStopLabel();
   UpdateEntryLabel();

   uint state=(uint)StringToInteger(sparam);
   bool left=((state&1)==1);

   bool down=(left && !g_prev_left);
   bool up=(!left && g_prev_left);

   if(down)
   {
      g_pressed=PRESS_NONE;

      if(OverMin(mx,my))
      {
         g_pressed=PRESS_MIN;
         RectStyle(N_MIN_BG,C_BTN_PRESS,C_BTN_PRESS);
         ChartRedraw();
      }
      else if(OverClose(mx,my))
      {
         g_pressed=PRESS_CLOSE;
         RectStyle(N_CLOSE_BG,C_CLOSE_PRESS,C_CLOSE_PRESS);
         ChartRedraw();
      }
      else if(OverLeft(mx,my))
      {
         g_pressed=PRESS_LEFT;
         RectStyle(N_LEFT_BG,C_BTN_PRESS,C_FRAME);
         ChartRedraw();
      }
      else if(OverRight(mx,my))
      {
         g_pressed=PRESS_RIGHT;
         UpdateExecuteRisk();
         ChartRedraw();
      }
      else if(OverHeader(mx,my))
      {
         g_pressed=PRESS_HEADER;
         BeginDrag(mx,my);
      }
   }

   if(left && g_dragging && g_pressed==PRESS_HEADER)
   {
      g_x=mx-g_drag_dx;
      g_y=my-g_drag_dy;

      KeepInside();
      Layout(false);
      ChartRedraw();
   }

   if(up)
   {
      EPressTarget pressed=g_pressed;

      if(g_dragging)
         EndDrag();

      g_pressed=PRESS_NONE;
      ResetPressed();

      if(pressed==PRESS_MIN && OverMin(mx,my))
      {
         g_minimized=!g_minimized;
         KeepInside();
         Layout();
      }
      else if(pressed==PRESS_CLOSE && OverClose(mx,my))
      {
         g_prev_left=left;
         ExpertRemove();
         return;
      }
      else if(pressed==PRESS_LEFT && OverLeft(mx,my))
      {
         ResetAll();
      }
      else if(pressed==PRESS_RIGHT && OverRight(mx,my))
      {
         ExecutePlan();
      }
   }

   g_prev_left=left;
}
//+------------------------------------------------------------------+