| //+------------------------------------------------------------------+
|
| //| MarketReplay.mq5 |
|
| //| v9.10 - Tick engine | Pending orders | Speed slider | Trades |
|
| //| Virtual microsecond clock (0.1 ms grid), tick-by-tick SL/TP, |
|
| //| fire-on-press UI, right-click Limit/Stop orders, floating table |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Grok Replay"
|
| #property version "9.10"
|
| #property strict
|
| #property description "Tick-level Market Replay with Limit/Stop orders, speed slider, calendar range picker and Trades window"
|
|
|
| //=== ENUM ==========================================================
|
| enum ENUM_TRADE_MODE
|
| {
|
| MODE_SINGLE = 0, // Single Trade | تک‌معامله
|
| MODE_MARTINGALE = 1 // Martingale Basket | سبد مارتینگل
|
| };
|
|
|
| //=== INPUTS (Bilingual) ============================================
|
| input group "══════ [1] ACCOUNT & TRADE MODE | حساب و حالت معامله ══════"
|
| input double InpBalance = 500.0; // Starting Balance | موجودی اولیه
|
| input ENUM_TRADE_MODE InpTradeMode = MODE_MARTINGALE; // Trade Mode | حالت معامله
|
| input double InpLot = 0.02; // Initial Lot (editable in panel) | لات اولیه (در پنل قابل تغییر است)
|
| input double InpLotMin = 0.01; // Minimum Lot | حداقل لات
|
| input double InpLotMax = 100.0; // Maximum Lot | حداکثر لات
|
| input double InpLotStep = 0.01; // Lot Step | گام تغییر لات
|
|
|
| input group "══════ [2] INSTRUMENT & COSTS | مشخصات نماد و هزینه‌ها ══════"
|
| input double InpPoint = 0.01; // Point Size (Gold = 0.01) | اندازه‌ی یک پوینت (طلا = 0.01)
|
| input double InpContractSize = 100.0; // Contract Size (Gold = 100) | اندازه‌ی قرارداد (طلا = 100)
|
| input int InpSpreadPts = 26; // Fixed Spread in points (0 = none) | اسپرد ثابت به پوینت (صفر = بدون اسپرد)
|
|
|
| input group "══════ [3] LEVERAGE & MARGIN | لوریج و مارجین ══════"
|
| input int InpLeverage = 500; // Leverage 1:X (editable in panel) | لوریج ۱:X (در پنل قابل تغییر است)
|
| input double InpStopOutPct = 50.0; // Stop-out Margin Level % | سطح استاپ‌اوت (درصد)
|
| input bool InpAutoReset = true; // Auto-reset Balance on Stop-out | ریست خودکار بالانس هنگام استاپ‌اوت
|
|
|
| input group "══════ [4] SINGLE TRADE MODE | حالت تک‌معامله ══════"
|
| input int InpSLpts = 150; // Stop Loss in points | حد ضرر (پوینت)
|
| input int InpTPpts = 300; // Take Profit in points | حد سود (پوینت)
|
| input bool InpTrailing = true; // Enable Trailing Stop | فعال‌سازی تریلینگ استاپ
|
| input int InpTrailStart = 170; // Trailing Start in points of profit | شروع تریلینگ (پوینت سود)
|
| input int InpTrailStep = 50; // Trailing Step in points | فاصله‌ی تریلینگ از قیمت (پوینت)
|
|
|
| input group "══════ [5] MARTINGALE BASKET MODE | حالت سبد مارتینگل ══════"
|
| input int InpMartTPpts = 300; // Basket Take Profit in points | حد سود سبد (پوینت از میانگین ورود)
|
| input int InpMartTrailStart = 170; // Basket Trailing Start in points | شروع تریلینگ سبد (پوینت)
|
| input int InpMartTrailStep = 50; // Basket Trailing Step in points | فاصله‌ی تریلینگ سبد (پوینت)
|
| input double InpMartMultiplier = 1.0; // Lot Multiplier after a Loss | ضریب افزایش لات پس از ضرر
|
| input int InpMartMaxLevels = 40; // Maximum Martingale Levels | بیشترین سطح مارتینگل
|
|
|
| input group "══════ [6] TICK ENGINE & SPEED | موتور تیک و سرعت ══════"
|
| input ENUM_TIMEFRAMES InpBaseTF = PERIOD_M1; // Base Data Timeframe (finest) | تایم‌فریم پایه‌ی داده (ریزترین)
|
| input int InpMinTicks = 8; // Minimum Ticks per Bar | کمترین تعداد تیک در هر کندل
|
| input int InpMaxTicks = 1200; // Maximum Ticks per Bar | بیشترین تعداد تیک در هر کندل
|
| input double InpPathNoise = 0.5; // Intrabar Path Noise 0..1 | نویز مسیر قیمت داخل کندل (۰ تا ۱)
|
| input int InpUiMs = 40; // Panel Refresh in ms | بازه‌ی به‌روزرسانی پنل (میلی‌ثانیه)
|
| input bool InpFireOnPress = true; // Fire Buttons on Mouse-Down | اجرای دکمه‌ها هنگام فشردن ماوس
|
|
|
| input group "══════ [7] CHART LINES | خطوط روی چارت ══════"
|
| input color InpColEntry = clrDodgerBlue; // Entry / Pending Line Colour | رنگ خط ورود و سفارش‌های Pending
|
| input color InpColSL = clrRed; // Stop Loss Line Colour | رنگ خط حد ضرر
|
| input color InpColTP = clrLimeGreen; // Take Profit Line Colour | رنگ خط حد سود
|
|
|
| input group "══════ [8] DATA & HISTORY | داده و تاریخچه ══════"
|
| input int InpHistoryBars = 30000; // Base Bars Shown before Start | تعداد کندل پایه پیش از نقطه‌ی شروع
|
| input int InpBarsToSave = 300000; // Max Bars to Save per Timeframe | حداکثر کندل ذخیره برای هر تایم‌فریم
|
| input int InpBarsToLoad = 150000; // Max Bars to Load per Timeframe | حداکثر کندل بارگذاری برای هر تایم‌فریم
|
| input bool InpResaveOnInit = true; // Re-export History on Every Start | ذخیره‌ی دوباره‌ی تاریخچه در هر اجرا
|
|
|
| //=== Types =========================================================
|
| struct Pos
|
| {
|
| ulong ticket;
|
| int dir; // +1 BUY, -1 SELL
|
| double lots, open, sl, tp;
|
| datetime time;
|
| bool open_;
|
| int level;
|
| };
|
|
|
| struct Ord // pending order
|
| {
|
| ulong ticket;
|
| int type; // 1 BuyLimit, 2 SellLimit, 3 BuyStop, 4 SellStop
|
| double price, lots;
|
| datetime time;
|
| bool live;
|
| };
|
|
|
| struct HEv // trade-history mark queued for drawing
|
| {
|
| ulong ticket;
|
| int kind; // 0 open, 1 close
|
| int dir;
|
| datetime t, t0;
|
| double price, p0, profit;
|
| int part; // 0 = normal event, >0 = partial-close sequence number
|
| double lots; // closed volume (partial close marks)
|
| };
|
|
|
| //=== Globals =======================================================
|
| string baseSym, customSym, folderName;
|
| string P = "RP_";
|
| long panelChart = 0;
|
| bool ready = false;
|
|
|
| ENUM_TIMEFRAMES usedTF = PERIOD_M1;
|
| ENUM_TIMEFRAMES currentTF = PERIOD_M5;
|
|
|
| bool playing = false;
|
| double speedMult = 1.0;
|
| double lotSize = 0.10;
|
| bool editing = false;
|
| int leverage = 500, slPts = 0, tpPts = 0;
|
| double resetBal = 10000.0;
|
| bool trailOn = true;
|
| int trStart = 170, trStep = 50;
|
| int dragKind = 0; ulong dragTicket = 0; double dragPrice = 0, dragPrice0 = 0; string dragName = "";
|
| bool modOpen = false; ulong modTicket = 0; int modX = 0, modY = 0;
|
| const int MOD_W = 300, MOD_H = 150;
|
| bool volOpen = false; ulong volTicket = 0; int volX = 0, volY = 0; // Volume (partial close) popup
|
| HEv hev[]; string hDrawn[]; datetime curTime = 0;
|
| int partSeq = 0;
|
| int cur = 0, total = 0, endBar = 0;
|
| double bal = 0, eq = 0;
|
| MqlRates rates[]; // base series (replayed)
|
| MqlRates cser[]; // coarser TF series concatenated (history stitching)
|
| int cOff[8], cCnt[8]; ENUM_TIMEFRAMES cTF[8]; int cK = 0;
|
| int digitsN = 2;
|
| double spreadPx = 0;
|
|
|
| // --- tick engine
|
| double barDurUs = 60e6;
|
| double tkOff[];
|
| double tkBid[];
|
| double wkb[];
|
| int tkN = 0, tkIdx = 0;
|
| double barClockUs = 0;
|
| ulong lastUs = 0;
|
| ulong lastUiUs = 0;
|
| double curBid = 0, curAsk = 0;
|
| MqlTick outTk[];
|
| int outN = 0;
|
| ulong rngS = 88172645463325252;
|
| const double BUDGET_US = 8000.0;
|
|
|
| // --- UI flags
|
| bool uiForce = false, linesDirty = true, btnDirty = true, needCompact = false, ordCompact = false;
|
| bool mouseDown = false, rightDown = false;
|
| string lastMsg = "";
|
| string pendLog = "";
|
| string pressId = ""; ulong pressMs = 0;
|
|
|
| // --- registry of clickable panel buttons
|
| string rId[48]; int rX[48], rY[48], rW[48], rH[48]; int rN = 0;
|
| int panW = 480, panH = 400;
|
|
|
| // --- label cache (avoid redundant ObjectSet calls)
|
| string lcT[40]; color lcC[40];
|
| const int K_BAL=0,K_EQ=1,K_FLO=2,K_POS=3,K_TD=4,K_YD=5,K_WK=6,K_MO=7,K_LOTS=8,K_MODE=9,K_INFO=10,K_INFO2=11,
|
| K_MSG=12,K_SELL=13,K_BUY=14,K_SPEED=15,K_SPR=16,K_MG=17,K_FM=18,K_ML=19,K_LI=20;
|
|
|
| // --- speed slider
|
| const double SPD_MIN=0.1, SPD_MAX=1000.0;
|
| const int SL_TH=14, SL_H=24;
|
| int slX=0, slY=0, slW=262;
|
| bool sliderDrag = false;
|
|
|
| // --- calendar popup
|
| const int CAL_HDR=32, CAL_WK=22, CAL_CW=36, CAL_CH=28;
|
| bool calOpen=false; int calTarget=0, calYear=2026, calMon=1;
|
| int calX=0, calY=0, calW=7*36+16, calH=32+22+6*28+36;
|
| int dateRowY=0, fromFieldX=0, toFieldX=0;
|
| datetime calDate[42]; bool calOn[42];
|
| datetime selFrom=0, selTo=0, dataFirst=0, dataLast=0; bool selDirty=false;
|
| string MonName[12]={"January","February","March","April","May","June","July","August","September","October","November","December"};
|
|
|
| // --- right-click context menu
|
| bool ctxOpen=false; double ctxPrice=0; int ctxX=0, ctxY=0, ctxN=0;
|
| string ctxId[4]; int ctxRY[4];
|
| const int CTX_W=250, CTX_ROW=26;
|
|
|
| // --- Trades window
|
| bool trOpen=false; int trX=60, trY=120, trW=700, trH=250, trTop=0;
|
| bool trDrag=false, trSize=false, trSizeDirty=false; int trDX=0, trDY=0; ulong trSizeUs=0;
|
| const int TR_TITLE=24, TR_HEAD=28, TR_FOOT=36, TR_ROWH=22, TR_MAXROWS=40;
|
| string twN[600]; int twOX[600], twOY[600]; int twCnt=0;
|
| string twC[500]; color twCC[500];
|
| int twKind[800], twIdx[800], twRows=0, twVis=0;
|
|
|
| // --- stats
|
| double dayProfit = 0, ydayProfit = 0, weekProfit = 0, monthProfit = 0;
|
| double dayLots = 0, weekLots = 0, monthLots = 0;
|
| datetime lastDay = 0, lastWeek = 0, lastMonth = 0;
|
| double closedToday = 0;
|
|
|
| // --- positions & orders
|
| Pos pos[];
|
| Ord ords[];
|
| int openCnt = 0, ordLive = 0;
|
| ulong nextT = 1;
|
|
|
| // --- martingale
|
| int martLevel = 0;
|
| int martDir = 0;
|
| double basketAvg = 0, basketLots = 0, basketSL = 0, basketTP = 0;
|
| int bDir = 0;
|
| bool basketTrailActive = false;
|
|
|
| //+------------------------------------------------------------------+
|
| //| Helpers |
|
| //+------------------------------------------------------------------+
|
| string CleanBase(string sym)
|
| {
|
| while(StringFind(sym,"REPLAY_")==0) sym = StringSubstr(sym,7);
|
| StringReplace(sym,"+",""); StringReplace(sym,".","");
|
| int len=StringLen(sym);
|
| if(len>0){ string last=StringSubstr(sym,len-1,1);
|
| if(last=="m"||last=="c"||last=="p") sym=StringSubstr(sym,0,len-1); }
|
| if(StringLen(sym)<3) sym="XAUUSD";
|
| return sym;
|
| }
|
| string TFName(ENUM_TIMEFRAMES tf)
|
| {
|
| if(tf==PERIOD_M1) return "M1"; if(tf==PERIOD_M5) return "M5";
|
| if(tf==PERIOD_M15) return "M15"; if(tf==PERIOD_M30) return "M30";
|
| if(tf==PERIOD_H1) return "H1"; if(tf==PERIOD_H4) return "H4";
|
| if(tf==PERIOD_D1) return "D1"; if(tf==PERIOD_W1) return "W1"; return "M5";
|
| }
|
| string StatePath(){ return folderName+"\\state.bin"; }
|
|
|
| double Rnd()
|
| {
|
| rngS ^= rngS >> 12;
|
| rngS ^= rngS << 25;
|
| rngS ^= rngS >> 27;
|
| ulong r = rngS * 2685821657736338717;
|
| return (double)(r >> 11) * (1.0/9007199254740992.0);
|
| }
|
| void SeedRng(ulong s)
|
| {
|
| rngS = s * 6364136223846793005 + 1442695040888963407;
|
| if(rngS==0) rngS = 88172645463325252;
|
| for(int i=0;i<4;i++) Rnd();
|
| }
|
| string Px(const double v){ return DoubleToString(v,digitsN); }
|
| double CalcProfit(const int dir,const double open,const double lots,const double price)
|
| {
|
| double m = (dir>0) ? (price-open) : (open-price);
|
| return NormalizeDouble(m * lots * InpContractSize, 2);
|
| }
|
|
|
| // MT5-style money text: 10 000.00
|
| string Money(const double v)
|
| {
|
| string s=DoubleToString(MathAbs(v),2);
|
| int dot=StringFind(s,".");
|
| string ip=StringSubstr(s,0,dot), fp=StringSubstr(s,dot);
|
| string o="";
|
| int L=StringLen(ip);
|
| for(int i=0;i<L;i++){ if(i>0 && (L-i)%3==0) o+=" "; o+=StringSubstr(ip,i,1); }
|
| return (v<0?"-":"")+o+fp;
|
| }
|
| string MoneyS(const double v){ return (v>0?"+":"")+Money(v); }
|
| color PnlCol(const double v){ return (v>0.004)?C'90,225,130':((v<-0.004)?C'255,100,100':clrWhite); }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Init / Deinit |
|
| //+------------------------------------------------------------------+
|
| int OnInit()
|
| {
|
| panelChart = ChartID();
|
| baseSym = CleanBase(_Symbol);
|
| customSym = "REPLAY_"+baseSym;
|
| folderName = "Custom_"+baseSym;
|
| digitsN = (int)MathRound(-MathLog10(MathMax(InpPoint,1e-8)));
|
| if(digitsN<0) digitsN=0; if(digitsN>8) digitsN=8;
|
| spreadPx = InpSpreadPts*InpPoint;
|
| lotSize = MathMax(InpLotMin,MathMin(InpLotMax,InpLot));
|
| leverage = MathMax(1,InpLeverage);
|
| resetBal = InpBalance;
|
| slPts = InpSLpts;
|
| tpPts = (InpTradeMode==MODE_SINGLE)?InpTPpts:InpMartTPpts;
|
| trailOn = (InpTradeMode==MODE_SINGLE)?InpTrailing:(InpMartTrailStart>0);
|
| trStart = (InpTradeMode==MODE_SINGLE)?InpTrailStart:InpMartTrailStart;
|
| trStep = (InpTradeMode==MODE_SINGLE)?InpTrailStep:InpMartTrailStep;
|
| ready=false;
|
|
|
| Print("=== MarketReplay v9.10 | Mode: ",(InpTradeMode==MODE_SINGLE?"Single":"Martingale")," ===");
|
| FolderCreate(folderName,0);
|
|
|
| // --- Stage 1: broker symbol -> export all TFs, create custom symbol, switch chart
|
| if(_Symbol!=customSym)
|
| {
|
| SaveSource();
|
| if(!SetupCustom()){ Alert("Symbol error | خطا سمبل"); return INIT_FAILED; }
|
| if(!ChartSetSymbolPeriod(panelChart,customSym,_Period))
|
| Alert("Open a chart of ",customSym," and attach the EA there | چارت ",customSym," را باز و اکسپرت را روی آن بگذارید");
|
| return INIT_SUCCEEDED;
|
| }
|
|
|
| // --- Stage 2: running on REPLAY_ symbol
|
| if(!SetupCustom()){ Alert("Symbol error | خطا سمبل"); return INIT_FAILED; }
|
| ArrayResize(tkOff,InpMaxTicks+16);
|
| ArrayResize(tkBid,InpMaxTicks+16);
|
| ArrayResize(wkb,InpMaxTicks+16);
|
| ArrayResize(outTk,256);
|
| if(!LoadBase()){ Alert("No data | داده‌ای یافت نشد"); return INIT_FAILED; }
|
| barDurUs = (double)PeriodSeconds(usedTF)*1e6;
|
| dataFirst = DayStart(rates[0].time); dataLast = DayStart(rates[total-1].time);
|
| currentTF = (ENUM_TIMEFRAMES)_Period;
|
|
|
| ChartSetInteger(panelChart,CHART_MODE,CHART_CANDLES);
|
| ChartSetInteger(panelChart,CHART_SHOW_GRID,false);
|
| ChartSetInteger(panelChart,CHART_AUTOSCROLL,true);
|
| ChartSetInteger(panelChart,CHART_SHIFT,true);
|
| ChartSetInteger(panelChart,CHART_SHOW_BID_LINE,true);
|
| ChartSetInteger(panelChart,CHART_SHOW_ASK_LINE,true);
|
| ChartSetInteger(panelChart,CHART_COLOR_BID,clrDodgerBlue);
|
| ChartSetInteger(panelChart,CHART_COLOR_ASK,clrRed);
|
| ChartSetInteger(panelChart,CHART_SHOW_OBJECT_DESCR,true);
|
| ChartSetInteger(panelChart,CHART_CONTEXT_MENU,false); // our own right-click menu
|
| ChartSetInteger(panelChart,CHART_EVENT_MOUSE_MOVE,true);
|
|
|
| if(!TryRestoreState())
|
| {
|
| bal=InpBalance; eq=bal;
|
| ResetTradeState(true);
|
| endBar=total-1;
|
| StartAt(MathMax(1,total/5));
|
| selFrom=DayStart(rates[cur].time); selTo=dataLast; selDirty=false;
|
| }
|
| if(selFrom<=0) selFrom=DayStart(rates[MathMin(cur,total-1)].time);
|
| if(selTo<=0) selTo=dataLast;
|
|
|
| BuildPanel();
|
| if(trOpen){ BuildTrades(); }
|
| ready=true;
|
| btnDirty=true; linesDirty=true;
|
| lastUs=GetMicrosecondCount();
|
| EventSetMillisecondTimer(playing?1:10);
|
| UpdateUI();
|
| Print("Ready | آماده | Bars: ",total," | Base TF: ",TFName(usedTF)," | Ticks/bar up to ",InpMaxTicks);
|
| return INIT_SUCCEEDED;
|
| }
|
|
|
| void OnDeinit(const int reason)
|
| {
|
| EventKillTimer();
|
| if(ready && reason==REASON_CHARTCHANGE) SaveState();
|
| if(reason!=REASON_CHARTCHANGE)
|
| {
|
| ChartSetInteger(panelChart,CHART_CONTEXT_MENU,true);
|
| ChartSetInteger(panelChart,CHART_EVENT_MOUSE_MOVE,false);
|
| ObjectsDeleteAll(panelChart,"RPH_");
|
| }
|
| ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,true);
|
| ObjectsDeleteAll(panelChart,P);
|
| ready=false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Timer: the heart of the replay |
|
| //+------------------------------------------------------------------+
|
| void OnTimer()
|
| {
|
| if(!ready) return;
|
| ulong nowUs = GetMicrosecondCount();
|
| if(playing)
|
| {
|
| double dt = (double)(nowUs - lastUs);
|
| lastUs = nowUs;
|
| if(dt > 1000000.0) dt = 1000000.0;
|
| Advance(dt * speedMult);
|
| }
|
| else lastUs = nowUs;
|
|
|
| if(trSizeDirty && (nowUs-trSizeUs)>=60000)
|
| {
|
| trSizeUs=nowUs; trSizeDirty=false;
|
| BuildTrades(); RefreshTrades(); ChartRedraw(panelChart);
|
| }
|
| if(uiForce || (nowUs - lastUiUs) >= (ulong)InpUiMs*1000)
|
| {
|
| lastUiUs = nowUs;
|
| UpdateUI();
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Advance the virtual clock by addUs and emit every due tick |
|
| //+------------------------------------------------------------------+
|
| void Advance(const double addUs)
|
| {
|
| if(tkN<=0) return;
|
| ulong t0 = GetMicrosecondCount();
|
| barClockUs += addUs;
|
| outN = 0;
|
|
|
| while(true)
|
| {
|
| while(tkIdx<tkN && tkOff[tkIdx]<=barClockUs)
|
| {
|
| EmitTick(tkIdx);
|
| tkIdx++;
|
| if(outN>=256) FlushTicks();
|
| }
|
| if(tkIdx>=tkN && barClockUs>=barDurUs)
|
| {
|
| if(cur>=endBar)
|
| {
|
| playing=false; btnDirty=true; barClockUs=barDurUs;
|
| EventSetMillisecondTimer(10);
|
| break;
|
| }
|
| barClockUs -= barDurUs; // carry remainder => zero drift
|
| cur++;
|
| UpdateStatsPeriod(rates[cur].time);
|
| BuildBarTicks(cur);
|
| tkIdx = 0;
|
| if((double)(GetMicrosecondCount()-t0) > BUDGET_US) break; // keep UI responsive
|
| continue;
|
| }
|
| break;
|
| }
|
| FlushTicks();
|
| }
|
|
|
| void EmitTick(const int i)
|
| {
|
| curBid = tkBid[i];
|
| curAsk = curBid + spreadPx;
|
| ulong msc = (ulong)rates[cur].time*1000 + (ulong)(tkOff[i]/1000.0);
|
|
|
| MqlTick t;
|
| t.time = (datetime)(msc/1000);
|
| curTime = t.time;
|
| t.time_msc = (long)msc;
|
| t.bid = curBid;
|
| t.ask = curAsk;
|
| t.last = 0;
|
| t.volume = 0;
|
| t.volume_real = 0;
|
| t.flags = TICK_FLAG_BID|TICK_FLAG_ASK;
|
| outTk[outN++] = t;
|
|
|
| if(openCnt>0 || ordLive>0) ManageTick(curBid,curAsk); // SL/TP/trailing on EVERY tick
|
| }
|
| void FlushTicks()
|
| {
|
| if(outN>0){ CustomTicksAdd(customSym,outTk,(uint)outN); outN=0; }
|
| }
|
| void BuildBarTicks(const int idx)
|
| {
|
| double o=rates[idx].open, h=rates[idx].high, l=rates[idx].low, c=rates[idx].close;
|
| if(h<MathMax(o,c)) h=MathMax(o,c);
|
| if(l>MathMin(o,c)) l=MathMin(o,c);
|
|
|
| int minT=MathMax(4,InpMinTicks);
|
| int maxT=MathMax(minT,InpMaxTicks);
|
| int n=(int)rates[idx].tick_volume;
|
| if(n<minT) n=minT;
|
| if(n>maxT) n=maxT;
|
|
|
| double rng=h-l;
|
| SeedRng((ulong)rates[idx].time);
|
|
|
| if(rng<=0.0)
|
| {
|
| n=2;
|
| tkBid[0]=NormalizeDouble(o,digitsN);
|
| tkBid[1]=NormalizeDouble(c,digitsN);
|
| tkOff[0]=0; tkOff[1]=MathFloor(barDurUs*0.5/100.0)*100.0;
|
| tkN=2; return;
|
| }
|
|
|
| double wp[4];
|
| wp[0]=o;
|
| if(c>=o){ wp[1]=l; wp[2]=h; } else { wp[1]=h; wp[2]=l; }
|
| wp[3]=c;
|
|
|
| // distribute ticks over the 3 legs proportionally to their length
|
| int rem=n-1, m[3]; double len[3]; double S=0; int big=0;
|
| for(int k=0;k<3;k++){ len[k]=MathAbs(wp[k+1]-wp[k]); S+=len[k]; if(len[k]>len[big]) big=k; }
|
| int extra=rem-3, used=0;
|
| for(int k=0;k<3;k++){ m[k]=1+(int)MathFloor(extra*len[k]/S); used+=m[k]; }
|
| m[big]+=rem-used;
|
|
|
| tkBid[0]=NormalizeDouble(o,digitsN);
|
| int w=1;
|
| for(int k=0;k<3;k++)
|
| {
|
| int mk=m[k]; double p0=wp[k], p1=wp[k+1];
|
| double sigma=InpPathNoise*rng/MathSqrt((double)mk);
|
| double acc=0;
|
| for(int s=1;s<=mk;s++){ acc+=(Rnd()*2.0-1.0)*1.7320508*sigma; wkb[s]=acc; }
|
| double wm=wkb[mk];
|
| for(int s=1;s<=mk;s++)
|
| {
|
| double px;
|
| if(s==mk) px=p1; // legs end exactly on O/H/L/C
|
| else
|
| {
|
| px=p0+(p1-p0)*s/mk+(wkb[s]-wm*s/mk); // Brownian bridge
|
| if(px>h) px=h;
|
| if(px<l) px=l;
|
| }
|
| tkBid[w++]=NormalizeDouble(px,digitsN);
|
| }
|
| }
|
|
|
| // Poisson (exponential) inter-arrival times, snapped to 100us
|
| tkOff[0]=0;
|
| double cum=0;
|
| for(int i=1;i<=n;i++)
|
| {
|
| double u=Rnd(); if(u<1e-12) u=1e-12;
|
| cum+=-MathLog(u);
|
| if(i<n) tkOff[i]=cum;
|
| }
|
| double scale=barDurUs*0.999/cum;
|
| for(int i=1;i<n;i++) tkOff[i]=MathFloor(tkOff[i]*scale/100.0)*100.0;
|
| tkN=n;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Per-tick trade management |
|
| //+------------------------------------------------------------------+
|
| void ManageTick(const double bid,const double ask)
|
| {
|
| const double pt=InpPoint;
|
| if(ordLive>0) CheckOrders(bid,ask);
|
| if(openCnt>0 && StopOutHit()){ DoStopOut(); return; }
|
|
|
| if(InpTradeMode==MODE_SINGLE)
|
| {
|
| for(int i=ArraySize(pos)-1;i>=0;i--)
|
| {
|
| if(!pos[i].open_) continue;
|
| if(pos[i].dir>0)
|
| {
|
| if(pos[i].sl>0 && bid<=pos[i].sl){ ClosePos(i,bid); continue; }
|
| if(pos[i].tp>0 && bid>=pos[i].tp){ ClosePos(i,pos[i].tp); continue; }
|
| if(trailOn && trStart>0 && (bid-pos[i].open)/pt>=trStart)
|
| {
|
| double ns=NormalizeDouble(bid-trStep*pt,digitsN);
|
| if(ns>pos[i].sl){ pos[i].sl=ns; linesDirty=true; }
|
| }
|
| }
|
| else
|
| {
|
| if(pos[i].sl>0 && ask>=pos[i].sl){ ClosePos(i,ask); continue; }
|
| if(pos[i].tp>0 && ask<=pos[i].tp){ ClosePos(i,pos[i].tp); continue; }
|
| if(trailOn && trStart>0 && (pos[i].open-ask)/pt>=trStart)
|
| {
|
| double ns=NormalizeDouble(ask+trStep*pt,digitsN);
|
| if(pos[i].sl==0 || ns<pos[i].sl){ pos[i].sl=ns; linesDirty=true; }
|
| }
|
| }
|
| }
|
| return;
|
| }
|
|
|
| // ===== Martingale basket =====
|
| if(basketLots<=0 || bDir==0) return;
|
| if(bDir>0)
|
| {
|
| if(bid>=basketTP){ CloseBasket(basketTP); return; }
|
| if(trailOn && trStart>0)
|
| {
|
| double pts=(bid-basketAvg)/pt;
|
| if(!basketTrailActive && pts>=trStart)
|
| { basketTrailActive=true; basketSL=NormalizeDouble(bid-trStep*pt,digitsN); linesDirty=true; }
|
| if(basketTrailActive)
|
| {
|
| double ns=NormalizeDouble(bid-trStep*pt,digitsN);
|
| if(ns>basketSL){ basketSL=ns; linesDirty=true; }
|
| if(bid<=basketSL){ CloseBasket(bid); return; }
|
| }
|
| }
|
| }
|
| else
|
| {
|
| if(ask<=basketTP){ CloseBasket(basketTP); return; }
|
| if(trailOn && trStart>0)
|
| {
|
| double pts=(basketAvg-ask)/pt;
|
| if(!basketTrailActive && pts>=trStart)
|
| { basketTrailActive=true; basketSL=NormalizeDouble(ask+trStep*pt,digitsN); linesDirty=true; }
|
| if(basketTrailActive)
|
| {
|
| double ns=NormalizeDouble(ask+trStep*pt,digitsN);
|
| if(ns<basketSL || basketSL==0){ basketSL=ns; linesDirty=true; }
|
| if(ask>=basketSL){ CloseBasket(ask); return; }
|
| }
|
| }
|
| }
|
| }
|
|
|
| string OrdTypeName(const int t)
|
| {
|
| if(t==1) return "buy limit"; if(t==2) return "sell limit";
|
| if(t==3) return "buy stop"; return "sell stop";
|
| }
|
|
|
| // pending orders trigger on Ask (buy) / Bid (sell), exactly like a real server
|
| void CheckOrders(const double bid,const double ask)
|
| {
|
| for(int i=0;i<ArraySize(ords);i++)
|
| {
|
| if(!ords[i].live) continue;
|
| int t=ords[i].type; double pr=ords[i].price; double fp=pr; bool hit=false;
|
| if(t==1 && ask<=pr){ hit=true; fp=MathMin(pr,ask); }
|
| else if(t==3 && ask>=pr){ hit=true; fp=ask; }
|
| else if(t==2 && bid>=pr){ hit=true; fp=MathMax(pr,bid); }
|
| else if(t==4 && bid<=pr){ hit=true; fp=bid; }
|
| if(!hit) continue;
|
| ords[i].live=false; ordLive--; ordCompact=true; linesDirty=true;
|
| int dir=(t==1||t==3)?1:-1;
|
| if(!OpenPos(dir,fp,ords[i].lots,ords[i].ticket))
|
| pendLog+=StringFormat("Pending #%I64u cancelled (blocked)\n",ords[i].ticket);
|
| else
|
| pendLog+=StringFormat("Pending #%I64u %s filled @ %s\n",ords[i].ticket,OrdTypeName(t),Px(fp));
|
| }
|
| }
|
|
|
| void ClosePos(const int i,const double price)
|
| {
|
| double pr=CalcProfit(pos[i].dir,pos[i].open,pos[i].lots,price);
|
| bal+=pr; dayProfit+=pr; weekProfit+=pr; monthProfit+=pr; closedToday+=pr;
|
| AddHevClose(pos[i],price,pr);
|
| pos[i].open_=false; openCnt--;
|
| needCompact=true; linesDirty=true;
|
| pendLog+=StringFormat("Closed #%I64u %s @ %s P/L=%+.2f\n",pos[i].ticket,(pos[i].dir>0?"BUY":"SELL"),Px(price),pr);
|
| }
|
| void CloseBasket(const double price)
|
| {
|
| double totalPr=0;
|
| for(int i=0;i<ArraySize(pos);i++)
|
| {
|
| if(!pos[i].open_) continue;
|
| double pp=CalcProfit(pos[i].dir,pos[i].open,pos[i].lots,price);
|
| totalPr+=pp;
|
| AddHevClose(pos[i],price,pp);
|
| pos[i].open_=false;
|
| }
|
| openCnt=0; needCompact=true; linesDirty=true;
|
| bal+=totalPr; dayProfit+=totalPr; weekProfit+=totalPr; monthProfit+=totalPr; closedToday+=totalPr;
|
|
|
| if(totalPr<0) martLevel=MathMin(martLevel+1,InpMartMaxLevels);
|
| else { martLevel=0; martDir=0; }
|
|
|
| basketAvg=0; basketLots=0; basketSL=0; basketTP=0; bDir=0; basketTrailActive=false;
|
| pendLog+=StringFormat("Basket closed @ %s P/L=%+.2f | Next level=%d\n",Px(price),totalPr,martLevel);
|
| }
|
| void CalcBasketAvg()
|
| {
|
| basketAvg=0; basketLots=0; bDir=0;
|
| double sum=0;
|
| for(int i=0;i<ArraySize(pos);i++)
|
| {
|
| if(!pos[i].open_) continue;
|
| if(bDir==0) bDir=pos[i].dir;
|
| sum+=pos[i].open*pos[i].lots;
|
| basketLots+=pos[i].lots;
|
| }
|
| if(basketLots>0)
|
| {
|
| basketAvg=NormalizeDouble(sum/basketLots,digitsN);
|
| basketTP=NormalizeDouble(basketAvg+bDir*tpPts*InpPoint,digitsN);
|
| }
|
| else { basketSL=0; basketTP=0; basketTrailActive=false; }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Leverage / margin / stop-out / balance control |
|
| //+------------------------------------------------------------------+
|
| void Account(double &flo,double &used)
|
| {
|
| flo=0; used=0;
|
| for(int i=0;i<ArraySize(pos);i++)
|
| {
|
| if(!pos[i].open_) continue;
|
| flo+=CalcProfit(pos[i].dir,pos[i].open,pos[i].lots,pos[i].dir>0?curBid:curAsk);
|
| used+=pos[i].lots*InpContractSize*pos[i].open/leverage;
|
| }
|
| }
|
|
|
| double FreeMargin()
|
| {
|
| double f,u; Account(f,u);
|
| return bal+f-u;
|
| }
|
|
|
| // largest lot (on lot-step grid) that the free margin can afford at this price
|
| double MaxLotFor(const double freeM,const double price)
|
| {
|
| if(freeM<=0 || price<=0) return 0.0;
|
| double lot=freeM*leverage/(InpContractSize*price);
|
| double st=MathMax(InpLotStep,0.0001);
|
| lot=MathFloor(lot/st+1e-9)*st;
|
| lot=MathMin(lot,InpLotMax);
|
| if(lot<InpLotMin) return 0.0;
|
| return NormalizeDouble(lot,2);
|
| }
|
|
|
| bool StopOutHit()
|
| {
|
| double f,u; Account(f,u);
|
| if(u<=0) return false;
|
| return ((bal+f)/u*100.0 < InpStopOutPct);
|
| }
|
|
|
| void DoStopOut()
|
| {
|
| double f,u; Account(f,u);
|
| pendLog+=StringFormat("STOP OUT: margin level %.1f%% < %.0f%% | equity %s\n",(bal+f)/u*100.0,InpStopOutPct,Money(bal+f));
|
| CloseAll();
|
| for(int i=0;i<ArraySize(ords);i++) CancelOrder(i);
|
| martLevel=0; martDir=0;
|
| if(InpAutoReset)
|
| {
|
| bal=resetBal;
|
| lastMsg="STOP OUT - balance reset to "+Money(resetBal)+" | بالانس ریست شد";
|
| }
|
| else
|
| {
|
| lastMsg="STOP OUT - use Reset balance or + Deposit | مارجین کال";
|
| playing=false; btnDirty=true; EventSetMillisecondTimer(10);
|
| }
|
| uiForce=true;
|
| }
|
|
|
| void ResetBalance()
|
| {
|
| CloseAll();
|
| for(int i=0;i<ArraySize(ords);i++) CancelOrder(i);
|
| martLevel=0; martDir=0;
|
| bal=resetBal;
|
| dayProfit=0; ydayProfit=0; weekProfit=0; monthProfit=0;
|
| dayLots=0; weekLots=0; monthLots=0; closedToday=0;
|
| lastMsg="Balance reset to "+Money(resetBal)+" | بالانس ریست شد";
|
| uiForce=true; linesDirty=true;
|
| }
|
|
|
| void Deposit()
|
| {
|
| bal+=resetBal;
|
| lastMsg="Deposited "+Money(resetBal)+" | واریز شد";
|
| uiForce=true;
|
| }
|
|
|
| void ApplyLevText()
|
| {
|
| string t=ObjectGetString(panelChart,P+"LEV",OBJPROP_TEXT);
|
| StringReplace(t,"1:",""); StringReplace(t," ","");
|
| long v=StringToInteger(t);
|
| if(v<1) v=leverage;
|
| if(v>5000) v=5000;
|
| leverage=(int)v;
|
| ObjectSetString(panelChart,P+"LEV",OBJPROP_TEXT,IntegerToString(leverage));
|
| lastMsg="Leverage set to 1:"+IntegerToString(leverage);
|
| uiForce=true;
|
| }
|
|
|
| void ApplySLTPText()
|
| {
|
| long s=StringToInteger(ObjectGetString(panelChart,P+"SLP",OBJPROP_TEXT));
|
| long t=StringToInteger(ObjectGetString(panelChart,P+"TPP",OBJPROP_TEXT));
|
| if(s<0) s=0; if(t<0) t=0;
|
| slPts=(int)s; tpPts=(int)t;
|
| ObjectSetString(panelChart,P+"SLP",OBJPROP_TEXT,IntegerToString(slPts));
|
| ObjectSetString(panelChart,P+"TPP",OBJPROP_TEXT,IntegerToString(tpPts));
|
| lastMsg=StringFormat("SL=%d TP=%d points (new trades)",slPts,tpPts);
|
| uiForce=true;
|
| }
|
|
|
| void ApplyBalText()
|
| {
|
| string t=ObjectGetString(panelChart,P+"BALV",OBJPROP_TEXT);
|
| StringReplace(t,",","."); StringReplace(t," ","");
|
| double v=StringToDouble(t);
|
| if(v<=0) v=resetBal;
|
| resetBal=NormalizeDouble(v,2);
|
| ObjectSetString(panelChart,P+"BALV",OBJPROP_TEXT,DoubleToString(resetBal,2));
|
| uiForce=true;
|
| }
|
|
|
| void ApplySLTPOpen()
|
| {
|
| if(InpTradeMode==MODE_SINGLE)
|
| {
|
| for(int i=0;i<ArraySize(pos);i++)
|
| {
|
| if(!pos[i].open_) continue;
|
| pos[i].sl=slPts>0?NormalizeDouble(pos[i].open-pos[i].dir*slPts*InpPoint,digitsN):0;
|
| pos[i].tp=tpPts>0?NormalizeDouble(pos[i].open+pos[i].dir*tpPts*InpPoint,digitsN):0;
|
| }
|
| }
|
| else { double sl=basketSL; bool ta=basketTrailActive; CalcBasketAvg(); basketSL=sl; basketTrailActive=ta; }
|
| linesDirty=true; uiForce=true;
|
| lastMsg="SL/TP applied to open positions | اعمال شد";
|
| }
|
|
|
| bool IsEditName(const string n)
|
| {
|
| return (n==P+"LOT"||n==P+"LEV"||n==P+"SLP"||n==P+"TPP"||n==P+"BALV"||n==P+"TRS"||n==P+"TRP"||n==P+"MOD_SL"||n==P+"MOD_TP"||n==P+"VOL_V");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| BUY / SELL / pending - hot path, no UI work |
|
| //+------------------------------------------------------------------+
|
| bool OpenPos(const int dir,const double price,const double baseLots,const ulong useTicket)
|
| {
|
| double lots=baseLots; int level=0;
|
|
|
| if(InpTradeMode==MODE_MARTINGALE)
|
| {
|
| if(openCnt>0 && martDir!=0 && martDir!=dir)
|
| { lastMsg="Opposite blocked - close basket first | جهت مخالف ممکن نیست، ابتدا سبد را ببندید"; uiForce=true; return false; }
|
| if(openCnt==0 && martDir!=dir) martLevel=0;
|
| martDir=dir;
|
| level=martLevel;
|
| int lv=MathMin(martLevel,InpMartMaxLevels);
|
| lots=NormalizeDouble(baseLots*MathPow(InpMartMultiplier,lv),2);
|
| }
|
|
|
| double need=lots*InpContractSize*price/leverage;
|
| double fm=FreeMargin();
|
| if(need>fm+1e-9)
|
| {
|
| lastMsg=StringFormat("Not enough margin: need %s, free %s | مارجین کافی نیست",Money(need),Money(fm));
|
| uiForce=true; return false;
|
| }
|
|
|
| Pos p;
|
| p.ticket=(useTicket>0)?useTicket:nextT++;
|
| p.dir=dir; p.lots=lots; p.open=price;
|
| p.time=rates[cur].time; p.open_=true; p.level=level;
|
| if(InpTradeMode==MODE_SINGLE)
|
| {
|
| p.sl=slPts>0 ? NormalizeDouble(price-dir*slPts*InpPoint,digitsN) : 0;
|
| p.tp=tpPts>0 ? NormalizeDouble(price+dir*tpPts*InpPoint,digitsN) : 0;
|
| }
|
| else { p.sl=0; p.tp=0; }
|
|
|
| int n=ArraySize(pos);
|
| ArrayResize(pos,n+1,64);
|
| pos[n]=p;
|
| openCnt++;
|
| AddHevOpen(p);
|
|
|
| dayLots+=lots; weekLots+=lots; monthLots+=lots;
|
| if(InpTradeMode==MODE_MARTINGALE){ CalcBasketAvg(); basketTrailActive=false; basketSL=0; }
|
|
|
| linesDirty=true; uiForce=true;
|
| lastMsg="";
|
| pendLog+=StringFormat("%s #%I64u Lot=%.2f @ %s\n",(dir>0?"BUY":"SELL"),p.ticket,lots,Px(price));
|
| return true;
|
| }
|
|
|
| void OpenTrade(const int dir)
|
| {
|
| if(curBid<=0) return;
|
| OpenPos(dir,(dir>0)?curAsk:curBid,lotSize,0);
|
| }
|
|
|
| void PlaceOrder(const int type,const double price0)
|
| {
|
| double price=NormalizeDouble(price0,digitsN);
|
| bool ok=false;
|
| if(type==1) ok=(price<curAsk);
|
| else if(type==2) ok=(price>curBid);
|
| else if(type==3) ok=(price>curAsk);
|
| else if(type==4) ok=(price<curBid);
|
| if(!ok){ lastMsg="Invalid price for "+OrdTypeName(type)+" | قیمت نامعتبر"; uiForce=true; return; }
|
|
|
| Ord o;
|
| o.ticket=nextT++; o.type=type; o.price=price; o.lots=lotSize;
|
| o.time=rates[cur].time; o.live=true;
|
| int n=ArraySize(ords);
|
| ArrayResize(ords,n+1,16);
|
| ords[n]=o;
|
| ordLive++;
|
| linesDirty=true; uiForce=true;
|
| lastMsg=StringFormat("Placed %s %.2f @ %s",OrdTypeName(type),lotSize,Px(price));
|
| pendLog+=StringFormat("Order #%I64u %s %.2f @ %s\n",o.ticket,OrdTypeName(type),lotSize,Px(price));
|
| }
|
|
|
| void CancelOrder(const int i)
|
| {
|
| if(i<0 || i>=ArraySize(ords) || !ords[i].live) return;
|
| ords[i].live=false; ordLive--; ordCompact=true; linesDirty=true; uiForce=true;
|
| pendLog+=StringFormat("Order #%I64u deleted\n",ords[i].ticket);
|
| }
|
|
|
| void CloseAll()
|
| {
|
| if(openCnt<=0) return;
|
| if(InpTradeMode==MODE_SINGLE)
|
| {
|
| for(int i=ArraySize(pos)-1;i>=0;i--)
|
| if(pos[i].open_) ClosePos(i,pos[i].dir>0?curBid:curAsk);
|
| }
|
| else CloseBasket(bDir>0?curBid:curAsk);
|
| uiForce=true;
|
| }
|
|
|
| void SetLot(double v)
|
| {
|
| v=MathMax(InpLotMin,MathMin(InpLotMax,v));
|
| double st=MathMax(InpLotStep,0.0001);
|
| v=NormalizeDouble(MathRound(v/st)*st,2);
|
| if(v<InpLotMin) v=InpLotMin;
|
| lotSize=v;
|
| ObjectSetString(panelChart,P+"LOT",OBJPROP_TEXT,DoubleToString(v,2));
|
| uiForce=true;
|
| }
|
|
|
| void ApplyLotText()
|
| {
|
| string t=ObjectGetString(panelChart,P+"LOT",OBJPROP_TEXT);
|
| StringReplace(t,",","."); StringTrimLeft(t); StringTrimRight(t);
|
| double v=StringToDouble(t);
|
| if(v<=0) v=lotSize;
|
| SetLot(v);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Events - everything fires on mouse-DOWN |
|
| //+------------------------------------------------------------------+
|
| string HitPanel(const int x,const int y)
|
| {
|
| for(int i=0;i<rN;i++)
|
| if(x>=rX[i] && x<rX[i]+rW[i] && y>=rY[i] && y<rY[i]+rH[i]) return rId[i];
|
| return "";
|
| }
|
|
|
| bool InCal(const int x,const int y)
|
| {
|
| return calOpen && x>=calX && x<calX+calW && y>=calY && y<calY+calH;
|
| }
|
| string HitCal(const int x,const int y)
|
| {
|
| if(x>=calX+6 && x<calX+34 && y>=calY+4 && y<calY+28) return "CAL_PREV";
|
| if(x>=calX+calW-34 && x<calX+calW-6 && y>=calY+4 && y<calY+28) return "CAL_NEXT";
|
| int gx=calX+8, gy=calY+CAL_HDR+CAL_WK;
|
| if(x>=gx && x<gx+7*CAL_CW && y>=gy && y<gy+6*CAL_CH)
|
| return "CAL_D"+IntegerToString(((y-gy)/CAL_CH)*7+(x-gx)/CAL_CW);
|
| if(x>=gx && x<gx+210 && y>=gy+6*CAL_CH+4 && y<gy+6*CAL_CH+28) return "CAL_TODAY";
|
| return "";
|
| }
|
| void MarkPressed(const string id){ pressId=id; pressMs=GetTickCount64(); }
|
|
|
| bool InTrades(const int x,const int y)
|
| {
|
| return trOpen && x>=trX && x<trX+trW && y>=trY && y<trY+trH;
|
| }
|
|
|
| //--- speed slider ---------------------------------------------------
|
| double SpeedFromPos(const double p)
|
| {
|
| double s=SPD_MIN*MathPow(SPD_MAX/SPD_MIN,p);
|
| if(MathAbs(MathLog10(s))<0.025) return 1.0; // snap to Live
|
| if(s>=10) return MathRound(s);
|
| if(s>=1) return MathRound(s*10.0)/10.0;
|
| return MathRound(s*100.0)/100.0;
|
| }
|
| double PosFromSpeed(const double s)
|
| {
|
| double p=MathLog10(MathMax(s,SPD_MIN)/SPD_MIN)/MathLog10(SPD_MAX/SPD_MIN);
|
| return MathMax(0.0,MathMin(1.0,p));
|
| }
|
| string SpeedTxt(const double s)
|
| {
|
| if(s==1.0) return "Live 1x";
|
| if(s>=10) return DoubleToString(s,0)+"x";
|
| if(s>=1) return DoubleToString(s,1)+"x";
|
| return DoubleToString(s,2)+"x";
|
| }
|
| void PlaceThumb()
|
| {
|
| double p=PosFromSpeed(speedMult);
|
| ObjectSetInteger(panelChart,P+"SL_TH",OBJPROP_XDISTANCE,slX+(int)MathRound(p*(slW-SL_TH)));
|
| }
|
| void SetSpeed(const double s)
|
| {
|
| speedMult=MathMax(SPD_MIN,MathMin(SPD_MAX,s));
|
| PlaceThumb(); btnDirty=true; uiForce=true;
|
| }
|
| void SliderAt(const int x)
|
| {
|
| double p=(double)(x-slX-SL_TH/2)/(double)(slW-SL_TH);
|
| SetSpeed(SpeedFromPos(MathMax(0.0,MathMin(1.0,p))));
|
| }
|
| void SpeedStep(const int dir)
|
| {
|
| double p=PosFromSpeed(speedMult)+dir*0.03;
|
| SetSpeed(SpeedFromPos(MathMax(0.0,MathMin(1.0,p))));
|
| }
|
|
|
| //--- right-click context menu (Limit / Stop orders) ------------------
|
| void CloseCtx()
|
| {
|
| if(!ctxOpen) return;
|
| ObjectsDeleteAll(panelChart,P+"CTX_");
|
| ctxOpen=false;
|
| ChartRedraw(panelChart);
|
| }
|
|
|
| string HitCtx(const int x,const int y)
|
| {
|
| if(!ctxOpen) return "";
|
| for(int i=0;i<ctxN;i++)
|
| if(x>=ctxX+3 && x<ctxX+CTX_W-3 && y>=ctxRY[i] && y<ctxRY[i]+CTX_ROW-2) return ctxId[i];
|
| return "";
|
| }
|
|
|
| void OpenCtx(const int x,const int y)
|
| {
|
| if(curBid<=0) return;
|
| int sub=0; datetime t=0; double price=0;
|
| if(!ChartXYToTimePrice(panelChart,x,y,sub,t,price) || sub!=0) return;
|
| price=NormalizeDouble(price,digitsN);
|
| CloseCtx(); CloseCal();
|
| ctxPrice=price; ctxN=0;
|
| if(price<curBid) { ctxId[0]="CTX_BL"; ctxId[1]="CTX_SS"; ctxN=2; }
|
| else if(price>curAsk) { ctxId[0]="CTX_SLM"; ctxId[1]="CTX_BS"; ctxN=2; }
|
| else { lastMsg="Too close to market price | قیمت خیلی نزدیک بازار است"; uiForce=true; return; }
|
|
|
| int w=CTX_W, h=CTX_ROW*(ctxN+1)+6;
|
| int cw=(int)ChartGetInteger(panelChart,CHART_WIDTH_IN_PIXELS);
|
| int ch=(int)ChartGetInteger(panelChart,CHART_HEIGHT_IN_PIXELS);
|
| ctxX=MathMax(2,MathMin(x,cw-w-4)); ctxY=MathMax(2,MathMin(y,ch-h-4));
|
| Rect("CTX_BG",ctxX,ctxY,w,h,C'30,36,54',C'0,150,255',2999);
|
| RawBtn(P+"CTX_H",StringFormat("Order @ %s | Lot %.2f",Px(price),lotSize),ctxX+3,ctxY+3,w-6,CTX_ROW-2,
|
| C'0,92,170',clrWhite,C'0,92,170',9,3000);
|
| for(int i=0;i<ctxN;i++)
|
| {
|
| ctxRY[i]=ctxY+3+CTX_ROW*(i+1);
|
| bool buy=(ctxId[i]=="CTX_BL"||ctxId[i]=="CTX_BS");
|
| string nm=(ctxId[i]=="CTX_BL")?"Buy Limit":(ctxId[i]=="CTX_SS")?"Sell Stop":(ctxId[i]=="CTX_SLM")?"Sell Limit":"Buy Stop";
|
| color bg=buy?clrForestGreen:clrFireBrick;
|
| RawBtn(P+ctxId[i],nm+" "+DoubleToString(lotSize,2)+" @ "+Px(price),ctxX+3,ctxRY[i],w-6,CTX_ROW-2,
|
| bg,clrWhite,Lighten(bg,55),9,3000);
|
| }
|
| ctxOpen=true;
|
| ChartRedraw(panelChart);
|
| }
|
|
|
| void RightClickAt(const int x,const int y)
|
| {
|
| if(x>=4 && x<4+panW && y>=4 && y<4+panH) return; // not over the panel
|
| if(InTrades(x,y)) return;
|
| OpenCtx(x,y);
|
| }
|
|
|
| //--- Trades window interaction ---------------------------------------
|
| void CloseRow(const int row)
|
| {
|
| if(row<0 || row>=twRows) return;
|
| if(twKind[row]==0)
|
| {
|
| int i=twIdx[row];
|
| if(i>=0 && i<ArraySize(pos) && pos[i].open_)
|
| {
|
| if(InpTradeMode==MODE_SINGLE) ClosePos(i,pos[i].dir>0?curBid:curAsk);
|
| else CloseBasket(bDir>0?curBid:curAsk);
|
| }
|
| }
|
| else CancelOrder(twIdx[row]);
|
| uiForce=true;
|
| }
|
|
|
| void MoveTrades()
|
| {
|
| for(int i=0;i<twCnt;i++)
|
| {
|
| ObjectSetInteger(panelChart,twN[i],OBJPROP_XDISTANCE,trX+twOX[i]);
|
| ObjectSetInteger(panelChart,twN[i],OBJPROP_YDISTANCE,trY+twOY[i]);
|
| }
|
| }
|
|
|
| void HandleTrades(const int x,const int y)
|
| {
|
| if(y<trY+TR_TITLE)
|
| {
|
| if(x>=trX+trW-28){ Act("TW_CLOSE"); return; }
|
| trDrag=true; trDX=x-trX; trDY=y-trY;
|
| ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,false);
|
| return;
|
| }
|
| if(y>=trY+trH-TR_FOOT)
|
| {
|
| if(x>=trX+trW-22){ trSize=true; ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,false); return; }
|
| if(x>=trX+trW-78 && x<trX+trW-52){ trTop=MathMax(0,trTop-1); RefreshTrades(); ChartRedraw(panelChart); return; }
|
| if(x>=trX+trW-52 && x<trX+trW-26){ trTop++; RefreshTrades(); ChartRedraw(panelChart); return; }
|
| return;
|
| }
|
| int rowsTop=trY+TR_TITLE+TR_HEAD;
|
| if(y>=rowsTop && x>=trX+trW-30)
|
| {
|
| int r=(y-rowsTop)/TR_ROWH;
|
| if(r>=0 && r<twVis) CloseRow(trTop+r);
|
| return;
|
| }
|
| if(y>=rowsTop)
|
| {
|
| int r=(y-rowsTop)/TR_ROWH;
|
| if(r<0 || r>=twVis || trTop+r>=twRows) return;
|
| double tw=(double)(trW-2-30), acc=1.0;
|
| for(int c=0;c<10;c++)
|
| {
|
| double l=acc; acc+=twFr[c]*tw;
|
| if((c==6||c==7) && x>=trX+(int)l && x<trX+(int)acc)
|
| { if(twKind[trTop+r]==0) OpenMod(twIdx[trTop+r]); return; }
|
| if(c==4 && x>=trX+(int)l && x<trX+(int)acc)
|
| { if(twKind[trTop+r]==0) OpenVol(twIdx[trTop+r]); return; }
|
| }
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Trade history marks: MT5-style arrows + dotted entry->exit lines |
|
| //+------------------------------------------------------------------+
|
| void AddHevOpen(const Pos &p)
|
| {
|
| int n=ArraySize(hev);
|
| if(n>3000) return;
|
| ArrayResize(hev,n+1,32);
|
| hev[n].ticket=p.ticket; hev[n].kind=0; hev[n].dir=p.dir;
|
| hev[n].t=p.time; hev[n].price=p.open; hev[n].t0=p.time; hev[n].p0=p.open; hev[n].profit=0;
|
| hev[n].part=0; hev[n].lots=p.lots;
|
| }
|
|
|
| void AddHevClose(const Pos &p,const double price,const double profit)
|
| {
|
| int n=ArraySize(hev);
|
| if(n>3000) return;
|
| ArrayResize(hev,n+1,32);
|
| hev[n].ticket=p.ticket; hev[n].kind=1; hev[n].dir=p.dir;
|
| hev[n].t=(curTime>0)?curTime:p.time; hev[n].price=price;
|
| hev[n].t0=p.time; hev[n].p0=p.open; hev[n].profit=profit;
|
| hev[n].part=0; hev[n].lots=p.lots;
|
| }
|
|
|
| // partial close: same exit mark + dotted line as a full close, but a unique object name per event
|
| void AddHevPartial(const Pos &p,const double closedLots,const double price,const double profit)
|
| {
|
| int n=ArraySize(hev);
|
| if(n>3000) return;
|
| ArrayResize(hev,n+1,32);
|
| hev[n].ticket=p.ticket; hev[n].kind=1; hev[n].dir=p.dir;
|
| hev[n].t=(curTime>0)?curTime:p.time; hev[n].price=price;
|
| hev[n].t0=p.time; hev[n].p0=p.open; hev[n].profit=profit;
|
| hev[n].part=++partSeq; hev[n].lots=closedLots;
|
| }
|
|
|
| void ProcessHistory()
|
| {
|
| int n=ArraySize(hev);
|
| if(n<=0) return;
|
| for(int k=0;k<n;k++)
|
| {
|
| string base="RPH_"+IntegerToString((long)hev[k].ticket)+(hev[k].part>0?"p"+IntegerToString(hev[k].part):"");
|
| bool buy=(hev[k].dir>0);
|
| color col=buy?clrDodgerBlue:clrRed;
|
| if(hev[k].kind==0)
|
| {
|
| string nm=base+"_in";
|
| if(ObjectCreate(panelChart,nm,buy?OBJ_ARROW_BUY:OBJ_ARROW_SELL,0,hev[k].t,hev[k].price))
|
| {
|
| ObjectSetInteger(panelChart,nm,OBJPROP_COLOR,col);
|
| ObjectSetInteger(panelChart,nm,OBJPROP_SELECTABLE,false);
|
| ObjectSetString(panelChart,nm,OBJPROP_TOOLTIP,"#"+IntegerToString((long)hev[k].ticket)+(buy?" buy @ ":" sell @ ")+Px(hev[k].price));
|
| }
|
| }
|
| else
|
| {
|
| string nx=base+"_out", nl=base+"_ln";
|
| color pc=(hev[k].profit>=0)?clrLimeGreen:clrOrangeRed;
|
| if(ObjectCreate(panelChart,nx,OBJ_ARROW,0,hev[k].t,hev[k].price))
|
| {
|
| ObjectSetInteger(panelChart,nx,OBJPROP_ARROWCODE,251);
|
| ObjectSetInteger(panelChart,nx,OBJPROP_COLOR,pc);
|
| ObjectSetInteger(panelChart,nx,OBJPROP_SELECTABLE,false);
|
| ObjectSetString(panelChart,nx,OBJPROP_TOOLTIP,"#"+IntegerToString((long)hev[k].ticket)+(hev[k].part>0?" partial close "+DoubleToString(hev[k].lots,2)+" @ ":" closed @ ")+Px(hev[k].price)+" "+MoneyS(hev[k].profit));
|
| }
|
| if(ObjectCreate(panelChart,nl,OBJ_TREND,0,hev[k].t0,hev[k].p0,hev[k].t,hev[k].price))
|
| {
|
| ObjectSetInteger(panelChart,nl,OBJPROP_COLOR,col);
|
| ObjectSetInteger(panelChart,nl,OBJPROP_STYLE,STYLE_DOT);
|
| ObjectSetInteger(panelChart,nl,OBJPROP_WIDTH,1);
|
| ObjectSetInteger(panelChart,nl,OBJPROP_RAY_RIGHT,false);
|
| ObjectSetInteger(panelChart,nl,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(panelChart,nl,OBJPROP_BACK,true);
|
| }
|
| int m=ArraySize(hDrawn);
|
| ArrayResize(hDrawn,m+1,64);
|
| hDrawn[m]=base;
|
| if(m+1>300) // keep the chart light
|
| {
|
| string ob=hDrawn[0];
|
| ObjectDelete(panelChart,ob+"_in"); ObjectDelete(panelChart,ob+"_out"); ObjectDelete(panelChart,ob+"_ln");
|
| ArrayRemove(hDrawn,0,1);
|
| }
|
| }
|
| }
|
| ArrayResize(hev,0);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Modify SL / TP: validation, drag on chart, Modify popup |
|
| //+------------------------------------------------------------------+
|
| int FindPosByTicket(const ulong tk)
|
| {
|
| for(int i=0;i<ArraySize(pos);i++) if(pos[i].open_ && pos[i].ticket==tk) return i;
|
| return -1;
|
| }
|
|
|
| bool SetPosLevel(const int i,const bool isSL,const double price0,string &err)
|
| {
|
| err="";
|
| if(InpTradeMode!=MODE_SINGLE){ err="Martingale: SL/TP belong to the basket | در مارتینگل SL/TP برای کل سبد است"; return false; }
|
| double price=(price0<=0)?0.0:NormalizeDouble(price0,digitsN);
|
| if(price>0)
|
| {
|
| bool buy=(pos[i].dir>0);
|
| bool ok;
|
| if(isSL) ok=buy?(price<curBid):(price>curAsk);
|
| else ok=buy?(price>curBid):(price<curAsk);
|
| if(!ok){ err=(isSL?"Invalid SL level":"Invalid TP level"); err+=" | سطح نامعتبر"; return false; }
|
| }
|
| if(isSL) pos[i].sl=price; else pos[i].tp=price;
|
| linesDirty=true; uiForce=true;
|
| return true;
|
| }
|
|
|
| int PriceToY(const double price)
|
| {
|
| double mx=ChartGetDouble(panelChart,CHART_PRICE_MAX,0), mn=ChartGetDouble(panelChart,CHART_PRICE_MIN,0);
|
| int h=(int)ChartGetInteger(panelChart,CHART_HEIGHT_IN_PIXELS,0);
|
| if(mx<=mn || h<=0) return -10000;
|
| return (int)MathRound((mx-price)/(mx-mn)*h);
|
| }
|
|
|
| double YToPrice(const int y)
|
| {
|
| double mx=ChartGetDouble(panelChart,CHART_PRICE_MAX,0), mn=ChartGetDouble(panelChart,CHART_PRICE_MIN,0);
|
| int h=(int)ChartGetInteger(panelChart,CHART_HEIGHT_IN_PIXELS,0);
|
| if(h<=0) return 0;
|
| return mx-(double)y/(double)h*(mx-mn);
|
| }
|
|
|
| void BeginDrag(const int kind,const ulong tk,const string name)
|
| {
|
| dragKind=kind; dragTicket=tk; dragName=name;
|
| dragPrice=ObjectGetDouble(panelChart,name,OBJPROP_PRICE);
|
| dragPrice0=dragPrice;
|
| ObjectSetInteger(panelChart,name,OBJPROP_WIDTH,2);
|
| ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,false);
|
| }
|
|
|
| // press on a SL / TP / pending-order line -> drag it like in MetaTrader
|
| bool TryStartLineDrag(const int x,const int y)
|
| {
|
| if(dragKind!=0) return false;
|
| const int TOL=5;
|
| if(InpTradeMode==MODE_SINGLE)
|
| {
|
| for(int i=0;i<ArraySize(pos);i++)
|
| {
|
| if(!pos[i].open_) continue;
|
| string t=IntegerToString((long)pos[i].ticket);
|
| if(pos[i].sl>0 && MathAbs(y-PriceToY(pos[i].sl))<=TOL){ BeginDrag(1,pos[i].ticket,P+"S_"+t); return true; }
|
| if(pos[i].tp>0 && MathAbs(y-PriceToY(pos[i].tp))<=TOL){ BeginDrag(2,pos[i].ticket,P+"T_"+t); return true; }
|
| }
|
| }
|
| else if(basketLots>0 && basketTP>0 && MathAbs(y-PriceToY(basketTP))<=TOL)
|
| { BeginDrag(4,0,P+"BTP"); return true; }
|
| for(int i=0;i<ArraySize(ords);i++)
|
| {
|
| if(!ords[i].live) continue;
|
| if(MathAbs(y-PriceToY(ords[i].price))<=TOL){ BeginDrag(3,ords[i].ticket,P+"O_"+IntegerToString((long)ords[i].ticket)); return true; }
|
| }
|
| return false;
|
| }
|
|
|
| void DragMove(const int y)
|
| {
|
| double p=NormalizeDouble(YToPrice(y),digitsN);
|
| if(p<=0) return;
|
| dragPrice=p;
|
| ObjectSetDouble(panelChart,dragName,OBJPROP_PRICE,p);
|
| ChartRedraw(panelChart);
|
| }
|
|
|
| void ApplyDrag()
|
| {
|
| int kind=dragKind; dragKind=0;
|
| ObjectSetInteger(panelChart,dragName,OBJPROP_WIDTH,(dragName==P+"BTP")?2:1);
|
| linesDirty=true; uiForce=true; // redraw from data: reverts the line if the move is refused
|
| double np=NormalizeDouble(dragPrice,digitsN);
|
| if(MathAbs(np-dragPrice0)<InpPoint*0.5) return;
|
| string e="";
|
| if(kind==1 || kind==2)
|
| {
|
| int i=FindPosByTicket(dragTicket);
|
| if(i<0) return;
|
| if(SetPosLevel(i,kind==1,np,e)) lastMsg=StringFormat("#%I64u %s moved to %s",dragTicket,(kind==1?"SL":"TP"),Px(np));
|
| else lastMsg=e;
|
| }
|
| else if(kind==3)
|
| {
|
| for(int i=0;i<ArraySize(ords);i++)
|
| {
|
| if(!ords[i].live || ords[i].ticket!=dragTicket) continue;
|
| int t=ords[i].type; bool ok=false;
|
| if(t==1) ok=(np<curAsk); else if(t==2) ok=(np>curBid); else if(t==3) ok=(np>curAsk); else ok=(np<curBid);
|
| if(ok){ ords[i].price=np; lastMsg=StringFormat("Order #%I64u moved to %s",dragTicket,Px(np)); }
|
| else lastMsg="Invalid price for "+OrdTypeName(t)+" | قیمت نامعتبر";
|
| break;
|
| }
|
| }
|
| else if(kind==4)
|
| {
|
| bool ok=(bDir>0)?(np>basketAvg):(np<basketAvg);
|
| int pts=(int)MathRound(MathAbs(np-basketAvg)/InpPoint);
|
| if(ok && pts>=1)
|
| {
|
| tpPts=pts;
|
| ObjectSetString(panelChart,P+"TPP",OBJPROP_TEXT,IntegerToString(tpPts));
|
| double sl=basketSL; bool ta=basketTrailActive; CalcBasketAvg(); basketSL=sl; basketTrailActive=ta;
|
| lastMsg=StringFormat("Basket TP = %d points",tpPts);
|
| }
|
| else lastMsg="Invalid basket TP | حد سود نامعتبر";
|
| }
|
| }
|
|
|
| bool InMod(const int x,const int y)
|
| {
|
| return modOpen && x>=modX && x<modX+MOD_W && y>=modY && y<modY+MOD_H;
|
| }
|
|
|
| string HitMod(const int x,const int y)
|
| {
|
| if(!modOpen) return "";
|
| if(y>=modY+72 && y<modY+98)
|
| {
|
| if(x>=modX+10 && x<modX+94) return "MOD_OK";
|
| if(x>=modX+100 && x<modX+190) return "MOD_NOSL";
|
| if(x>=modX+196 && x<modX+286) return "MOD_NOTP";
|
| }
|
| if(y>=modY+108 && y<modY+134 && x>=modX+196 && x<modX+286) return "MOD_X";
|
| return "";
|
| }
|
|
|
| void CloseMod()
|
| {
|
| if(!modOpen) return;
|
| ObjectsDeleteAll(panelChart,P+"MOD_");
|
| modOpen=false; editing=false;
|
| ChartRedraw(panelChart);
|
| }
|
|
|
| void OpenMod(const int i)
|
| {
|
| if(InpTradeMode!=MODE_SINGLE)
|
| { lastMsg="Martingale: SL/TP belong to the basket | در مارتینگل SL/TP برای کل سبد است"; uiForce=true; return; }
|
| if(i<0 || i>=ArraySize(pos) || !pos[i].open_) return;
|
| CloseVol();
|
| CloseMod();
|
| modOpen=true; modTicket=pos[i].ticket;
|
| modX=MathMax(2,trX+40);
|
| modY=(trY>MOD_H+12)?trY-MOD_H-6:trY+trH+6;
|
| Rect("MOD_BG",modX,modY,MOD_W,MOD_H,C'30,36,54',C'0,150,255',3400);
|
| RawBtn(P+"MOD_T",StringFormat("Modify #%I64u %s %.2f",pos[i].ticket,(pos[i].dir>0?"buy":"sell"),pos[i].lots),
|
| modX+3,modY+3,MOD_W-6,24,C'0,92,170',clrWhite,C'0,92,170',9,3500);
|
| Lbl("MOD_LS","S/L",modX+10,modY+42,clrWhite,9);
|
| EditBox("MOD_SL",pos[i].sl>0?Px(pos[i].sl):"0",modX+40,modY+36,100,26);
|
| Lbl("MOD_LT","T/P",modX+156,modY+42,clrWhite,9);
|
| EditBox("MOD_TP",pos[i].tp>0?Px(pos[i].tp):"0",modX+186,modY+36,100,26);
|
| ObjectSetInteger(panelChart,P+"MOD_SL",OBJPROP_ZORDER,3500);
|
| ObjectSetInteger(panelChart,P+"MOD_TP",OBJPROP_ZORDER,3500);
|
| RawBtn(P+"MOD_OK", "Apply", modX+10, modY+72,84, 26,clrForestGreen,clrWhite,Lighten(clrForestGreen,55),9,3500);
|
| RawBtn(P+"MOD_NOSL", "Remove SL", modX+100,modY+72,90, 26,clrFireBrick, clrWhite,Lighten(clrFireBrick,55), 9,3500);
|
| RawBtn(P+"MOD_NOTP", "Remove TP", modX+196,modY+72,90, 26,clrFireBrick, clrWhite,Lighten(clrFireBrick,55), 9,3500);
|
| RawBtn(P+"MOD_X", "Close", modX+196,modY+108,90,26,clrDimGray, clrWhite,Lighten(clrDimGray,55), 9,3500);
|
| Lbl("MOD_H","0 = no level | صفر یعنی بدون سطح",modX+10,modY+114,C'140,152,185',8);
|
| ChartRedraw(panelChart);
|
| }
|
|
|
| void ApplyMod()
|
| {
|
| int i=FindPosByTicket(modTicket);
|
| if(i<0){ CloseMod(); return; }
|
| string t1=ObjectGetString(panelChart,P+"MOD_SL",OBJPROP_TEXT), t2=ObjectGetString(panelChart,P+"MOD_TP",OBJPROP_TEXT);
|
| StringReplace(t1,",","."); StringReplace(t2,",",".");
|
| string e1="", e2="";
|
| bool a=SetPosLevel(i,true,StringToDouble(t1),e1);
|
| bool b=SetPosLevel(i,false,StringToDouble(t2),e2);
|
| if(a && b){ lastMsg=StringFormat("#%I64u SL/TP updated",modTicket); CloseMod(); }
|
| else lastMsg=(a?e2:e1);
|
| uiForce=true;
|
| }
|
|
|
| void ModRemove(const bool isSL)
|
| {
|
| int i=FindPosByTicket(modTicket);
|
| if(i<0){ CloseMod(); return; }
|
| string e="";
|
| SetPosLevel(i,isSL,0,e);
|
| ObjectSetString(panelChart,P+(isSL?"MOD_SL":"MOD_TP"),OBJPROP_TEXT,"0");
|
| lastMsg=StringFormat("#%I64u %s removed",modTicket,(isSL?"SL":"TP"));
|
| uiForce=true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Change Volume of an open position = PARTIAL CLOSE (MT5 style) |
|
| //| the removed part is closed at market, its P/L goes to balance |
|
| //+------------------------------------------------------------------+
|
| bool PartialClose(const int i,const double newLots0,string &err)
|
| {
|
| err="";
|
| if(i<0 || i>=ArraySize(pos) || !pos[i].open_){ err="Position not found | معامله پیدا نشد"; return false; }
|
| double st=MathMax(InpLotStep,0.0001);
|
| double nl=NormalizeDouble(MathRound(newLots0/st)*st,2);
|
| if(newLots0<=0 || nl<InpLotMin)
|
| { err=StringFormat("Minimum volume is %.2f | حداقل حجم %.2f است",InpLotMin,InpLotMin); return false; }
|
| if(nl>pos[i].lots+1e-9)
|
| { err=StringFormat("Volume can only be reduced (now %.2f) | حجم فقط کاهش می‌یابد",pos[i].lots); return false; }
|
| double cl=NormalizeDouble(pos[i].lots-nl,2);
|
| if(cl<=1e-9){ err="Same volume - nothing changed | حجم تغییری نکرد"; return false; }
|
|
|
| double price=(pos[i].dir>0)?curBid:curAsk;
|
| double pr=CalcProfit(pos[i].dir,pos[i].open,cl,price); // P/L of the closed part only
|
| bal+=pr; dayProfit+=pr; weekProfit+=pr; monthProfit+=pr; closedToday+=pr;
|
| AddHevPartial(pos[i],cl,price,pr);
|
| pos[i].lots=nl;
|
|
|
| if(InpTradeMode==MODE_MARTINGALE)
|
| {
|
| double sl=basketSL; bool ta=basketTrailActive;
|
| CalcBasketAvg();
|
| basketSL=sl; basketTrailActive=ta;
|
| }
|
| linesDirty=true; uiForce=true;
|
| lastMsg=StringFormat("#%I64u closed %.2f lot, P/L %s | %.2f remains",pos[i].ticket,cl,MoneyS(pr),nl);
|
| pendLog+=StringFormat("Partial close #%I64u %s %.2f @ %s P/L=%+.2f | remaining %.2f\n",
|
| pos[i].ticket,(pos[i].dir>0?"BUY":"SELL"),cl,Px(price),pr,nl);
|
| return true;
|
| }
|
|
|
| bool InVol(const int x,const int y)
|
| {
|
| return volOpen && x>=volX && x<volX+MOD_W && y>=volY && y<volY+MOD_H;
|
| }
|
|
|
| string HitVol(const int x,const int y)
|
| {
|
| if(!volOpen) return "";
|
| if(y>=volY+72 && y<volY+98)
|
| {
|
| if(x>=volX+10 && x<volX+94) return "VOL_OK";
|
| if(x>=volX+196 && x<volX+286) return "VOL_X";
|
| }
|
| return "";
|
| }
|
|
|
| void CloseVol()
|
| {
|
| if(!volOpen) return;
|
| ObjectsDeleteAll(panelChart,P+"VOL_");
|
| volOpen=false; editing=false;
|
| ChartRedraw(panelChart);
|
| }
|
|
|
| void OpenVol(const int i)
|
| {
|
| if(i<0 || i>=ArraySize(pos) || !pos[i].open_) return;
|
| CloseMod(); CloseVol();
|
| volOpen=true; volTicket=pos[i].ticket;
|
| volX=MathMax(2,trX+40);
|
| volY=(trY>MOD_H+12)?trY-MOD_H-6:trY+trH+6;
|
| Rect("VOL_BG",volX,volY,MOD_W,MOD_H,C'30,36,54',C'0,150,255',3400);
|
| RawBtn(P+"VOL_T",StringFormat("Volume #%I64u %s %.2f",pos[i].ticket,(pos[i].dir>0?"buy":"sell"),pos[i].lots),
|
| volX+3,volY+3,MOD_W-6,24,C'0,92,170',clrWhite,C'0,92,170',9,3500);
|
| Lbl("VOL_LV","Volume",volX+10,volY+42,clrWhite,9);
|
| EditBox("VOL_V",DoubleToString(pos[i].lots,2),volX+70,volY+36,100,26);
|
| ObjectSetInteger(panelChart,P+"VOL_V",OBJPROP_ZORDER,3500);
|
| Lbl("VOL_LC",StringFormat("max %.2f",pos[i].lots),volX+182,volY+42,C'140,152,185',9);
|
| RawBtn(P+"VOL_OK","Apply",volX+10,volY+72,84,26,clrForestGreen,clrWhite,Lighten(clrForestGreen,55),9,3500);
|
| RawBtn(P+"VOL_X","Close",volX+196,volY+72,90,26,clrDimGray,clrWhite,Lighten(clrDimGray,55),9,3500);
|
| Lbl("VOL_H","New volume < current: the rest is closed at market | حجم کمتر یعنی بستن بخشی از معامله",volX+10,volY+108,C'140,152,185',7);
|
| ChartRedraw(panelChart);
|
| }
|
|
|
| void ApplyVol()
|
| {
|
| int i=FindPosByTicket(volTicket);
|
| if(i<0){ CloseVol(); return; }
|
| string t=ObjectGetString(panelChart,P+"VOL_V",OBJPROP_TEXT);
|
| StringReplace(t,",","."); StringTrimLeft(t); StringTrimRight(t);
|
| string e="";
|
| if(PartialClose(i,StringToDouble(t),e)) CloseVol();
|
| else { lastMsg=e; uiForce=true; }
|
| }
|
|
|
| void ApplyTrailText()
|
| {
|
| long a=StringToInteger(ObjectGetString(panelChart,P+"TRS",OBJPROP_TEXT));
|
| long b=StringToInteger(ObjectGetString(panelChart,P+"TRP",OBJPROP_TEXT));
|
| if(a<0) a=0; if(b<0) b=0;
|
| trStart=(int)a; trStep=(int)b;
|
| ObjectSetString(panelChart,P+"TRS",OBJPROP_TEXT,IntegerToString(trStart));
|
| ObjectSetString(panelChart,P+"TRP",OBJPROP_TEXT,IntegerToString(trStep));
|
| lastMsg=StringFormat("Trailing: start %d step %d points",trStart,trStep);
|
| uiForce=true;
|
| }
|
|
|
| void ToggleTrail()
|
| {
|
| trailOn=!trailOn;
|
| if(!trailOn && InpTradeMode==MODE_MARTINGALE){ basketTrailActive=false; basketSL=0; linesDirty=true; }
|
| lastMsg=trailOn?"Trailing stop ON | تریلینگ روشن":"Trailing stop OFF | تریلینگ خاموش";
|
| btnDirty=true; uiForce=true;
|
| }
|
|
|
| void EndDrags()
|
| {
|
| if(dragKind!=0) ApplyDrag();
|
| if(trSize) trSizeDirty=true;
|
| sliderDrag=false; trDrag=false; trSize=false;
|
| ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,true);
|
| }
|
|
|
| //--- press dispatcher -------------------------------------------------
|
| void PressAt(const int x,const int y)
|
| {
|
| if(ctxOpen)
|
| {
|
| string c=HitCtx(x,y);
|
| CloseCtx();
|
| if(c!=""){ MarkPressed(c); Act(c); return; }
|
| }
|
| if(calOpen)
|
| {
|
| if(InCal(x,y))
|
| {
|
| string c=HitCal(x,y);
|
| if(c!=""){ MarkPressed(c); Act(c); }
|
| return;
|
| }
|
| string pid=HitPanel(x,y);
|
| bool same=(calTarget==0 && (pid=="FROM"||pid=="FROM_I")) || (calTarget==1 && (pid=="TO"||pid=="TO_I"));
|
| CloseCal();
|
| if(same){ MarkPressed(pid); return; }
|
| if(pid!=""){ MarkPressed(pid); Act(pid); }
|
| return;
|
| }
|
| if(volOpen)
|
| {
|
| if(InVol(x,y)){ string vc=HitVol(x,y); if(vc!=""){ MarkPressed(vc); Act(vc); } return; }
|
| CloseVol();
|
| }
|
| if(modOpen)
|
| {
|
| if(InMod(x,y)){ string mc=HitMod(x,y); if(mc!=""){ MarkPressed(mc); Act(mc); } return; }
|
| CloseMod();
|
| }
|
| if(InTrades(x,y)){ HandleTrades(x,y); return; }
|
| if(x>=slX-6 && x<slX+slW+6 && y>=slY-4 && y<slY+SL_H+4)
|
| {
|
| sliderDrag=true;
|
| ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,false);
|
| SliderAt(x);
|
| return;
|
| }
|
| if(!(x>=4 && x<4+panW && y>=4 && y<4+panH) && TryStartLineDrag(x,y)) return;
|
| if(!InpFireOnPress) return;
|
| string id=HitPanel(x,y);
|
| if(id!=""){ MarkPressed(id); Act(id); }
|
| }
|
|
|
| void SetPlay(const bool p)
|
| {
|
| playing=p;
|
| lastUs=GetMicrosecondCount();
|
| EventSetMillisecondTimer(p?1:10);
|
| btnDirty=true; uiForce=true;
|
| }
|
|
|
| // Play applies the chosen date range first (if it changed or replay finished)
|
| void StartPlay()
|
| {
|
| bool atEnd=(cur>=endBar && tkIdx>=tkN && barClockUs>=barDurUs);
|
| if(selDirty || atEnd) ApplyRange();
|
| SetPlay(true);
|
| }
|
|
|
| void Act(const string b)
|
| {
|
| if(b=="BUY") OpenTrade(1);
|
| else if(b=="SELL") OpenTrade(-1);
|
| else if(b=="CLOSE") CloseAll();
|
| else if(b=="PLAY") { StartPlay(); UpdateButtonStates(true); btnDirty=false; }
|
| else if(b=="PAUSE") { SetPlay(false); UpdateButtonStates(true); btnDirty=false; }
|
| else if(b=="LIVE") { SetSpeed(1.0); UpdateButtonStates(true); btnDirty=false; }
|
| else if(b=="LOT_M") SetLot(lotSize-InpLotStep);
|
| else if(b=="LOT_P") SetLot(lotSize+InpLotStep);
|
| else if(b=="MAXLOT") SetLot(MaxLotFor(FreeMargin(),curAsk));
|
| else if(b=="APPLY") ApplySLTPOpen();
|
| else if(b=="BAL_RESET") ResetBalance();
|
| else if(b=="BAL_DEP") Deposit();
|
| else if(b=="TRAIL_T") ToggleTrail();
|
| else if(b=="MOD_OK") ApplyMod();
|
| else if(b=="MOD_NOSL") ModRemove(true);
|
| else if(b=="MOD_NOTP") ModRemove(false);
|
| else if(b=="MOD_X") CloseMod();
|
| else if(b=="VOL_OK") ApplyVol();
|
| else if(b=="VOL_X") CloseVol();
|
| else if(b=="TRADES"){ if(trOpen) CloseTrades(); else OpenTrades(); UpdateButtonStates(true); btnDirty=false; }
|
| else if(b=="TW_CLOSE"){ CloseTrades(); UpdateButtonStates(true); btnDirty=false; }
|
| else if(b=="CTX_BL") { PlaceOrder(1,ctxPrice); CloseCtx(); }
|
| else if(b=="CTX_SLM") { PlaceOrder(2,ctxPrice); CloseCtx(); }
|
| else if(b=="CTX_BS") { PlaceOrder(3,ctxPrice); CloseCtx(); }
|
| else if(b=="CTX_SS") { PlaceOrder(4,ctxPrice); CloseCtx(); }
|
| else if(b=="TF_M1") SwitchTF(PERIOD_M1);
|
| else if(b=="TF_M5") SwitchTF(PERIOD_M5);
|
| else if(b=="TF_M15") SwitchTF(PERIOD_M15);
|
| else if(b=="TF_M30") SwitchTF(PERIOD_M30);
|
| else if(b=="TF_H1") SwitchTF(PERIOD_H1);
|
| else if(b=="TF_H4") SwitchTF(PERIOD_H4);
|
| else if(b=="TF_D1") SwitchTF(PERIOD_D1);
|
| else if(b=="TF_W1") SwitchTF(PERIOD_W1);
|
| else if(b=="FROM"||b=="FROM_I") { if(calOpen && calTarget==0) CloseCal(); else OpenCal(0); }
|
| else if(b=="TO"||b=="TO_I") { if(calOpen && calTarget==1) CloseCal(); else OpenCal(1); }
|
| else if(b=="CAL_PREV"){ calMon--; if(calMon<1){calMon=12;calYear--;} RefreshCal(); ChartRedraw(panelChart); }
|
| else if(b=="CAL_NEXT"){ calMon++; if(calMon>12){calMon=1;calYear++;} RefreshCal(); ChartRedraw(panelChart); }
|
| else if(b=="CAL_TODAY"){ PickDate(MathMax(dataFirst,MathMin(dataLast,DayStart(TimeLocal())))); }
|
| else if(StringFind(b,"CAL_D")==0)
|
| {
|
| int i=(int)StringToInteger(StringSubstr(b,5));
|
| if(i>=0 && i<42 && calOn[i]) PickDate(calDate[i]);
|
| }
|
| uiForce=true;
|
| }
|
|
|
| void OnChartEvent(const int id,const long &lp,const double &dp,const string &sp)
|
| {
|
| if(!ready) return;
|
|
|
| if(id==CHARTEVENT_MOUSE_MOVE)
|
| {
|
| int x=(int)lp, y=(int)dp;
|
| uint fl=(uint)StringToInteger(sp);
|
| bool ld=((fl&1)!=0), rd=((fl&2)!=0);
|
| if(ld)
|
| {
|
| if(sliderDrag) SliderAt(x);
|
| else if(trDrag){ trX=MathMax(0,x-trDX); trY=MathMax(0,y-trDY); MoveTrades(); ChartRedraw(panelChart); }
|
| else if(trSize){ trW=MathMax(600,x-trX+10); trH=MathMax(160,y-trY+10); trSizeDirty=true; }
|
| else if(dragKind!=0) DragMove(y);
|
| }
|
| else if(sliderDrag||trDrag||trSize||dragKind!=0) EndDrags();
|
| if(ld && !mouseDown) PressAt(x,y);
|
| if(rd && !rightDown) RightClickAt(x,y);
|
| mouseDown=ld; rightDown=rd;
|
| return;
|
| }
|
|
|
| if(id==CHARTEVENT_OBJECT_ENDEDIT)
|
| {
|
| editing=false;
|
| if(sp==P+"LOT") ApplyLotText();
|
| else if(sp==P+"LEV") ApplyLevText();
|
| else if(sp==P+"SLP"||sp==P+"TPP") ApplySLTPText();
|
| else if(sp==P+"BALV") ApplyBalText();
|
| else if(sp==P+"TRS"||sp==P+"TRP") ApplyTrailText();
|
| return;
|
| }
|
|
|
| // hotkeys: B = Buy, S = Sell, C = Close all, Space = Play/Pause, +/- = speed, Esc = close popups
|
| if(id==CHARTEVENT_KEYDOWN)
|
| {
|
| if(editing) return;
|
| if(lp==66) OpenTrade(1);
|
| else if(lp==83) OpenTrade(-1);
|
| else if(lp==67) CloseAll();
|
| else if(lp==32) { if(playing) Act("PAUSE"); else Act("PLAY"); }
|
| else if(lp==107||lp==187) SpeedStep(1);
|
| else if(lp==109||lp==189) SpeedStep(-1);
|
| else if(lp==27) { CloseCtx(); CloseCal(); CloseMod(); CloseVol(); }
|
| return;
|
| }
|
|
|
| // fallback path (click on release) - skipped when the press already fired
|
| if(id!=CHARTEVENT_OBJECT_CLICK) return;
|
| if(StringFind(sp,P)!=0) return;
|
| if(IsEditName(sp)){ editing=true; return; }
|
| string b=StringSubstr(sp,StringLen(P));
|
| if(b=="") return;
|
| bool dup=(b==pressId && (GetTickCount64()-pressMs)<1500);
|
| if(dup) pressId=""; else Act(b);
|
| ObjectSetInteger(panelChart,sp,OBJPROP_STATE,false);
|
| btnDirty=true; uiForce=true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| TF switch: terminal rebuilds every TF from ticks, so no reload. |
|
| //+------------------------------------------------------------------+
|
| void SwitchTF(ENUM_TIMEFRAMES tf)
|
| {
|
| if(tf==currentTF) return;
|
| FlushTicks();
|
| ChartSetSymbolPeriod(panelChart,customSym,tf);
|
| }
|
|
|
| datetime DayStart(const datetime t){ return (datetime)(((long)t/86400)*86400); }
|
| int FindFirst(const datetime t) // first bar with time >= t
|
| {
|
| int lo=0,hi=total-1;
|
| while(lo<hi){ int mid=(lo+hi)/2; if(rates[mid].time<t) lo=mid+1; else hi=mid; }
|
| return lo;
|
| }
|
| int FindLast(const datetime t) // last bar with time <= t
|
| {
|
| int lo=0,hi=total-1;
|
| while(lo<hi){ int mid=(lo+hi+1)/2; if(rates[mid].time>t) hi=mid-1; else lo=mid; }
|
| return lo;
|
| }
|
|
|
| void ApplyRange()
|
| {
|
| if(selTo<selFrom) selTo=selFrom;
|
| int bf=FindFirst(selFrom);
|
| int bt=FindLast(selTo+86399);
|
| if(bt<=bf) bt=total-1;
|
| SetPlay(false);
|
| endBar=bt;
|
| selDirty=false;
|
| ResetTradeState(false);
|
| ClearAllLines();
|
| StartAt(bf);
|
| linesDirty=true;
|
| }
|
|
|
| void ResetTradeState(const bool resetStats)
|
| {
|
| ArrayResize(pos,0); openCnt=0; needCompact=false;
|
| ArrayResize(ords,0); ordLive=0; ordCompact=false;
|
| martLevel=0; martDir=0;
|
| basketAvg=0; basketLots=0; basketSL=0; basketTP=0; bDir=0; basketTrailActive=false;
|
| if(resetStats)
|
| {
|
| nextT=1; lastDay=0; lastWeek=0; lastMonth=0;
|
| dayProfit=0; ydayProfit=0; weekProfit=0; monthProfit=0;
|
| dayLots=0; weekLots=0; monthLots=0; closedToday=0;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Replay positioning |
|
| //| History = base bars [from..idx-1] + coarser TFs stitched in |
|
| //| for everything older (complete higher-TF history, no holes) |
|
| //+------------------------------------------------------------------+
|
| void PushHistory(const int idx)
|
| {
|
| int from=MathMax(0,idx-InpHistoryBars);
|
| CustomRatesDelete(customSym,0,LONG_MAX);
|
| CustomTicksDelete(customSym,0,LONG_MAX);
|
|
|
| datetime boundary=rates[from].time;
|
| int segS[8], segC[8], segN=0;
|
| int totalN=idx-from;
|
| for(int k=0;k<cK && segN<8;k++)
|
| {
|
| int ps=PeriodSeconds(cTF[k]);
|
| int off=cOff[k], m=cCnt[k];
|
| int lo=0, hi=m;
|
| while(lo<hi){ int mid=(lo+hi)/2; if(cser[off+mid].time+ps<=boundary) lo=mid+1; else hi=mid; }
|
| if(lo<=0) continue;
|
| segS[segN]=off; segC[segN]=lo; segN++;
|
| totalN+=lo;
|
| boundary=cser[off].time;
|
| }
|
| if(totalN<=0) return;
|
| MqlRates all[];
|
| ArrayResize(all,totalN);
|
| int w=0;
|
| for(int s=segN-1;s>=0;s--){ ArrayCopy(all,cser,w,segS[s],segC[s]); w+=segC[s]; }
|
| if(idx-from>0) ArrayCopy(all,rates,w,from,idx-from);
|
| CustomRatesUpdate(customSym,all);
|
| }
|
|
|
| void StartAt(const int idx)
|
| {
|
| cur=idx;
|
| PushHistory(idx);
|
| curBid=(idx>0)?rates[idx-1].close:rates[0].open;
|
| curAsk=curBid+spreadPx;
|
| UpdateStatsPeriod(rates[cur].time);
|
| BuildBarTicks(cur);
|
| tkIdx=0; barClockUs=0;
|
| lastUs=GetMicrosecondCount();
|
| Advance(0.0); // emit opening tick so the first candle is visible
|
| }
|
| void UpdateStatsPeriod(const datetime t)
|
| {
|
| datetime dayStart=(datetime)(((long)t/86400)*86400);
|
| if(dayStart==lastDay && lastWeek!=0 && lastMonth!=0) return;
|
|
|
| MqlDateTime d; TimeToStruct(dayStart,d);
|
| long dn=(long)dayStart/86400;
|
| datetime weekStart =(datetime)((dn-((dn+3)%7))*86400); // Monday based
|
| datetime monthStart=(datetime)(((long)dayStart)-(long)(d.day-1)*86400);
|
|
|
| if(lastDay==0) lastDay=dayStart;
|
| else if(dayStart!=lastDay){ ydayProfit=dayProfit; dayProfit=0; dayLots=0; closedToday=0; lastDay=dayStart; }
|
|
|
| if(lastWeek==0) lastWeek=weekStart;
|
| else if(weekStart!=lastWeek){ weekProfit=0; weekLots=0; lastWeek=weekStart; }
|
|
|
| if(lastMonth==0) lastMonth=monthStart;
|
| else if(monthStart!=lastMonth){ monthProfit=0; monthLots=0; lastMonth=monthStart; }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Data: full multi-TF export / cached load |
|
| //+------------------------------------------------------------------+
|
| string CsvPath(ENUM_TIMEFRAMES tf){ return folderName+"\\"+baseSym+"+"+TFName(tf)+".csv"; }
|
| string BinPath(ENUM_TIMEFRAMES tf){ return folderName+"\\"+baseSym+"+"+TFName(tf)+".bin"; }
|
|
|
| int TfCandidates(ENUM_TIMEFRAMES &c[])
|
| {
|
| ArrayResize(c,8);
|
| c[0]=PERIOD_M1; c[1]=PERIOD_M5; c[2]=PERIOD_M15; c[3]=PERIOD_M30; c[4]=PERIOD_H1; c[5]=PERIOD_H4; c[6]=PERIOD_D1; c[7]=PERIOD_W1;
|
| int s=0;
|
| for(int i=0;i<8;i++) if(c[i]==InpBaseTF){ s=i; break; }
|
| return s;
|
| }
|
|
|
| // make sure the terminal really has the whole history before exporting
|
| int FetchFull(const string sym,ENUM_TIMEFRAMES tf,MqlRates &r[])
|
| {
|
| for(int w=0;w<25;w++){ if((bool)SeriesInfoInteger(sym,tf,SERIES_SYNCHRONIZED)) break; Sleep(200); }
|
| int prev=-1, n=0;
|
| for(int k=0;k<8;k++)
|
| {
|
| n=CopyRates(sym,tf,0,InpBarsToSave,r);
|
| if(n<=0){ Sleep(250); continue; }
|
| if(n==prev || n>=InpBarsToSave) break; // stopped growing => fully loaded
|
| prev=n; Sleep(250);
|
| }
|
| return n;
|
| }
|
|
|
| void SaveSource()
|
| {
|
| ENUM_TIMEFRAMES c[]; int s=TfCandidates(c);
|
| SymbolSelect(_Symbol,true);
|
| for(int k=s;k<8;k++)
|
| {
|
| if(!InpResaveOnInit && FileIsExist(CsvPath(c[k]))) continue;
|
| MqlRates r[];
|
| int n=FetchFull(_Symbol,c[k],r);
|
| if(n<=0){ Print("No history for ",TFName(c[k])," on ",_Symbol); continue; }
|
| if(r[n-1].time+PeriodSeconds(c[k])>TimeCurrent()) n--; // drop the still-forming bar
|
| if(n<=0) continue;
|
| int h=FileOpen(CsvPath(c[k]),FILE_WRITE|FILE_CSV|FILE_ANSI,',');
|
| if(h==INVALID_HANDLE){ Print("Cannot write ",CsvPath(c[k])); continue; }
|
| FileWrite(h,"DateTime","Open","High","Low","Close","TickVolume","Spread","RealVolume");
|
| for(int j=0;j<n;j++)
|
| FileWrite(h,TimeToString(r[j].time,TIME_DATE|TIME_SECONDS),
|
| DoubleToString(r[j].open,_Digits),DoubleToString(r[j].high,_Digits),
|
| DoubleToString(r[j].low,_Digits),DoubleToString(r[j].close,_Digits),
|
| (long)r[j].tick_volume,(int)r[j].spread,(long)r[j].real_volume);
|
| FileClose(h);
|
| FileDelete(BinPath(c[k])); // invalidate binary cache
|
| Print("Saved ",TFName(c[k])," | bars: ",n," | ",TimeToString(r[0].time)," -> ",TimeToString(r[n-1].time));
|
| }
|
| }
|
|
|
| bool SetupCustom()
|
| {
|
| if(!SymbolInfoInteger(customSym,SYMBOL_EXIST))
|
| {
|
| if(!CustomSymbolCreate(customSym,"Custom\\Replay")) return false;
|
| }
|
| CustomSymbolSetInteger(customSym,SYMBOL_DIGITS,digitsN);
|
| CustomSymbolSetDouble(customSym,SYMBOL_POINT,InpPoint);
|
| CustomSymbolSetDouble(customSym,SYMBOL_TRADE_TICK_SIZE,InpPoint);
|
| CustomSymbolSetDouble(customSym,SYMBOL_TRADE_CONTRACT_SIZE,InpContractSize);
|
| CustomSymbolSetInteger(customSym,SYMBOL_TRADE_CALC_MODE,SYMBOL_CALC_MODE_CFD);
|
| CustomSymbolSetInteger(customSym,SYMBOL_TRADE_MODE,SYMBOL_TRADE_MODE_FULL);
|
| SymbolSelect(customSym,true); // required for CustomTicksAdd
|
| return true;
|
| }
|
|
|
| // binary cache: loads hundreds of thousands of bars in milliseconds
|
| bool LoadBin(ENUM_TIMEFRAMES tf,MqlRates &out[])
|
| {
|
| if(!FileIsExist(BinPath(tf)) || !FileIsExist(CsvPath(tf))) return false;
|
| int hc=FileOpen(CsvPath(tf),FILE_READ|FILE_TXT|FILE_ANSI|FILE_SHARE_READ);
|
| if(hc==INVALID_HANDLE) return false;
|
| long dCsv=FileGetInteger(hc,FILE_MODIFY_DATE); FileClose(hc);
|
| int h=FileOpen(BinPath(tf),FILE_READ|FILE_BIN);
|
| if(h==INVALID_HANDLE) return false;
|
| bool ok=false;
|
| if(FileGetInteger(h,FILE_MODIFY_DATE)>=dCsv && FileReadInteger(h)==0x42494E32 && FileReadInteger(h)==InpBarsToLoad)
|
| {
|
| int n=FileReadInteger(h);
|
| if(n>=10 && n<=20000000)
|
| {
|
| ArrayResize(out,n);
|
| ok=((int)FileReadArray(h,out,0,n)==n);
|
| }
|
| }
|
| FileClose(h);
|
| return ok;
|
| }
|
|
|
| void SaveBin(ENUM_TIMEFRAMES tf,MqlRates &src[])
|
| {
|
| int n=ArraySize(src);
|
| int h=FileOpen(BinPath(tf),FILE_WRITE|FILE_BIN);
|
| if(h==INVALID_HANDLE) return;
|
| FileWriteInteger(h,0x42494E32); FileWriteInteger(h,InpBarsToLoad); FileWriteInteger(h,n);
|
| FileWriteArray(h,src,0,n);
|
| FileClose(h);
|
| }
|
|
|
| bool ReadSeries(ENUM_TIMEFRAMES tf,MqlRates &out[])
|
| {
|
| if(LoadBin(tf,out)) return ArraySize(out)>=10;
|
| if(!FileIsExist(CsvPath(tf)))
|
| {
|
| int n0=CopyRates(baseSym,tf,0,InpBarsToLoad,out);
|
| return n0>=10;
|
| }
|
| int h=FileOpen(CsvPath(tf),FILE_READ|FILE_TXT|FILE_ANSI|FILE_SHARE_READ);
|
| if(h==INVALID_HANDLE) return false;
|
| MqlRates tmp[];
|
| ArrayResize(tmp,0,MathMin(InpBarsToSave,3000000)+16);
|
| int n=0; string line; string p[]; datetime lastT=0;
|
| while(!FileIsEnding(h))
|
| {
|
| line=FileReadString(h);
|
| if(StringLen(line)<16) continue;
|
| int k=StringSplit(line,',',p);
|
| if(k<6) continue;
|
| datetime t=StringToTime(p[0]);
|
| if(t<=0 || t<=lastT) continue; // header / duplicates / disorder
|
| double o=StringToDouble(p[1]), hi=StringToDouble(p[2]), lo=StringToDouble(p[3]), cl=StringToDouble(p[4]);
|
| if(o<=0 || hi<=0 || lo<=0 || cl<=0) continue;
|
| MqlRates rr; ZeroMemory(rr);
|
| rr.time=t; rr.open=o; rr.high=hi; rr.low=lo; rr.close=cl;
|
| rr.tick_volume=(long)StringToInteger(p[4+1]); if(rr.tick_volume<=0) rr.tick_volume=1;
|
| if(k>=7) rr.spread=(int)StringToInteger(p[6]);
|
| if(k>=8) rr.real_volume=(long)StringToInteger(p[7]);
|
| ArrayResize(tmp,n+1);
|
| tmp[n++]=rr; lastT=t;
|
| }
|
| FileClose(h);
|
| if(n<10) return false;
|
| int keep=MathMin(n,InpBarsToLoad); // newest bars win
|
| ArrayResize(out,keep);
|
| ArrayCopy(out,tmp,0,n-keep,keep);
|
| SaveBin(tf,out);
|
| return true;
|
| }
|
|
|
| bool LoadBase()
|
| {
|
| ENUM_TIMEFRAMES c[]; int s=TfCandidates(c);
|
| int kb=-1;
|
| for(int k=s;k<8;k++) if(ReadSeries(c[k],rates)){ kb=k; break; }
|
| if(kb<0) return false;
|
| total=ArraySize(rates);
|
| usedTF=c[kb];
|
|
|
| ArrayResize(cser,0); cK=0;
|
| int w=0;
|
| for(int k=kb+1;k<8 && cK<8;k++)
|
| {
|
| MqlRates t[];
|
| if(!ReadSeries(c[k],t)) continue;
|
| int m=ArraySize(t);
|
| ArrayResize(cser,w+m);
|
| ArrayCopy(cser,t,w,0,m);
|
| cTF[cK]=c[k]; cOff[cK]=w; cCnt[cK]=m; cK++; w+=m;
|
| }
|
| Print("Loaded base ",TFName(usedTF)," bars: ",total," | ",TimeToString(rates[0].time)," -> ",TimeToString(rates[total-1].time),
|
| " | stitched coarser TFs: ",cK);
|
| return total>=10;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Persist / restore state across TF changes (MT5 re-inits the EA) |
|
| //+------------------------------------------------------------------+
|
| void SaveState()
|
| {
|
| int h=FileOpen(StatePath(),FILE_WRITE|FILE_BIN);
|
| if(h==INVALID_HANDLE) return;
|
| FileWriteInteger(h,0x52504C5C);
|
| FileWriteLong(h,(long)TimeLocal());
|
| FileWriteInteger(h,cur); FileWriteInteger(h,endBar); FileWriteInteger(h,tkIdx);
|
| FileWriteDouble(h,barClockUs); FileWriteDouble(h,bal); FileWriteDouble(h,speedMult); FileWriteDouble(h,lotSize);
|
| FileWriteInteger(h,leverage); FileWriteInteger(h,slPts); FileWriteInteger(h,tpPts); FileWriteDouble(h,resetBal);
|
| FileWriteInteger(h,trailOn?1:0); FileWriteInteger(h,trStart); FileWriteInteger(h,trStep);
|
| FileWriteInteger(h,playing?1:0); FileWriteLong(h,(long)nextT);
|
| FileWriteInteger(h,martLevel); FileWriteInteger(h,martDir);
|
| FileWriteDouble(h,basketSL); FileWriteInteger(h,basketTrailActive?1:0);
|
| FileWriteDouble(h,curBid);
|
| FileWriteDouble(h,dayProfit); FileWriteDouble(h,ydayProfit); FileWriteDouble(h,weekProfit); FileWriteDouble(h,monthProfit);
|
| FileWriteDouble(h,dayLots); FileWriteDouble(h,weekLots); FileWriteDouble(h,monthLots); FileWriteDouble(h,closedToday);
|
| FileWriteLong(h,(long)lastDay); FileWriteLong(h,(long)lastWeek); FileWriteLong(h,(long)lastMonth);
|
| FileWriteLong(h,(long)selFrom); FileWriteLong(h,(long)selTo); FileWriteInteger(h,selDirty?1:0);
|
| FileWriteInteger(h,trOpen?1:0); FileWriteInteger(h,trX); FileWriteInteger(h,trY); FileWriteInteger(h,trW); FileWriteInteger(h,trH);
|
| int n=ArraySize(pos);
|
| FileWriteInteger(h,n);
|
| for(int i=0;i<n;i++) FileWriteStruct(h,pos[i]);
|
| int m=ArraySize(ords);
|
| FileWriteInteger(h,m);
|
| for(int i=0;i<m;i++) FileWriteStruct(h,ords[i]);
|
| FileClose(h);
|
| }
|
|
|
| bool TryRestoreState()
|
| {
|
| if(!FileIsExist(StatePath())) return false;
|
| int h=FileOpen(StatePath(),FILE_READ|FILE_BIN);
|
| if(h==INVALID_HANDLE) return false;
|
| bool ok=false;
|
| if(FileReadInteger(h)==0x52504C5C)
|
| {
|
| long stamp=FileReadLong(h);
|
| if(MathAbs((long)TimeLocal()-stamp)<=30)
|
| {
|
| cur=FileReadInteger(h); endBar=FileReadInteger(h); tkIdx=FileReadInteger(h);
|
| barClockUs=FileReadDouble(h); bal=FileReadDouble(h); speedMult=FileReadDouble(h); lotSize=FileReadDouble(h);
|
| leverage=FileReadInteger(h); slPts=FileReadInteger(h); tpPts=FileReadInteger(h); resetBal=FileReadDouble(h);
|
| trailOn=(FileReadInteger(h)==1); trStart=FileReadInteger(h); trStep=FileReadInteger(h);
|
| playing=(FileReadInteger(h)==1); nextT=(ulong)FileReadLong(h);
|
| martLevel=FileReadInteger(h); martDir=FileReadInteger(h);
|
| basketSL=FileReadDouble(h); basketTrailActive=(FileReadInteger(h)==1);
|
| curBid=FileReadDouble(h);
|
| dayProfit=FileReadDouble(h); ydayProfit=FileReadDouble(h); weekProfit=FileReadDouble(h); monthProfit=FileReadDouble(h);
|
| dayLots=FileReadDouble(h); weekLots=FileReadDouble(h); monthLots=FileReadDouble(h); closedToday=FileReadDouble(h);
|
| lastDay=(datetime)FileReadLong(h); lastWeek=(datetime)FileReadLong(h); lastMonth=(datetime)FileReadLong(h);
|
| selFrom=(datetime)FileReadLong(h); selTo=(datetime)FileReadLong(h); selDirty=(FileReadInteger(h)==1);
|
| trOpen=(FileReadInteger(h)==1); trX=FileReadInteger(h); trY=FileReadInteger(h); trW=FileReadInteger(h); trH=FileReadInteger(h);
|
| int n=FileReadInteger(h);
|
| ArrayResize(pos,0); ArrayResize(ords,0);
|
| if(n>=0 && n<100000)
|
| {
|
| ArrayResize(pos,n,64);
|
| for(int i=0;i<n;i++) FileReadStruct(h,pos[i]);
|
| int m=FileReadInteger(h);
|
| if(m>=0 && m<100000)
|
| {
|
| ArrayResize(ords,m,16);
|
| for(int i=0;i<m;i++) FileReadStruct(h,ords[i]);
|
| ok=(cur>=0 && cur<total && endBar<total);
|
| }
|
| }
|
| }
|
| }
|
| FileClose(h);
|
| FileDelete(StatePath());
|
| if(!ok){ ArrayResize(pos,0); ArrayResize(ords,0); return false; }
|
|
|
| if(speedMult<SPD_MIN) speedMult=1.0;
|
| if(lotSize<=0) lotSize=InpLot;
|
| if(leverage<1) leverage=InpLeverage;
|
| if(resetBal<=0) resetBal=InpBalance;
|
| if(trStart<0) trStart=0; if(trStep<0) trStep=0;
|
| endBar=MathMin(endBar,total-1);
|
| curAsk=curBid+spreadPx;
|
| openCnt=0; ordLive=0;
|
| for(int i=0;i<ArraySize(pos);i++) if(pos[i].open_) openCnt++;
|
| for(int i=0;i<ArraySize(ords);i++) if(ords[i].live) ordLive++;
|
| if(InpTradeMode==MODE_MARTINGALE){ double sl=basketSL; bool ta=basketTrailActive; CalcBasketAvg(); basketSL=sl; basketTrailActive=ta; }
|
| BuildBarTicks(cur);
|
| if(tkIdx>tkN) tkIdx=tkN;
|
| eq=bal;
|
| Print("State restored after TF change | وضعیت حفظ شد. Bar=",cur);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Chart lines - MetaTrader 5 standard look |
|
| //| dotted lines, labels "#ticket buy 0.10" / "#ticket sl|tp" |
|
| //+------------------------------------------------------------------+
|
| void DrawHLine(const string name,const double price,const color clr,const ENUM_LINE_STYLE st,const int w,const string txt)
|
| {
|
| if(dragKind!=0 && name==dragName) return; // do not fight the user while a line is being dragged
|
| if(ObjectFind(panelChart,name)<0)
|
| {
|
| ObjectCreate(panelChart,name,OBJ_HLINE,0,0,price);
|
| ObjectSetInteger(panelChart,name,OBJPROP_COLOR,clr);
|
| ObjectSetInteger(panelChart,name,OBJPROP_STYLE,st);
|
| ObjectSetInteger(panelChart,name,OBJPROP_WIDTH,w);
|
| ObjectSetInteger(panelChart,name,OBJPROP_BACK,true);
|
| ObjectSetInteger(panelChart,name,OBJPROP_SELECTABLE,false);
|
| }
|
| else ObjectSetDouble(panelChart,name,OBJPROP_PRICE,price);
|
| ObjectSetString(panelChart,name,OBJPROP_TEXT,txt);
|
| }
|
| void DeletePosLines(const ulong ticket)
|
| {
|
| string t=IntegerToString((long)ticket);
|
| ObjectDelete(panelChart,P+"E_"+t);
|
| ObjectDelete(panelChart,P+"S_"+t);
|
| ObjectDelete(panelChart,P+"T_"+t);
|
| }
|
|
|
| void ClearBasketLines()
|
| {
|
| ObjectDelete(panelChart,P+"BAVG");
|
| ObjectDelete(panelChart,P+"BTP");
|
| ObjectDelete(panelChart,P+"BSL");
|
| }
|
|
|
| void ClearAllLines()
|
| {
|
| ObjectsDeleteAll(panelChart,P+"E_");
|
| ObjectsDeleteAll(panelChart,P+"S_");
|
| ObjectsDeleteAll(panelChart,P+"T_");
|
| ObjectsDeleteAll(panelChart,P+"O_");
|
| ObjectsDeleteAll(panelChart,"RPH_");
|
| ArrayResize(hev,0); ArrayResize(hDrawn,0);
|
| ClearBasketLines();
|
| }
|
|
|
| void CompactPositions()
|
| {
|
| int w=0, n=ArraySize(pos);
|
| for(int i=0;i<n;i++)
|
| {
|
| if(!pos[i].open_){ DeletePosLines(pos[i].ticket); continue; }
|
| if(w!=i) pos[w]=pos[i];
|
| w++;
|
| }
|
| ArrayResize(pos,w);
|
| needCompact=false;
|
| }
|
|
|
| void CompactOrders()
|
| {
|
| int w=0, n=ArraySize(ords);
|
| for(int i=0;i<n;i++)
|
| {
|
| if(!ords[i].live){ ObjectDelete(panelChart,P+"O_"+IntegerToString((long)ords[i].ticket)); continue; }
|
| if(w!=i) ords[w]=ords[i];
|
| w++;
|
| }
|
| ArrayResize(ords,w);
|
| ordCompact=false;
|
| }
|
|
|
| void UpdateOrderLines()
|
| {
|
| for(int i=0;i<ArraySize(ords);i++)
|
| {
|
| if(!ords[i].live) continue;
|
| string t=IntegerToString((long)ords[i].ticket);
|
| DrawHLine(P+"O_"+t,ords[i].price,InpColEntry,STYLE_DOT,1,"#"+t+" "+OrdTypeName(ords[i].type)+" "+DoubleToString(ords[i].lots,2));
|
| }
|
| }
|
|
|
| void UpdateTradeLines()
|
| {
|
| for(int i=0;i<ArraySize(pos);i++)
|
| {
|
| if(!pos[i].open_) continue;
|
| string t=IntegerToString((long)pos[i].ticket);
|
| DrawHLine(P+"E_"+t,pos[i].open,InpColEntry,STYLE_DOT,1,"#"+t+" "+(pos[i].dir>0?"buy ":"sell ")+DoubleToString(pos[i].lots,2));
|
| if(InpTradeMode!=MODE_SINGLE) continue;
|
| if(pos[i].sl>0) DrawHLine(P+"S_"+t,pos[i].sl,InpColSL,STYLE_DOT,1,"#"+t+" sl");
|
| else ObjectDelete(panelChart,P+"S_"+t);
|
| if(pos[i].tp>0) DrawHLine(P+"T_"+t,pos[i].tp,InpColTP,STYLE_DOT,1,"#"+t+" tp");
|
| else ObjectDelete(panelChart,P+"T_"+t);
|
| }
|
| }
|
|
|
| void UpdateBasketLines()
|
| {
|
| if(basketLots<=0 || basketAvg<=0){ ClearBasketLines(); return; }
|
| DrawHLine(P+"BAVG",basketAvg,InpColEntry,STYLE_SOLID,2,StringFormat("basket %s %.2f",(bDir>0?"buy":"sell"),basketLots));
|
| DrawHLine(P+"BTP",basketTP,InpColTP,STYLE_SOLID,2,"basket tp");
|
| if(basketTrailActive && basketSL>0) DrawHLine(P+"BSL",basketSL,InpColSL,STYLE_SOLID,2,"basket sl");
|
| else ObjectDelete(panelChart,P+"BSL");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| UI refresh (throttled, never inside the tick loop) |
|
| //+------------------------------------------------------------------+
|
| void SetT(const int k,const string id,const string t0)
|
| {
|
| string t=(t0=="")?" ":t0;
|
| if(lcT[k]==t) return;
|
| lcT[k]=t;
|
| ObjectSetString(panelChart,P+id,OBJPROP_TEXT,t);
|
| }
|
| void SetCol(const int k,const string id,const color c)
|
| {
|
| if(lcC[k]==c) return;
|
| lcC[k]=c;
|
| ObjectSetInteger(panelChart,P+id,OBJPROP_COLOR,c);
|
| }
|
|
|
| void UpdateUI()
|
| {
|
| uiForce=false;
|
|
|
| double flo=0, used=0, buyL=0, sellL=0; int nb=0, ns=0;
|
| for(int i=0;i<ArraySize(pos);i++)
|
| {
|
| if(!pos[i].open_) continue;
|
| double fl=CalcProfit(pos[i].dir,pos[i].open,pos[i].lots,pos[i].dir>0?curBid:curAsk);
|
| flo+=fl;
|
| used+=pos[i].lots*InpContractSize*pos[i].open/leverage;
|
| if(pos[i].dir>0){ buyL+=pos[i].lots; nb++; } else { sellL+=pos[i].lots; ns++; }
|
| ObjectSetString(panelChart,P+"E_"+IntegerToString((long)pos[i].ticket),OBJPROP_TEXT,
|
| StringFormat("#%I64u %s %.2f %s",pos[i].ticket,(pos[i].dir>0?"buy":"sell"),pos[i].lots,MoneyS(fl)));
|
| }
|
| eq=bal+flo;
|
| double freeM=eq-used;
|
| double mlvl=(used>0)?eq/used*100.0:0;
|
|
|
| if(needCompact) CompactPositions();
|
| if(ordCompact) CompactOrders();
|
| if(linesDirty)
|
| {
|
| linesDirty=false;
|
| UpdateOrderLines();
|
| UpdateTradeLines();
|
| if(InpTradeMode==MODE_MARTINGALE) UpdateBasketLines();
|
| }
|
| ProcessHistory();
|
| if(btnDirty){ btnDirty=false; UpdateButtonStates(false); }
|
| if(pendLog!=""){ Print(pendLog); pendLog=""; }
|
|
|
| // simulated time & candle countdown
|
| double simSec=(double)rates[cur].time+barClockUs/1e6;
|
| int tfs=PeriodSeconds(currentTF); if(tfs<=0) tfs=300;
|
| double tfOff=(currentTF==PERIOD_W1)?3.0*86400.0:0.0;
|
| double remReal=(tfs-MathMod(simSec-tfOff,(double)tfs))/MathMax(0.01,speedMult);
|
| int rm=(int)(remReal/60.0), rs=(int)MathMod(remReal,60.0), rt=(int)(MathMod(remReal,1.0)*10.0);
|
|
|
| // --- big quote buttons
|
| SetT(K_SELL,"SELL","SELL "+Px(curBid));
|
| SetT(K_BUY, "BUY", "BUY "+Px(curAsk));
|
| SetT(K_SPEED,"SPDV",SpeedTxt(speedMult));
|
|
|
| // --- account cells
|
| SetT(K_BAL,"VB",Money(bal));
|
| SetT(K_EQ, "VE",Money(eq)); SetCol(K_EQ,"VE",PnlCol(eq-bal));
|
| SetT(K_FLO,"VF",MoneyS(flo)); SetCol(K_FLO,"VF",PnlCol(flo));
|
|
|
| SetT(K_MG,"VMG",Money(used));
|
| SetT(K_FM,"VFM",Money(freeM)); SetCol(K_FM,"VFM",(freeM>=0)?clrWhite:C'255,100,100');
|
| SetT(K_ML,"VML",(used>0)?DoubleToString(mlvl,1)+"%":"--");
|
| SetCol(K_ML,"VML",(used<=0)?clrWhite:(mlvl<InpStopOutPct*1.5)?C'255,100,100':(mlvl<150.0)?C'255,190,60':C'90,225,130');
|
|
|
| double mpl=InpContractSize*curAsk/leverage; // margin for 1.00 lot
|
| int fit=(mpl*lotSize>0)?(int)MathFloor(MathMax(0.0,freeM)/(mpl*lotSize)):0;
|
| SetT(K_LI,"LI",StringFormat("Margin/1 lot %s | This lot %s | Max lot %.2f | Fits %d trade(s)",
|
| Money(mpl),Money(mpl*lotSize),MaxLotFor(freeM,curAsk),fit));
|
|
|
| int op=nb+ns;
|
| SetT(K_POS,"POS",(op==0)?StringFormat("No open positions | Pending: %d",ordLive)
|
| :StringFormat("Open %d | Buy %.2f (%d) Sell %.2f (%d) Net %+.2f | Pending: %d",op,buyL,nb,sellL,ns,buyL-sellL,ordLive));
|
|
|
| SetT(K_TD,"VT",MoneyS(dayProfit)); SetCol(K_TD,"VT",PnlCol(dayProfit));
|
| SetT(K_YD,"VY",MoneyS(ydayProfit)); SetCol(K_YD,"VY",PnlCol(ydayProfit));
|
| SetT(K_WK,"VW",MoneyS(weekProfit)); SetCol(K_WK,"VW",PnlCol(weekProfit));
|
| SetT(K_MO,"VM",MoneyS(monthProfit)); SetCol(K_MO,"VM",PnlCol(monthProfit));
|
| SetT(K_LOTS,"LOTS",StringFormat("Lots traded Today %.2f | Week %.2f | Month %.2f",dayLots,weekLots,monthLots));
|
|
|
| if(InpTradeMode==MODE_SINGLE)
|
| SetT(K_MODE,"MODE",StringFormat("Mode: Single | تک معامله SL %d TP %d Trail %s %d/%d Lev 1:%d",slPts,tpPts,(trailOn?"ON":"OFF"),trStart,trStep,leverage));
|
| else
|
| SetT(K_MODE,"MODE",StringFormat("Mode: Martingale | مارتینگل Lvl %d Avg %s Lots %.2f Trail %s",
|
| martLevel,(basketAvg>0?Px(basketAvg):"--"),basketLots,basketTrailActive?"ON":"OFF"));
|
|
|
| SetT(K_INFO,"INFO",StringFormat("%s %s %s Bid %s Ask %s Spr %d",(playing?"▶":"⏸"),SpeedTxt(speedMult),
|
| TimeToString((datetime)simSec,TIME_DATE|TIME_SECONDS),Px(curBid),Px(curAsk),InpSpreadPts));
|
| SetT(K_INFO2,"INFO2",StringFormat("TF %s | bar %d/%d | tick %d/%d | ⏱ %d:%02d.%d",
|
| TFName(currentTF),cur+1,total,tkIdx,tkN,rm,rs,rt));
|
| SetT(K_MSG,"MSG",lastMsg);
|
|
|
| if(trOpen) RefreshTrades();
|
| ChartRedraw(panelChart);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Panel: framed, 3D-style buttons |
|
| //+------------------------------------------------------------------+
|
| color Lighten(const color c,const int a)
|
| {
|
| int r=(int)(((uint)c)&0xFF), g=(int)((((uint)c)>>8)&0xFF), b=(int)((((uint)c)>>16)&0xFF);
|
| r=MathMin(255,r+a); g=MathMin(255,g+a); b=MathMin(255,b+a);
|
| return (color)(r|(g<<8)|(b<<16));
|
| }
|
| void Rect(const string id,const int x,const int y,const int w,const int h,const color bg,const color border,const int z=0)
|
| {
|
| string n=P+id;
|
| ObjectCreate(panelChart,n,OBJ_RECTANGLE_LABEL,0,0,0);
|
| ObjectSetInteger(panelChart,n,OBJPROP_CORNER,CORNER_LEFT_UPPER);
|
| ObjectSetInteger(panelChart,n,OBJPROP_XDISTANCE,x);
|
| ObjectSetInteger(panelChart,n,OBJPROP_YDISTANCE,y);
|
| ObjectSetInteger(panelChart,n,OBJPROP_XSIZE,w);
|
| ObjectSetInteger(panelChart,n,OBJPROP_YSIZE,h);
|
| ObjectSetInteger(panelChart,n,OBJPROP_BGCOLOR,bg);
|
| ObjectSetInteger(panelChart,n,OBJPROP_BORDER_TYPE,BORDER_FLAT);
|
| ObjectSetInteger(panelChart,n,OBJPROP_COLOR,border);
|
| ObjectSetInteger(panelChart,n,OBJPROP_BACK,false);
|
| ObjectSetInteger(panelChart,n,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(panelChart,n,OBJPROP_ZORDER,z);
|
| }
|
| void Reg(const string id,const int x,const int y,const int w,const int h)
|
| {
|
| if(rN>=48) return;
|
| rId[rN]=id; rX[rN]=x; rY[rN]=y; rW[rN]=w; rH[rN]=h; rN++;
|
| }
|
| void RawBtn(const string n,const string t,const int x,const int y,const int w,const int h,
|
| const color bg,const color tc,const color border,const int fs,const int z)
|
| {
|
| ObjectCreate(panelChart,n,OBJ_BUTTON,0,0,0);
|
| ObjectSetInteger(panelChart,n,OBJPROP_XDISTANCE,x);
|
| ObjectSetInteger(panelChart,n,OBJPROP_YDISTANCE,y);
|
| ObjectSetInteger(panelChart,n,OBJPROP_XSIZE,w);
|
| ObjectSetInteger(panelChart,n,OBJPROP_YSIZE,h);
|
| ObjectSetString(panelChart,n,OBJPROP_TEXT,t);
|
| ObjectSetString(panelChart,n,OBJPROP_FONT,"Segoe UI Semibold");
|
| ObjectSetInteger(panelChart,n,OBJPROP_FONTSIZE,fs);
|
| ObjectSetInteger(panelChart,n,OBJPROP_COLOR,tc);
|
| ObjectSetInteger(panelChart,n,OBJPROP_BGCOLOR,bg);
|
| ObjectSetInteger(panelChart,n,OBJPROP_BORDER_COLOR,border);
|
| ObjectSetInteger(panelChart,n,OBJPROP_CORNER,CORNER_LEFT_UPPER);
|
| ObjectSetInteger(panelChart,n,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(panelChart,n,OBJPROP_ZORDER,z);
|
| ObjectSetInteger(panelChart,n,OBJPROP_STATE,false);
|
| }
|
| void Btn3D(const string id,const string t,const int x,const int y,const int w,const int h,const color bg,const int fs=9)
|
| {
|
| Rect(id+"_sh",x+2,y+3,w,h,C'6,8,14',C'6,8,14');
|
| RawBtn(P+id,t,x,y,w,h,bg,clrWhite,Lighten(bg,55),fs,500);
|
| Rect(id+"_hl",x+2,y+2,w-4,1,Lighten(bg,110),Lighten(bg,110));
|
| Reg(id,x,y,w,h);
|
| }
|
| void SetBtn(const string id,const color bg,const color tc)
|
| {
|
| ObjectSetInteger(panelChart,P+id,OBJPROP_BGCOLOR,bg);
|
| ObjectSetInteger(panelChart,P+id,OBJPROP_COLOR,tc);
|
| ObjectSetInteger(panelChart,P+id,OBJPROP_BORDER_COLOR,Lighten(bg,55));
|
| ObjectSetInteger(panelChart,P+id+"_hl",OBJPROP_BGCOLOR,Lighten(bg,110));
|
| ObjectSetInteger(panelChart,P+id+"_hl",OBJPROP_COLOR,Lighten(bg,110));
|
| }
|
|
|
| void Lbl(const string id,const string t,const int x,const int y,const color c=clrYellow,
|
| const int fs=9,const string font="Segoe UI")
|
| {
|
| string n=P+id;
|
| ObjectCreate(panelChart,n,OBJ_LABEL,0,0,0);
|
| ObjectSetInteger(panelChart,n,OBJPROP_XDISTANCE,x);
|
| ObjectSetInteger(panelChart,n,OBJPROP_YDISTANCE,y);
|
| ObjectSetString(panelChart,n,OBJPROP_TEXT,(t=="")?" ":t); // empty text would show "Label"
|
| ObjectSetString(panelChart,n,OBJPROP_FONT,font);
|
| ObjectSetInteger(panelChart,n,OBJPROP_COLOR,c);
|
| ObjectSetInteger(panelChart,n,OBJPROP_CORNER,CORNER_LEFT_UPPER);
|
| ObjectSetInteger(panelChart,n,OBJPROP_FONTSIZE,fs);
|
| ObjectSetInteger(panelChart,n,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(panelChart,n,OBJPROP_ZORDER,0);
|
| }
|
|
|
| void EditBox(const string id,const string t,const int x,const int y,const int w,const int h)
|
| {
|
| string n=P+id;
|
| ObjectCreate(panelChart,n,OBJ_EDIT,0,0,0);
|
| ObjectSetInteger(panelChart,n,OBJPROP_XDISTANCE,x);
|
| ObjectSetInteger(panelChart,n,OBJPROP_YDISTANCE,y);
|
| ObjectSetInteger(panelChart,n,OBJPROP_XSIZE,w);
|
| ObjectSetInteger(panelChart,n,OBJPROP_YSIZE,h);
|
| ObjectSetString(panelChart,n,OBJPROP_TEXT,t);
|
| ObjectSetString(panelChart,n,OBJPROP_FONT,"Segoe UI Semibold");
|
| ObjectSetInteger(panelChart,n,OBJPROP_FONTSIZE,11);
|
| ObjectSetInteger(panelChart,n,OBJPROP_COLOR,clrBlack);
|
| ObjectSetInteger(panelChart,n,OBJPROP_BGCOLOR,clrWhite);
|
| ObjectSetInteger(panelChart,n,OBJPROP_BORDER_COLOR,C'0,120,215');
|
| ObjectSetInteger(panelChart,n,OBJPROP_CORNER,CORNER_LEFT_UPPER);
|
| ObjectSetInteger(panelChart,n,OBJPROP_ALIGN,ALIGN_CENTER);
|
| ObjectSetInteger(panelChart,n,OBJPROP_ZORDER,500);
|
| }
|
|
|
| void DateField(const string id,const datetime d,const int x,const int y)
|
| {
|
| RawBtn(P+id,TimeToString(d,TIME_DATE),x,y,104,26,clrWhite,clrBlack,C'0,120,215',10,500);
|
| Reg(id,x,y,104,26);
|
| Btn3D(id+"_I","▦ ▾",x+104,y,28,26,C'96,110,140',9);
|
| }
|
|
|
| void BuildPanel()
|
| {
|
| ObjectsDeleteAll(panelChart,P);
|
| rN=0; calOpen=false; ctxOpen=false;
|
| for(int i=0;i<40;i++){ lcC[i]=clrNONE; lcT[i]="~~"; }
|
| const int PX=4, PY=4;
|
| panW=480;
|
| const int x=PX+14;
|
| const color KEY=C'140,152,185', LAB=C'190,200,225';
|
| int y=PY+34;
|
|
|
| Rect("FRAME", PX, PY, panW, 400,C'24,30,46',C'0,150,255');
|
| Rect("FRAME2",PX+3,PY+3,panW-6, 394,C'24,30,46',C'52,68,104');
|
| Rect("TBAR", PX+4,PY+4,panW-8, 24, C'0,92,170',C'0,92,170');
|
| Lbl("TTL","◆ MARKET REPLAY v9.1 | ریپلی بازار",x,PY+8,clrWhite,10,"Segoe UI Semibold");
|
|
|
| // --- row 1: transport
|
| Btn3D("PLAY", "▶ Play", x, y,104,30,clrDarkGreen,10);
|
| Btn3D("PAUSE", "⏸ Pause", x+112, y,104,30,clrDarkOrange,10);
|
| Btn3D("TRADES","▤ Trades",x+224, y,124,30,clrSteelBlue,10);
|
|
|
| // --- row 2: speed slider
|
| y+=40;
|
| Lbl("LS","Speed",x,y+4,LAB,9);
|
| slX=x+50; slY=y;
|
| Rect("SL_TRK",slX,slY+SL_H/2-5,slW,10,C'208,213,226',C'96,108,140',600);
|
| Rect("SL_GRV",slX+3,slY+SL_H/2-1,slW-6,2,C'120,132,165',C'120,132,165',600);
|
| for(int i=0;i<5;i++)
|
| {
|
| string tx=(i==0)?"0.1x":(i==1)?"1x":(i==2)?"10x":(i==3)?"100x":"1000x";
|
| int tx_x=slX+(int)MathRound(i*0.25*(slW-SL_TH))+SL_TH/2-(StringLen(tx)*3);
|
| Lbl("SK"+IntegerToString(i),tx,tx_x,y+SL_H+3,KEY,7);
|
| Rect("ST"+IntegerToString(i),slX+(int)MathRound(i*0.25*(slW-SL_TH))+SL_TH/2,slY+SL_H/2+6,1,4,C'96,108,140',C'96,108,140',600);
|
| }
|
| RawBtn(P+"SL_TH","",slX,slY,SL_TH,SL_H,C'238,241,248',clrBlack,C'70,80,115',8,700);
|
| PlaceThumb();
|
| Lbl("SPDV","Live 1x",x+322,y+3,clrGold,11,"Segoe UI Semibold");
|
| Btn3D("LIVE","Live",x+400,y,52,26,clrTeal);
|
|
|
| // --- row 3: timeframes
|
| y+=50;
|
| Lbl("LTF","TF",x,y+5,LAB);
|
| Btn3D("TF_M1", "M1", x+26, y,48,26,clrSteelBlue);
|
| Btn3D("TF_M5", "M5", x+78, y,48,26,clrSteelBlue);
|
| Btn3D("TF_M15","M15", x+130, y,48,26,clrSteelBlue);
|
| Btn3D("TF_M30","M30", x+182, y,48,26,clrSteelBlue);
|
| Btn3D("TF_H1", "H1", x+234, y,48,26,clrSteelBlue);
|
| Btn3D("TF_H4", "H4", x+286, y,48,26,clrSteelBlue);
|
| Btn3D("TF_D1", "D1", x+338, y,48,26,clrSteelBlue);
|
| Btn3D("TF_W1", "W1", x+390, y,48,26,clrSteelBlue);
|
|
|
| // --- row 4: date range
|
| y+=38;
|
| dateRowY=y; fromFieldX=x+44; toFieldX=x+246;
|
| Lbl("LF","From:",x,y+5,LAB);
|
| DateField("FROM",selFrom,fromFieldX,y);
|
| Lbl("LT","To:",x+206,y+5,LAB);
|
| DateField("TO",selTo,toFieldX,y);
|
|
|
| // --- row 5: lot + leverage
|
| y+=38;
|
| Lbl("LLOT","Lot:",x,y+5,LAB);
|
| Btn3D("LOT_M","−",x+34, y,30,26,clrDimGray,12);
|
| EditBox("LOT",DoubleToString(lotSize,2),x+68,y,78,26);
|
| Btn3D("LOT_P","+",x+150,y,30,26,clrDimGray,12);
|
| Btn3D("MAXLOT","Max",x+186,y,46,26,clrSlateGray,9);
|
| Lbl("LLEV","Leverage 1 :",x+250,y+5,LAB);
|
| EditBox("LEV",IntegerToString(leverage),x+346,y,70,26);
|
| y+=31;
|
| Lbl("LI","",x,y,KEY,8);
|
| y+=22;
|
|
|
| // --- row 6: SL / TP
|
| Lbl("LSL","SL pts:",x,y+5,LAB);
|
| EditBox("SLP",IntegerToString(slPts),x+50,y,76,26);
|
| Lbl("LTP",(InpTradeMode==MODE_SINGLE)?"TP pts:":"Basket TP:",x+140,y+5,LAB);
|
| EditBox("TPP",IntegerToString(tpPts),x+206,y,76,26);
|
| Btn3D("APPLY","Apply to open",x+296,y,120,26,clrSteelBlue,9);
|
|
|
| // --- row 6b: trailing stop
|
| y+=36;
|
| Lbl("LTR",(InpTradeMode==MODE_SINGLE)?"Trailing:":"Basket trail:",x,y+5,LAB);
|
| Btn3D("TRAIL_T",trailOn?"ON":"OFF",x+84,y,52,26,trailOn?clrForestGreen:clrDimGray,9);
|
| Lbl("LTS","Start pts:",x+146,y+5,LAB);
|
| EditBox("TRS",IntegerToString(trStart),x+214,y,66,26);
|
| Lbl("LTP2","Step pts:",x+290,y+5,LAB);
|
| EditBox("TRP",IntegerToString(trStep),x+354,y,66,26);
|
|
|
| // --- row 7: balance control
|
| y+=36;
|
| Lbl("LBV","Amount:",x,y+5,LAB);
|
| EditBox("BALV",DoubleToString(resetBal,2),x+56,y,110,26);
|
| Btn3D("BAL_RESET","Reset balance",x+174,y,130,26,clrDarkOrange,9);
|
| Btn3D("BAL_DEP","+ Deposit",x+312,y,110,26,clrTeal,9);
|
|
|
| // --- row 8: SELL (left) CLOSE BUY (right)
|
| y+=40;
|
| Btn3D("SELL", "SELL", x, y,166,46,clrFireBrick,12);
|
| Btn3D("CLOSE","Close All",x+174, y,104,46,clrDimGray,10);
|
| Btn3D("BUY", "BUY", x+286, y,166,46,clrForestGreen,12);
|
|
|
| // --- stats block
|
| y+=58;
|
| int statTop=y-6;
|
| Rect("STATS",x-6,statTop,panW-16,200,C'12,16,28',C'60,74,108');
|
| Lbl("KB","BALANCE",x,y,KEY,8); Lbl("VB","",x,y+12,clrWhite,13,"Segoe UI Semibold");
|
| Lbl("KE","EQUITY",x+156,y,KEY,8); Lbl("VE","",x+156,y+12,clrWhite,13,"Segoe UI Semibold");
|
| Lbl("KF","FLOATING P/L",x+312,y,KEY,8); Lbl("VF","",x+312,y+12,clrWhite,13,"Segoe UI Semibold");
|
| y+=42;
|
| Lbl("KG","USED MARGIN",x,y,KEY,8); Lbl("VMG","",x,y+12,clrWhite,11,"Segoe UI Semibold");
|
| Lbl("KH","FREE MARGIN",x+156,y,KEY,8); Lbl("VFM","",x+156,y+12,clrWhite,11,"Segoe UI Semibold");
|
| Lbl("KL","MARGIN LEVEL",x+312,y,KEY,8); Lbl("VML","",x+312,y+12,clrWhite,11,"Segoe UI Semibold");
|
| y+=40;
|
| Lbl("POS","",x,y,clrWhite,9);
|
| y+=22;
|
| Rect("SEP1",x,y-2,panW-28,1,C'60,74,108',C'60,74,108');
|
| Lbl("KT","TODAY",x,y+2,KEY,8); Lbl("VT","",x,y+14,clrWhite,11,"Segoe UI Semibold");
|
| Lbl("KY","YESTERDAY",x+114,y+2,KEY,8); Lbl("VY","",x+114,y+14,clrWhite,11,"Segoe UI Semibold");
|
| Lbl("KW","WEEK",x+228,y+2,KEY,8); Lbl("VW","",x+228,y+14,clrWhite,11,"Segoe UI Semibold");
|
| Lbl("KM","MONTH",x+342,y+2,KEY,8); Lbl("VM","",x+342,y+14,clrWhite,11,"Segoe UI Semibold");
|
| y+=40;
|
| Lbl("LOTS","",x,y,LAB,9); y+=20;
|
| Lbl("MODE","",x,y,LAB,9); y+=22;
|
| Rect("SEP2",x,y-2,panW-28,1,C'60,74,108',C'60,74,108');
|
| Lbl("INFO","",x,y+2,clrWhite,9); y+=19;
|
| Lbl("INFO2","",x,y+2,clrWhite,9); y+=19;
|
| Lbl("MSG","",x,y+2,clrTomato,9); y+=19;
|
| Lbl("HINT","Keys: B=Buy S=Sell C=Close Space=Play/Pause +/-=Speed Esc=Cancel",x,y+2,C'110,124,160',8);
|
| y+=26;
|
|
|
| panH=y-PY;
|
| ObjectSetInteger(panelChart,P+"FRAME", OBJPROP_YSIZE,panH);
|
| ObjectSetInteger(panelChart,P+"FRAME2",OBJPROP_YSIZE,panH-6);
|
| ObjectSetInteger(panelChart,P+"STATS", OBJPROP_YSIZE,y-26-statTop+22);
|
| }
|
|
|
| void SpBtn(const string id,const bool on,const color idle)
|
| {
|
| if(on) SetBtn(id,clrGold,clrBlack); else SetBtn(id,idle,clrWhite);
|
| }
|
| void TfBtn(const string id,const ENUM_TIMEFRAMES tf)
|
| {
|
| if(currentTF==tf) SetBtn(id,clrDodgerBlue,clrWhite); else SetBtn(id,clrSteelBlue,clrWhite);
|
| }
|
|
|
| void UpdateButtonStates(const bool redraw)
|
| {
|
| SetBtn("PLAY", playing?clrLimeGreen:clrDarkGreen, playing?clrBlack:clrWhite);
|
| SetBtn("PAUSE",playing?clrDarkOrange:clrOrange, clrWhite);
|
| ObjectSetString(panelChart,P+"PLAY", OBJPROP_TEXT,playing?"▶ Playing":"▶ Play");
|
| ObjectSetString(panelChart,P+"PAUSE",OBJPROP_TEXT,playing?"⏸ Pause":"⏸ Paused");
|
| if(trOpen) SetBtn("TRADES",clrDodgerBlue,clrWhite); else SetBtn("TRADES",clrSteelBlue,clrWhite);
|
| SpBtn("LIVE",speedMult==1.0,clrTeal);
|
| SetBtn("TRAIL_T",trailOn?clrForestGreen:clrDimGray,clrWhite);
|
| ObjectSetString(panelChart,P+"TRAIL_T",OBJPROP_TEXT,trailOn?"ON":"OFF");
|
|
|
| TfBtn("TF_M1",PERIOD_M1); TfBtn("TF_M5",PERIOD_M5); TfBtn("TF_M15",PERIOD_M15);
|
| TfBtn("TF_M30",PERIOD_M30); TfBtn("TF_H1",PERIOD_H1); TfBtn("TF_H4",PERIOD_H4);
|
| TfBtn("TF_D1",PERIOD_D1); TfBtn("TF_W1",PERIOD_W1);
|
| SetT(K_SPEED,"SPDV",SpeedTxt(speedMult));
|
| if(redraw) ChartRedraw(panelChart);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Calendar popup (month grid, Sun..Sat, like a Windows date picker)|
|
| //+------------------------------------------------------------------+
|
| void CalBtn(const string id,const string t,const int x,const int y,const int w,const int h,
|
| const color bg,const color tc,const color border,const int fs=9)
|
| {
|
| RawBtn(P+"CAL_"+id,t,x,y,w,h,bg,tc,border,fs,2000);
|
| }
|
| void OpenCal(const int target)
|
| {
|
| CloseCal();
|
| calTarget=target; calOpen=true;
|
| datetime d=(target==0)?selFrom:selTo;
|
| MqlDateTime s; TimeToStruct(d,s);
|
| calYear=s.year; calMon=s.mon;
|
| int fx=(target==0)?fromFieldX:toFieldX;
|
| calX=MathMin(fx,4+panW-calW-6);
|
| calY=dateRowY+28;
|
|
|
| Rect("CAL_BG",calX,calY,calW,calH,clrWhite,C'110,110,110',1999);
|
| CalBtn("PREV","◀",calX+6,calY+4,28,24,clrWhite,C'60,60,60',clrWhite,10);
|
| CalBtn("NEXT","▶",calX+calW-34,calY+4,28,24,clrWhite,C'60,60,60',clrWhite,10);
|
| CalBtn("TITLE","",calX+40,calY+4,calW-80,24,clrWhite,clrBlack,clrWhite,10);
|
| string wd[7]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
|
| int gx=calX+8, gy=calY+CAL_HDR+CAL_WK;
|
| for(int c=0;c<7;c++)
|
| CalBtn("W"+IntegerToString(c),wd[c],gx+c*CAL_CW,calY+CAL_HDR,CAL_CW,CAL_WK,clrWhite,C'40,40,40',clrWhite,9);
|
| for(int i=0;i<42;i++)
|
| CalBtn("D"+IntegerToString(i),"",gx+(i%7)*CAL_CW+1,gy+(i/7)*CAL_CH+1,CAL_CW-2,CAL_CH-2,clrWhite,clrBlack,clrWhite,10);
|
| CalBtn("TODAY","Today: "+TimeToString(DayStart(TimeLocal()),TIME_DATE),gx,gy+6*CAL_CH+4,210,24,clrWhite,C'30,30,30',C'0,120,215',9);
|
| RefreshCal();
|
| ChartRedraw(panelChart);
|
| }
|
| void RefreshCal()
|
| {
|
| ObjectSetString(panelChart,P+"CAL_TITLE",OBJPROP_TEXT,MonName[calMon-1]+" "+IntegerToString(calYear));
|
| datetime first=StringToTime(StringFormat("%04d.%02d.01",calYear,calMon));
|
| MqlDateTime f; TimeToStruct(first,f);
|
| datetime start=first-(datetime)((long)f.day_of_week*86400);
|
| datetime sel=(calTarget==0)?selFrom:selTo;
|
| datetime today=DayStart(TimeLocal());
|
| for(int i=0;i<42;i++)
|
| {
|
| datetime d=start+(datetime)((long)i*86400);
|
| MqlDateTime m; TimeToStruct(d,m);
|
| bool inMon=(m.mon==calMon);
|
| bool on=(d>=dataFirst && d<=dataLast);
|
| calDate[i]=d; calOn[i]=on;
|
| string n=P+"CAL_D"+IntegerToString(i);
|
| ObjectSetString(panelChart,n,OBJPROP_TEXT,IntegerToString(m.day));
|
| color tc=!on?C'205,205,205':(inMon?clrBlack:C'140,140,140');
|
| color bg=(d==sel)?C'204,228,247':clrWhite;
|
| color bd=(d==sel)?C'0,120,215':((d==today)?clrCrimson:clrWhite);
|
| ObjectSetInteger(panelChart,n,OBJPROP_COLOR,tc);
|
| ObjectSetInteger(panelChart,n,OBJPROP_BGCOLOR,bg);
|
| ObjectSetInteger(panelChart,n,OBJPROP_BORDER_COLOR,bd);
|
| }
|
| }
|
| void CloseCal()
|
| {
|
| if(!calOpen) return;
|
| ObjectsDeleteAll(panelChart,P+"CAL_");
|
| calOpen=false;
|
| ChartRedraw(panelChart);
|
| }
|
| void PickDate(const datetime d)
|
| {
|
| if(calTarget==0){ selFrom=d; if(selTo<selFrom) selTo=selFrom; }
|
| else { selTo=d; if(selFrom>selTo) selFrom=selTo; }
|
| selDirty=true;
|
| ObjectSetString(panelChart,P+"FROM",OBJPROP_TEXT,TimeToString(selFrom,TIME_DATE));
|
| ObjectSetString(panelChart,P+"TO", OBJPROP_TEXT,TimeToString(selTo,TIME_DATE));
|
| lastMsg="Range set - press Play to apply | محدوده انتخاب شد، Play را بزنید";
|
| CloseCal();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Trades window: floating, draggable, resizable, MT5-like table |
|
| //+------------------------------------------------------------------+
|
| double twFr[10]={0.09,0.08,0.15,0.10,0.07,0.11,0.10,0.10,0.10,0.10};
|
|
|
| void TwReg(const string n,const int ox,const int oy)
|
| {
|
| if(twCnt>=600) return;
|
| twN[twCnt]=n; twOX[twCnt]=ox; twOY[twCnt]=oy; twCnt++;
|
| }
|
|
|
| void TwRect(const string id,const int ox,const int oy,const int w,const int h,const color bg,const color bd)
|
| {
|
| Rect(id,trX+ox,trY+oy,w,h,bg,bd,3000);
|
| TwReg(P+id,ox,oy);
|
| }
|
|
|
| void TwLbl(const string id,const string t,const int ox,const int oy,const color c,const int fs,const bool right,
|
| const string font="Segoe UI")
|
| {
|
| string n=P+id;
|
| ObjectCreate(panelChart,n,OBJ_LABEL,0,0,0);
|
| ObjectSetInteger(panelChart,n,OBJPROP_CORNER,CORNER_LEFT_UPPER);
|
| ObjectSetInteger(panelChart,n,OBJPROP_ANCHOR,right?ANCHOR_RIGHT_UPPER:ANCHOR_LEFT_UPPER);
|
| ObjectSetInteger(panelChart,n,OBJPROP_XDISTANCE,trX+ox);
|
| ObjectSetInteger(panelChart,n,OBJPROP_YDISTANCE,trY+oy);
|
| ObjectSetString(panelChart,n,OBJPROP_TEXT,(t=="")?" ":t); // empty text would show "Label"
|
| ObjectSetString(panelChart,n,OBJPROP_FONT,font);
|
| ObjectSetInteger(panelChart,n,OBJPROP_FONTSIZE,fs);
|
| ObjectSetInteger(panelChart,n,OBJPROP_COLOR,c);
|
| ObjectSetInteger(panelChart,n,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(panelChart,n,OBJPROP_ZORDER,0);
|
| TwReg(n,ox,oy);
|
| }
|
|
|
| void BuildTrades()
|
| {
|
| ObjectsDeleteAll(panelChart,P+"TW_");
|
| twCnt=0; trOpen=true;
|
| int cw=(int)ChartGetInteger(panelChart,CHART_WIDTH_IN_PIXELS);
|
| int ch=(int)ChartGetInteger(panelChart,CHART_HEIGHT_IN_PIXELS);
|
| trW=MathMax(600,MathMin(trW,cw-4)); trH=MathMax(160,MathMin(trH,ch-4));
|
| trX=MathMax(0,MathMin(trX,cw-trW)); trY=MathMax(0,MathMin(trY,ch-trH));
|
| twVis=MathMax(1,MathMin(TR_MAXROWS,(trH-TR_TITLE-TR_HEAD-TR_FOOT)/TR_ROWH));
|
| for(int i=0;i<500;i++){ twC[i]="~~"; twCC[i]=clrNONE; }
|
| for(int i=36;i<40;i++){ lcT[i]="~~"; lcC[i]=clrNONE; }
|
|
|
| TwRect("TW_BG",0,0,trW,trH,C'252,252,254',C'80,92,130');
|
| TwRect("TW_TBAR",1,1,trW-2,TR_TITLE-1,C'0,92,170',C'0,92,170');
|
| TwLbl("TW_TTL","Trades | معاملات",8,4,clrWhite,9,false,"Arial Bold");
|
| TwLbl("TW_XC","✕",trW-20,3,clrWhite,10,false);
|
| TwRect("TW_HD",1,TR_TITLE,trW-2,TR_HEAD,C'208,216,236',C'160,172,204');
|
|
|
| // bold, large, dark column titles
|
| string hd[10]={"Symbol","Ticket","Time","Type","Volume","Price","S / L","T / P","Price","Profit"};
|
| double tw=(double)(trW-2-30);
|
| double acc=1.0;
|
| double colR[10]; double colL[10];
|
| for(int c=0;c<10;c++){ colL[c]=acc; acc+=twFr[c]*tw; colR[c]=acc; }
|
| for(int c=0;c<10;c++)
|
| TwLbl("TW_H"+IntegerToString(c),hd[c],(int)(c<4?colL[c]+6:colR[c]-6),TR_TITLE+6,C'10,20,70',10,c>=4,"Arial Bold");
|
|
|
| for(int r=0;r<twVis;r++)
|
| {
|
| int yy=TR_TITLE+TR_HEAD+r*TR_ROWH;
|
| color bg=(r%2==0)?C'255,255,255':C'243,246,251';
|
| TwRect("TW_S"+IntegerToString(r),1,yy,trW-2,TR_ROWH,bg,bg);
|
| for(int c=0;c<10;c++)
|
| TwLbl("TW_C"+IntegerToString(r)+"_"+IntegerToString(c)," ",(int)(c<4?colL[c]+6:colR[c]-6),yy+3,C'30,36,60',9,c>=4);
|
| TwLbl("TW_C"+IntegerToString(r)+"_10"," ",trW-24,yy+2,C'200,40,40',10,false);
|
| }
|
|
|
| // footer: big bold Balance / Equity / Profit
|
| int fy=trH-TR_FOOT;
|
| TwRect("TW_FT",1,fy,trW-2,TR_FOOT-1,C'208,216,236',C'160,172,204');
|
| TwLbl("TW_FBK","Balance:",10,fy+8,C'40,50,90',10,false,"Arial Bold");
|
| TwLbl("TW_FBV"," ",84,fy+7,C'8,16,60',12,false,"Arial Bold");
|
| TwLbl("TW_FEK","Equity:",210,fy+8,C'40,50,90',10,false,"Arial Bold");
|
| TwLbl("TW_FEV"," ",272,fy+7,C'8,16,60',12,false,"Arial Bold");
|
| TwLbl("TW_FPK","Profit:",390,fy+8,C'40,50,90',10,false,"Arial Bold");
|
| TwLbl("TW_FPV"," ",446,fy+7,C'0,130,50',12,false,"Arial Bold");
|
| TwLbl("TW_UP","▲",trW-72,fy+8,C'70,80,115',10,false);
|
| TwLbl("TW_DN","▼",trW-46,fy+8,C'70,80,115',10,false);
|
| TwLbl("TW_GR","◢",trW-15,trH-17,C'110,120,150',9,false);
|
| }
|
|
|
| void TwSet(const int r,const int c,const string txt0,const color col)
|
| {
|
| int k=r*11+c;
|
| if(k>=500) return;
|
| string txt=(txt0=="")?" ":txt0; // never leave a label empty
|
| string n=P+"TW_C"+IntegerToString(r)+"_"+IntegerToString(c);
|
| if(twC[k]!=txt){ twC[k]=txt; ObjectSetString(panelChart,n,OBJPROP_TEXT,txt); }
|
| if(twCC[k]!=col){ twCC[k]=col; ObjectSetInteger(panelChart,n,OBJPROP_COLOR,col); }
|
| }
|
|
|
| void RefreshTrades()
|
| {
|
| if(!trOpen) return;
|
| twRows=0;
|
| for(int i=0;i<ArraySize(pos);i++) if(pos[i].open_ && twRows<800){ twKind[twRows]=0; twIdx[twRows]=i; twRows++; }
|
| for(int i=0;i<ArraySize(ords);i++) if(ords[i].live && twRows<800){ twKind[twRows]=1; twIdx[twRows]=i; twRows++; }
|
| trTop=MathMax(0,MathMin(trTop,MathMax(0,twRows-twVis)));
|
|
|
| const color TX=C'30,36,60', BUYC=C'0,90,200', SELLC=C'200,40,40', GRN=C'0,140,60', RED=C'200,40,40';
|
| for(int r=0;r<twVis;r++)
|
| {
|
| int row=trTop+r;
|
| if(row>=twRows){ for(int c=0;c<=10;c++) TwSet(r,c,"",TX); continue; }
|
| if(twKind[row]==0)
|
| {
|
| int i=twIdx[row];
|
| double pr=(pos[i].dir>0)?curBid:curAsk;
|
| double fl=CalcProfit(pos[i].dir,pos[i].open,pos[i].lots,pr);
|
| double ssl=pos[i].sl, stp=pos[i].tp;
|
| if(InpTradeMode==MODE_MARTINGALE){ ssl=basketTrailActive?basketSL:0; stp=basketTP; }
|
| TwSet(r,0,baseSym,TX);
|
| TwSet(r,1,IntegerToString((long)pos[i].ticket),TX);
|
| TwSet(r,2,TimeToString(pos[i].time,TIME_DATE|TIME_SECONDS),TX);
|
| TwSet(r,3,(pos[i].dir>0)?"buy":"sell",(pos[i].dir>0)?BUYC:SELLC);
|
| TwSet(r,4,DoubleToString(pos[i].lots,2),TX);
|
| TwSet(r,5,Px(pos[i].open),TX);
|
| TwSet(r,6,ssl>0?Px(ssl):"",TX);
|
| TwSet(r,7,stp>0?Px(stp):"",TX);
|
| TwSet(r,8,Px(pr),TX);
|
| TwSet(r,9,Money(fl),(fl>=0)?GRN:RED);
|
| TwSet(r,10,"✕",RED);
|
| }
|
| else
|
| {
|
| int i=twIdx[row];
|
| int t=ords[i].type;
|
| bool buy=(t==1||t==3);
|
| TwSet(r,0,baseSym,TX);
|
| TwSet(r,1,IntegerToString((long)ords[i].ticket),TX);
|
| TwSet(r,2,TimeToString(ords[i].time,TIME_DATE|TIME_SECONDS),TX);
|
| TwSet(r,3,OrdTypeName(t),buy?BUYC:SELLC);
|
| TwSet(r,4,DoubleToString(ords[i].lots,2),TX);
|
| TwSet(r,5,Px(ords[i].price),TX);
|
| TwSet(r,6,"",TX); TwSet(r,7,"",TX);
|
| TwSet(r,8,Px(buy?curAsk:curBid),TX);
|
| TwSet(r,9,"",TX);
|
| TwSet(r,10,"✕",RED);
|
| }
|
| }
|
|
|
| // footer values: large, bold, strong colours
|
| string vb=Money(bal), ve=Money(eq), vp=MoneyS(eq-bal);
|
| color pc=(eq-bal>=0)?C'0,130,50':C'200,30,30';
|
| if(lcT[36]!=vb){ lcT[36]=vb; ObjectSetString(panelChart,P+"TW_FBV",OBJPROP_TEXT,vb); }
|
| if(lcT[37]!=ve){ lcT[37]=ve; ObjectSetString(panelChart,P+"TW_FEV",OBJPROP_TEXT,ve); }
|
| if(lcT[38]!=vp){ lcT[38]=vp; ObjectSetString(panelChart,P+"TW_FPV",OBJPROP_TEXT,vp); }
|
| if(lcC[38]!=pc){ lcC[38]=pc; ObjectSetInteger(panelChart,P+"TW_FPV",OBJPROP_COLOR,pc); }
|
| }
|
|
|
| void OpenTrades()
|
| {
|
| trOpen=true;
|
| BuildTrades();
|
| RefreshTrades();
|
| ChartRedraw(panelChart);
|
| }
|
|
|
| void CloseTrades()
|
| {
|
| trOpen=false; trDrag=false; trSize=false;
|
| ObjectsDeleteAll(panelChart,P+"TW_");
|
| twCnt=0;
|
| ChartSetInteger(panelChart,CHART_MOUSE_SCROLL,true);
|
| ChartRedraw(panelChart);
|
| }
|
|
|
