Vigiar
1
0
Derivar
Você já tinha feito uma derivação do repositório PropNewsSpreadGuard, anteriormente
0
PropNewsSpreadGuard/PropNewsSpreadGuard.mq5
//+------------------------------------------------------------------+
//| PropNewsSpreadGuard.mq5 |
//| ForexNewsRadar |
//| https://www.mql5.com/en/users/forexnewsradar |
//+------------------------------------------------------------------+
#property copyright "ForexNewsRadar"
#property link "https://www.mql5.com/en/users/forexnewsradar"
#property version "1.00"
#property description "Standalone Prop-Firm Pre-News Blackout, Spread-Spike VETO & Pending-Order Guard EA."
#property description "Combines native MQL5 Economic Calendar countdowns, recurring macro blackout windows,"
#property description "EMA spread-widening detection, non-destructive pending-order cleanup, and RAM bridge."
#include <Trade\Trade.mqh>
//+------------------------------------------------------------------+
//| Enumerations |
//+------------------------------------------------------------------+
enum ENUM_GUARD_CORNER
{
GUARD_CORNER_TOP_RIGHT = 0, // Top-Right Chart Corner
GUARD_CORNER_TOP_LEFT = 1, // Top-Left Chart Corner
GUARD_CORNER_BOTTOM_RIGHT = 2, // Bottom-Right Chart Corner
GUARD_CORNER_BOTTOM_LEFT = 3 // Bottom-Left Chart Corner
};
enum ENUM_GUARD_STATUS
{
STATUS_SAFE_CLEAR = 0,
STATUS_PRE_NEWS = 1,
STATUS_POST_NEWS = 2,
STATUS_TIME_WINDOW = 3,
STATUS_SPREAD_VETO = 4
};
//+------------------------------------------------------------------+
//| Input Parameters |
//+------------------------------------------------------------------+
input group "=== 1. Prop-Firm News Blackout Rules ==="
input bool InpUseNativeCalendar = true; // Use Native MT5 Economic Calendar
input bool InpIncludeModerateNews = false; // Include Medium-Impact News (false = High Only)
input int InpPreNewsMinutes = 5; // Pre-News Blackout Window (Minutes, e.g. T-5m)
input int InpPostNewsMinutes = 5; // Post-News Cooldown Window (Minutes, e.g. T+5m)
input group "=== 2. Recurring Daily Macro Window Fallback (Server Time) ==="
input bool InpUseDailyWindowFallback = false; // Enable Recurring Daily Blackout Window
input int InpWindowStartHour = 15; // Daily Blackout Start Hour (0..23 Server Time)
input int InpWindowStartMinute = 25; // Daily Blackout Start Minute (0..59)
input int InpWindowDurationMinutes = 15; // Daily Blackout Duration (Minutes)
input group "=== 3. Spread-Spike & Liquidity Vacuum VETO ==="
input bool InpUseSpreadGuard = true; // Enable Live Spread-Spike VETO
input int InpMaxSpreadPoints = 35; // Hard Max Allowed Spread (Points, 0 = Disabled)
input double InpSpreadSpikeMultiplier = 2.20; // Dynamic Spike Multiplier vs Rolling EMA (0 = Off)
input int InpSpreadEmaSamples = 60; // Rolling Spread EMA Smoothing Samples
input group "=== 4. Pending-Order Sweeper & Cross-EA RAM Bridge ==="
input bool InpSweepPendingOnVeto = false; // Delete Pending Orders During Active VETO
input long InpTargetMagicNumber = -1; // Pending Order Magic Filter (-1 = All Magic Numbers)
input bool InpPublishGlobalVars = true; // Publish FNR_GUARD_SAFE_<SYMBOL> GlobalVariables
input bool InpSendPushNotifications = false; // Send MT5 Mobile Push Alert on VETO Transition
input group "=== 5. On-Chart Institutional HUD ==="
input bool InpShowHudPanel = true; // Render Non-Destructive On-Chart HUD Panel
input ENUM_GUARD_CORNER InpHudCorner = GUARD_CORNER_TOP_RIGHT;// HUD Anchor Corner
input int InpHudOffsetX = 16; // Horizontal Offset (Pixels)
input int InpHudOffsetY = 24; // Vertical Offset (Pixels)
//+------------------------------------------------------------------+
//| Constants & Global State |
//+------------------------------------------------------------------+
#define HUD_PREFIX "FNR_SG_"
double g_emaSpreadPts = 0.0;
bool g_emaInitialized = false;
ENUM_GUARD_STATUS g_currentStatus = STATUS_SAFE_CLEAR;
ENUM_GUARD_STATUS g_previousStatus = STATUS_SAFE_CLEAR;
string g_statusDetail = "All 4 Prop Risk Checks Clear";
string g_nextEventLabel = "None in next 24h";
int g_nextEventSec = -1;
int g_vetoRemainingSec = 0;
ulong g_sweptOrdersCount = 0;
datetime g_lastCalendarCheck = 0;
bool g_calendarAvailable = false;
struct CachedNewsWindow
{
datetime eventTime;
string currency;
string eventName;
bool isHighImpact;
};
CachedNewsWindow g_cachedEvents[];
//+------------------------------------------------------------------+
//| Clean Currency Code Helper |
//+------------------------------------------------------------------+
string CleanCurrencyCode(const string rawCode)
{
string code = rawCode;
StringTrimLeft(code);
StringTrimRight(code);
StringToUpper(code);
return code;
}
//+------------------------------------------------------------------+
//| Resolve Relevant Currencies for Current Symbol |
//+------------------------------------------------------------------+
void ResolveSymbolCurrencies(string &baseCcy, string &profitCcy)
{
baseCcy = CleanCurrencyCode(SymbolInfoString(_Symbol, SYMBOL_CURRENCY_BASE));
profitCcy = CleanCurrencyCode(SymbolInfoString(_Symbol, SYMBOL_CURRENCY_PROFIT));
string upSym = _Symbol;
StringToUpper(upSym);
if(StringFind(upSym, "XAU") >= 0 || StringFind(upSym, "GOLD") >= 0 ||
StringFind(upSym, "XAG") >= 0 || StringFind(upSym, "SILVER") >= 0)
{
if(profitCcy == "" || profitCcy == "XAU" || profitCcy == "XAG")
profitCcy = "USD";
}
}
//+------------------------------------------------------------------+
//| Refresh Native MQL5 Calendar Cache (Once per 60s) |
//+------------------------------------------------------------------+
void RefreshCalendarCache()
{
ArrayResize(g_cachedEvents, 0);
g_calendarAvailable = false;
if(!InpUseNativeCalendar || (bool)MQLInfoInteger(MQL_TESTER))
return;
datetime nowSrv = TimeTradeServer();
if(nowSrv <= 0)
nowSrv = TimeCurrent();
datetime fromTime = nowSrv - (datetime)(MathMax(InpPostNewsMinutes, 10) * 60 + 300);
datetime toTime = nowSrv + 86400;
string baseCcy = "", profitCcy = "";
ResolveSymbolCurrencies(baseCcy, profitCcy);
MqlCalendarValue values[];
ResetLastError();
int count = CalendarValueHistory(values, fromTime, toTime, NULL, NULL);
if(count <= 0)
return;
g_calendarAvailable = true;
for(int i = 0; i < count; i++)
{
MqlCalendarEvent ev;
if(!CalendarEventById(values[i].event_id, ev))
continue;
bool isHigh = (ev.importance == CALENDAR_IMPORTANCE_HIGH);
bool isMod = (ev.importance == CALENDAR_IMPORTANCE_MODERATE);
if(!isHigh && !(InpIncludeModerateNews && isMod))
continue;
MqlCalendarCountry country;
if(!CalendarCountryById(ev.country_id, country))
continue;
string evCcy = CleanCurrencyCode(country.currency);
if(evCcy == "")
continue;
if(evCcy != baseCcy && evCcy != profitCcy)
continue;
int idx = ArraySize(g_cachedEvents);
ArrayResize(g_cachedEvents, idx + 1, 32);
g_cachedEvents[idx].eventTime = values[i].time;
g_cachedEvents[idx].currency = evCcy;
g_cachedEvents[idx].eventName = ev.name;
g_cachedEvents[idx].isHighImpact = isHigh;
}
}
//+------------------------------------------------------------------+
//| Format Seconds into Compact Human Countdown |
//+------------------------------------------------------------------+
string FormatDurationCompact(const int totalSec)
{
if(totalSec <= 0)
return "0s";
int hrs = totalSec / 3600;
int mins = (totalSec % 3600) / 60;
int secs = totalSec % 60;
if(hrs > 0)
return IntegerToString(hrs) + "h " + IntegerToString(mins) + "m";
if(mins > 0)
return IntegerToString(mins) + "m " + IntegerToString(secs) + "s";
return IntegerToString(secs) + "s";
}
//+------------------------------------------------------------------+
//| Evaluate Active Risk State |
//+------------------------------------------------------------------+
void EvaluateGuardState()
{
datetime nowSrv = TimeTradeServer();
if(nowSrv <= 0)
nowSrv = TimeCurrent();
// 1. Refresh calendar cache every 60 seconds outside Strategy Tester
if(InpUseNativeCalendar && !(bool)MQLInfoInteger(MQL_TESTER))
{
if(g_lastCalendarCheck == 0 || (nowSrv - g_lastCalendarCheck) >= 60)
{
RefreshCalendarCache();
g_lastCalendarCheck = nowSrv;
}
}
// 2. Update live spread & rolling EMA baseline
long rawSpread = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);
double curSpread = (rawSpread > 0) ? (double)rawSpread : 0.0;
int samples = MathMax(5, InpSpreadEmaSamples);
double alpha = 2.0 / ((double)samples + 1.0);
if(!g_emaInitialized || g_emaSpreadPts <= 0.0)
{
if(curSpread > 0.0)
{
g_emaSpreadPts = curSpread;
g_emaInitialized = true;
}
}
else if(curSpread > 0.0 && g_currentStatus == STATUS_SAFE_CLEAR)
{
// Update baseline EMA only during calm periods so news spikes do not pollute baseline
g_emaSpreadPts = curSpread * alpha + g_emaSpreadPts * (1.0 - alpha);
}
ENUM_GUARD_STATUS resolvedStatus = STATUS_SAFE_CLEAR;
string resolvedDetail = "All Prop-Firm Risk Checks Clear";
int resolvedWait = 0;
// 3. Evaluate Native Calendar Windows
g_nextEventSec = -1;
g_nextEventLabel = (InpUseNativeCalendar && !g_calendarAvailable && !(bool)MQLInfoInteger(MQL_TESTER))
? "Broker Calendar Empty/Off"
: "No High-Impact in 24h";
int preSec = MathMax(0, InpPreNewsMinutes) * 60;
int postSec = MathMax(0, InpPostNewsMinutes) * 60;
int totalEv = ArraySize(g_cachedEvents);
for(int i = 0; i < totalEv; i++)
{
int deltaSec = (int)(g_cachedEvents[i].eventTime - nowSrv);
// Track nearest upcoming catalyst
if(deltaSec > 0 && (g_nextEventSec < 0 || deltaSec < g_nextEventSec))
{
g_nextEventSec = deltaSec;
string shortTitle = g_cachedEvents[i].eventName;
if(StringLen(shortTitle) > 24)
shortTitle = StringSubstr(shortTitle, 0, 22) + "..";
g_nextEventLabel = g_cachedEvents[i].currency + " " + shortTitle + " in " + FormatDurationCompact(deltaSec);
}
// Check Pre-News Blackout [eventTime - preSec .. eventTime]
if(deltaSec >= 0 && deltaSec <= preSec && preSec > 0)
{
resolvedStatus = STATUS_PRE_NEWS;
resolvedWait = deltaSec + postSec;
resolvedDetail = "PRE-NEWS HOLD: " + g_cachedEvents[i].currency + " in " + FormatDurationCompact(deltaSec);
break;
}
// Check Post-News Cooldown [eventTime .. eventTime + postSec]
if(deltaSec < 0 && (-deltaSec) <= postSec && postSec > 0)
{
int rem = postSec - (-deltaSec);
resolvedStatus = STATUS_POST_NEWS;
resolvedWait = rem;
resolvedDetail = "POST-NEWS VETO: Cooldown " + FormatDurationCompact(rem);
break;
}
}
// 4. Evaluate Recurring Daily Time Window Fallback (when enabled)
if(resolvedStatus == STATUS_SAFE_CLEAR && InpUseDailyWindowFallback && InpWindowDurationMinutes > 0)
{
MqlDateTime dt;
TimeToStruct(nowSrv, dt);
int curMinOfDay = dt.hour * 60 + dt.min;
int startMinOfDay = (MathMax(0, MathMin(23, InpWindowStartHour)) * 60) + MathMax(0, MathMin(59, InpWindowStartMinute));
int durMin = MathMin(720, MathMax(1, InpWindowDurationMinutes));
int diffMin = curMinOfDay - startMinOfDay;
if(diffMin < 0)
diffMin += 1440;
if(diffMin >= 0 && diffMin < durMin)
{
int remSec = (durMin - diffMin) * 60 - dt.sec;
if(remSec < 1)
remSec = 1;
resolvedStatus = STATUS_TIME_WINDOW;
resolvedWait = remSec;
resolvedDetail = "SCHEDULED BLACKOUT: " + FormatDurationCompact(remSec) + " left";
}
}
// 5. Evaluate Spread-Spike & Liquidity Vacuum Guard
if(resolvedStatus == STATUS_SAFE_CLEAR && InpUseSpreadGuard && curSpread > 0.0)
{
bool hardBreach = (InpMaxSpreadPoints > 0 && curSpread > (double)InpMaxSpreadPoints);
bool emaBreach = (InpSpreadSpikeMultiplier > 1.0 && g_emaSpreadPts >= 1.0 &&
curSpread >= (g_emaSpreadPts * InpSpreadSpikeMultiplier) &&
curSpread >= 5.0);
if(hardBreach || emaBreach)
{
resolvedStatus = STATUS_SPREAD_VETO;
resolvedWait = 15;
resolvedDetail = "SPREAD VETO: " + IntegerToString((int)curSpread) + " pts (EMA " +
DoubleToString(g_emaSpreadPts, 1) + " pts)";
}
}
g_currentStatus = resolvedStatus;
g_statusDetail = resolvedDetail;
g_vetoRemainingSec = resolvedWait;
}
//+------------------------------------------------------------------+
//| Publish Cross-EA Safety Flag to Terminal RAM |
//+------------------------------------------------------------------+
void PublishRamBridge()
{
if(!InpPublishGlobalVars)
return;
string keySafe = "FNR_GUARD_SAFE_" + _Symbol;
string keyWait = "FNR_GUARD_WAIT_" + _Symbol;
if(!GlobalVariableCheck(keySafe))
GlobalVariableTemp(keySafe);
if(!GlobalVariableCheck(keyWait))
GlobalVariableTemp(keyWait);
double isSafe = (g_currentStatus == STATUS_SAFE_CLEAR) ? 1.0 : 0.0;
GlobalVariableSet(keySafe, isSafe);
GlobalVariableSet(keyWait, (double)g_vetoRemainingSec);
}
//+------------------------------------------------------------------+
//| Safely Sweep Unexecuted Pending Orders on Current Symbol |
//+------------------------------------------------------------------+
void SweepPendingOrdersIfRequired()
{
if(!InpSweepPendingOnVeto || g_currentStatus == STATUS_SAFE_CLEAR)
return;
if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) ||
!MQLInfoInteger(MQL_TRADE_ALLOWED) ||
!AccountInfoInteger(ACCOUNT_TRADE_EXPERT))
return;
ENUM_SYMBOL_TRADE_MODE tradeMode = (ENUM_SYMBOL_TRADE_MODE)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_MODE);
if(tradeMode == SYMBOL_TRADE_MODE_DISABLED)
return;
long freezePts = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_FREEZE_LEVEL);
double pointVal = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
CTrade trade;
trade.SetAsyncMode(false);
int total = OrdersTotal();
for(int i = total - 1; i >= 0; i--)
{
ulong ticket = OrderGetTicket(i);
if(ticket == 0)
continue;
if(OrderGetString(ORDER_SYMBOL) != _Symbol)
continue;
if(InpTargetMagicNumber >= 0 && OrderGetInteger(ORDER_MAGIC) != InpTargetMagicNumber)
continue;
ENUM_ORDER_TYPE ordType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
bool isPending = (ordType == ORDER_TYPE_BUY_LIMIT ||
ordType == ORDER_TYPE_SELL_LIMIT ||
ordType == ORDER_TYPE_BUY_STOP ||
ordType == ORDER_TYPE_SELL_STOP ||
ordType == ORDER_TYPE_BUY_STOP_LIMIT ||
ordType == ORDER_TYPE_SELL_STOP_LIMIT);
if(!isPending)
continue;
// Respect broker freeze level before attempting deletion
if(freezePts > 0 && pointVal > 0.0 && bid > 0.0 && ask > 0.0)
{
double openPrice = OrderGetDouble(ORDER_PRICE_OPEN);
double refPrice = (ordType == ORDER_TYPE_BUY_LIMIT || ordType == ORDER_TYPE_BUY_STOP || ordType == ORDER_TYPE_BUY_STOP_LIMIT)
? ask : bid;
double distPts = MathAbs(openPrice - refPrice) / pointVal;
if(distPts <= (double)freezePts)
continue;
}
ResetLastError();
if(trade.OrderDelete(ticket))
{
g_sweptOrdersCount++;
Print("PropNewsSpreadGuard: Removed pending order #", ticket, " on ", _Symbol, " (", g_statusDetail, ")");
}
}
}
//+------------------------------------------------------------------+
//| Resolve Base Chart Corner |
//+------------------------------------------------------------------+
ENUM_BASE_CORNER ResolveBaseCorner()
{
switch(InpHudCorner)
{
case GUARD_CORNER_TOP_LEFT: return CORNER_LEFT_UPPER;
case GUARD_CORNER_BOTTOM_RIGHT: return CORNER_RIGHT_LOWER;
case GUARD_CORNER_BOTTOM_LEFT: return CORNER_LEFT_LOWER;
default: return CORNER_RIGHT_UPPER;
}
}
//+------------------------------------------------------------------+
//| Create or Update Single HUD Text Row |
//+------------------------------------------------------------------+
void UpsertHudLabel(const string name,
const ENUM_BASE_CORNER corner,
const int xDist,
const int yDist,
const string text,
const color clr,
const int fontSize,
const bool isBold)
{
if(ObjectFind(0, name) < 0)
{
if(!ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0))
return;
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, name, OBJPROP_BACK, false);
}
ObjectSetInteger(0, name, OBJPROP_CORNER, corner);
ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_UPPER);
ObjectSetInteger(0, name, OBJPROP_XDISTANCE, xDist);
ObjectSetInteger(0, name, OBJPROP_YDISTANCE, yDist);
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, fontSize);
ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
ObjectSetString(0, name, OBJPROP_FONT, isBold ? "Trebuchet MS Bold" : "Consolas");
ObjectSetString(0, name, OBJPROP_TEXT, text);
}
//+------------------------------------------------------------------+
//| Render Non-Destructive Institutional HUD Card |
//+------------------------------------------------------------------+
void RenderHudPanel()
{
if(!InpShowHudPanel || ((bool)MQLInfoInteger(MQL_TESTER) && !(bool)MQLInfoInteger(MQL_VISUAL_MODE)))
return;
ENUM_BASE_CORNER corner = ResolveBaseCorner();
int cardW = 308;
int cardH = 104;
int boxX = InpHudOffsetX;
int boxY = InpHudOffsetY;
// In right-hand corners, OBJ_RECTANGLE_LABEL XDISTANCE is distance from right edge to left edge of rectangle
if(corner == CORNER_RIGHT_UPPER || corner == CORNER_RIGHT_LOWER)
boxX = InpHudOffsetX + cardW;
if(corner == CORNER_LEFT_LOWER || corner == CORNER_RIGHT_LOWER)
boxY = InpHudOffsetY + cardH;
string bgName = HUD_PREFIX + "BG";
string accentName = HUD_PREFIX + "ACCENT";
bool isSafe = (g_currentStatus == STATUS_SAFE_CLEAR);
color borderClr = isSafe ? C'24,78,58' : (g_currentStatus == STATUS_PRE_NEWS ? C'146,92,18' : C'136,34,42');
color badgeClr = isSafe ? C'52,211,153' : (g_currentStatus == STATUS_PRE_NEWS ? C'251,191,36' : C'248,113,113');
if(ObjectFind(0, bgName) < 0)
{
if(ObjectCreate(0, bgName, OBJ_RECTANGLE_LABEL, 0, 0, 0))
{
ObjectSetInteger(0, bgName, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, bgName, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, bgName, OBJPROP_BACK, false);
}
}
ObjectSetInteger(0, bgName, OBJPROP_CORNER, corner);
ObjectSetInteger(0, bgName, OBJPROP_XDISTANCE, boxX);
ObjectSetInteger(0, bgName, OBJPROP_YDISTANCE, boxY);
ObjectSetInteger(0, bgName, OBJPROP_XSIZE, cardW);
ObjectSetInteger(0, bgName, OBJPROP_YSIZE, cardH);
ObjectSetInteger(0, bgName, OBJPROP_BGCOLOR, C'11,14,20');
ObjectSetInteger(0, bgName, OBJPROP_BORDER_TYPE, BORDER_FLAT);
ObjectSetInteger(0, bgName, OBJPROP_COLOR, borderClr);
ObjectSetInteger(0, bgName, OBJPROP_WIDTH, 1);
if(ObjectFind(0, accentName) < 0)
{
if(ObjectCreate(0, accentName, OBJ_RECTANGLE_LABEL, 0, 0, 0))
{
ObjectSetInteger(0, accentName, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, accentName, OBJPROP_HIDDEN, true);
ObjectSetInteger(0, accentName, OBJPROP_BACK, false);
}
}
ObjectSetInteger(0, accentName, OBJPROP_CORNER, corner);
ObjectSetInteger(0, accentName, OBJPROP_XDISTANCE, boxX);
ObjectSetInteger(0, accentName, OBJPROP_YDISTANCE, boxY);
ObjectSetInteger(0, accentName, OBJPROP_XSIZE, 4);
ObjectSetInteger(0, accentName, OBJPROP_YSIZE, cardH);
ObjectSetInteger(0, accentName, OBJPROP_BGCOLOR, badgeClr);
ObjectSetInteger(0, accentName, OBJPROP_BORDER_TYPE, BORDER_FLAT);
ObjectSetInteger(0, accentName, OBJPROP_COLOR, badgeClr);
int textX = (corner == CORNER_RIGHT_UPPER || corner == CORNER_RIGHT_LOWER) ? (boxX - 12) : (boxX + 12);
int topY = (corner == CORNER_LEFT_LOWER || corner == CORNER_RIGHT_LOWER) ? (boxY - 10) : (boxY + 10);
int stepY = (corner == CORNER_LEFT_LOWER || corner == CORNER_RIGHT_LOWER) ? -21 : 21;
string titleLine = _Symbol + " | " + (isSafe ? "PROP SAFE - CLEAR" : "VETO - DO NOT ENTER");
long curSpr = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);
string sprLine = "Spread: " + IntegerToString((int)curSpr) + " pts (EMA " + DoubleToString(g_emaSpreadPts, 1) +
(InpMaxSpreadPoints > 0 ? " / Max " + IntegerToString(InpMaxSpreadPoints) : "") + ")";
string catLine = "Next: " + g_nextEventLabel;
string sweepLine = "Pending Guard: " + (InpSweepPendingOnVeto ? "ARMED" : "MONITOR") +
" | Swept: " + IntegerToString((int)g_sweptOrdersCount);
UpsertHudLabel(HUD_PREFIX + "L1", corner, textX, topY, titleLine, badgeClr, 9, true);
UpsertHudLabel(HUD_PREFIX + "L2", corner, textX, topY + stepY, g_statusDetail, C'226,232,240', 8, false);
UpsertHudLabel(HUD_PREFIX + "L3", corner, textX, topY + stepY * 2, sprLine, C'148,163,184', 8, false);
UpsertHudLabel(HUD_PREFIX + "L4", corner, textX, topY + stepY * 3, (isSafe ? catLine : sweepLine), C'148,163,184', 8, false);
ChartRedraw(0);
}
//+------------------------------------------------------------------+
//| Remove All HUD Objects Created by This EA |
//+------------------------------------------------------------------+
void CleanupHudObjects()
{
ObjectsDeleteAll(0, HUD_PREFIX);
ChartRedraw(0);
}
//+------------------------------------------------------------------+
//| Core Execution Cycle |
//+------------------------------------------------------------------+
void RunGuardCycle()
{
EvaluateGuardState();
PublishRamBridge();
SweepPendingOrdersIfRequired();
if(g_currentStatus != g_previousStatus)
{
if(InpSendPushNotifications && g_currentStatus != STATUS_SAFE_CLEAR && !(bool)MQLInfoInteger(MQL_TESTER))
SendNotification("PropNewsSpreadGuard [" + _Symbol + "]: " + g_statusDetail);
g_previousStatus = g_currentStatus;
}
RenderHudPanel();
}
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
if(InpPreNewsMinutes < 0 || InpPostNewsMinutes < 0)
{
Print("PropNewsSpreadGuard: Pre/Post news minutes must be non-negative.");
return INIT_PARAMETERS_INCORRECT;
}
g_lastCalendarCheck = 0;
EventSetTimer(1);
RunGuardCycle();
return INIT_SUCCEEDED;
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
EventKillTimer();
CleanupHudObjects();
}
//+------------------------------------------------------------------+
//| Timer event handler |
//+------------------------------------------------------------------+
void OnTimer()
{
RunGuardCycle();
}
//+------------------------------------------------------------------+
//| Tick event handler |
//+------------------------------------------------------------------+
void OnTick()
{
RunGuardCycle();
}
//+------------------------------------------------------------------+
//| TradeTransaction handler (instant intercept for .ex5 orders) |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
const MqlTradeRequest &request,
const MqlTradeResult &result)
{
if(trans.type == TRADE_TRANSACTION_ORDER_ADD && InpSweepPendingOnVeto && g_currentStatus != STATUS_SAFE_CLEAR)
SweepPendingOrdersIfRequired();
}
//+------------------------------------------------------------------+