| //+------------------------------------------------------------------+
|
| //| ICTMacros.mq5 |
|
| //| Copyright 2026, MT5 Coder Project |
|
| //+------------------------------------------------------------------+
|
| // WHAT IT DOES
|
| // Marks ICT macro windows as chart objects (rectangle, plus optional
|
| // 50% midline, start/end vertical lines and a label) for the Asia,
|
| // London and New York sessions. Every session has its own ON/OFF input.
|
| //
|
| // Window times are entered in NEW YORK local time as
|
| // "HH:MM-HH:MM;HH:MM-HH:MM". Defaults:
|
| // London : 02:33-03:00;04:03-04:30
|
| // New York: 08:50-09:10;09:50-10:10;10:50-11:10;11:50-12:10;13:10-13:40;15:15-15:45
|
| // Asia : empty by default - paste Asia windows into InpAsiaMacros and
|
| // the Asia toggle starts working immediately.
|
| // A window whose end time is not later than its start time is treated as
|
| // crossing midnight (e.g. 23:30-00:15).
|
| //
|
| // TIME BASE
|
| // Chart bars are in broker server time. Window times are converted
|
| // NY local -> UTC (US DST rules implemented here) -> server time.
|
| // The server/UTC offset is auto-detected as TimeTradeServer()-TimeGMT()
|
| // rounded to 5 minutes, or taken from InpManualServerGmtOffset.
|
| // TimeGMT() depends on the accuracy of the local PC clock; switch to
|
| // ICT_SRV_MANUAL if that clock is not reliable.
|
| //
|
| // OBJECTS
|
| // Prefix "ICTMacros_". Only objects created by this program are removed.
|
| // Windows on closed bars never move. The window that is currently open is
|
| // refreshed while it is open (InpLiveBox). Windows whose bars do not exist
|
| // yet are not drawn, so a later window of the day appears once its first
|
| // bar has formed.
|
| //
|
| // LIMITATIONS
|
| // * Chart objects only - no indicator buffers, nothing for iCustom.
|
| // * MT5 chart objects have no alpha transparency: a filled box is opaque
|
| // (it is drawn behind the bars). Outline only is the default.
|
| // * Best on M1-M15. On coarse timeframes a window can cover 0 or 1 bar.
|
| // * Object count grows with InpHistoryDays - watch InpMaxObjects.
|
| // * Visual tool only: it draws no signals and does not trade.
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2026, MT5 Coder Project"
|
| #property link "https://www.mql5.com"
|
| #property version "1.00"
|
| #property description "ICT macro windows (Asia / London / New York) drawn in New York local time."
|
|
|
| #property indicator_chart_window
|
| #property indicator_buffers 0
|
| #property indicator_plots 0
|
|
|
| //--- object namespace owned by this program
|
| #define ICT_PREFIX "ICTMacros_"
|
| #define ICT_SEC_PER_DAY 86400
|
| #define ICT_MIN_PER_DAY 1440
|
|
|
| //--- enums
|
| enum ENUM_ICT_TIMEBASE { ICT_TB_NEWYORK = 0, ICT_TB_SERVER = 1, ICT_TB_GMT = 2 };
|
| enum ENUM_ICT_SRVOFF { ICT_SRV_AUTO = 0, ICT_SRV_MANUAL = 1 };
|
| enum ENUM_ICT_SESSION { ICT_ASIA = 0, ICT_LONDON = 1, ICT_NEWYORK = 2 };
|
|
|
| //--- inputs
|
| input group "Sessions"
|
| input bool InpShowAsia = true; // Draw Asia macros
|
| input bool InpShowLondon = true; // Draw London macros
|
| input bool InpShowNewYork = true; // Draw New York macros
|
|
|
| input group "Macro windows (New York local time, format HH:MM-HH:MM;...)"
|
| input string InpAsiaMacros = ""; // Asia windows (empty = none)
|
| input string InpLondonMacros = "02:33-03:00;04:03-04:30";
|
| input string InpNYMacros = "08:50-09:10;09:50-10:10;10:50-11:10;11:50-12:10;13:10-13:40;15:15-15:45";
|
|
|
| input group "Time base"
|
| input ENUM_ICT_TIMEBASE InpTimeBase = ICT_TB_NEWYORK; // Reference zone of the windows above
|
| input ENUM_ICT_SRVOFF InpServerOffsetMode = ICT_SRV_AUTO; // Broker server offset detection
|
| input double InpManualServerGmtOffset = 0.0; // Server GMT offset in hours (manual mode)
|
|
|
| input group "Display"
|
| input bool InpDrawBox = true; // Draw the macro box
|
| input bool InpFillBox = false; // Fill the box (opaque, drawn behind the bars)
|
| input bool InpMidline = false; // Draw the 50% midline of the window
|
| input bool InpVerticalLines = true; // Draw vertical lines at window start/end
|
| input bool InpShowLabels = true; // Draw the window label
|
| input int InpLabelFontSize = 8; // Label font size
|
| input color InpAsiaColor = clrKhaki;
|
| input color InpLondonColor = clrSteelBlue;
|
| input color InpNewYorkColor = clrTomato;
|
| input bool InpLiveBox = true; // Refresh the window that is currently open
|
|
|
| input group "History / limits"
|
| input int InpHistoryDays = 20; // Past days to draw (0 = current day only)
|
| input int InpMaxObjects = 2000; // Safety cap of objects per rebuild
|
| input bool InpCleanStaleObjects = true; // Remove leftover ICTMacros_ objects of former runs
|
|
|
| input group "Diagnostics"
|
| input bool InpVerboseLog = true; // Print time base / offset / object diagnostics
|
|
|
| //--- one macro window (times are minutes from midnight in the reference zone)
|
| struct MacroWindow
|
| {
|
| int session; // ENUM_ICT_SESSION
|
| int index; // 1-based index inside the session
|
| int startMin; // start, minutes from midnight
|
| int endMin; // end, minutes from midnight (may exceed 1440 when crossing midnight)
|
| string label; // display label, e.g. "London 02:33-03:00"
|
| };
|
|
|
| //--- state
|
| MacroWindow g_win[]; // parsed windows of all enabled session lists
|
| int g_winCount = 0;
|
| string g_names[]; // objects of the current rebuild
|
| int g_nameCount = 0;
|
| string g_prevNames[]; // objects of the previous rebuild (stale-object diff)
|
| int g_prevCount = 0;
|
| datetime g_lastBarTime = 0;
|
| int g_srvOffsetSec = 0; // broker server UTC offset in seconds
|
| double g_liveHi = 0.0;
|
| double g_liveLo = 0.0;
|
| bool g_loggedSummary = false;
|
| bool g_capWarned = false;
|
| bool g_orphanSwept = false;
|
|
|
| //+------------------------------------------------------------------+
|
| //| Small text helpers |
|
| //+------------------------------------------------------------------+
|
| string Trim(const string src)
|
| {
|
| string s = src;
|
| StringTrimLeft(s);
|
| StringTrimRight(s);
|
| return s;
|
| }
|
|
|
| bool AllDigits(const string s)
|
| {
|
| const int n = StringLen(s);
|
| if(n == 0)
|
| return false;
|
| for(int i = 0; i < n; i++)
|
| {
|
| const ushort c = StringGetCharacter(s, i);
|
| if(c < 48 || c > 57) // '0' .. '9'
|
| return false;
|
| }
|
| return true;
|
| }
|
|
|
| //| Parse "HH:MM" into minutes from midnight. |
|
| bool ParseHHMM(const string src, int &minutes)
|
| {
|
| const string t = Trim(src);
|
| string hm[];
|
| if(StringSplit(t, ':', hm) != 2)
|
| return false;
|
| const string hs = Trim(hm[0]);
|
| const string ms = Trim(hm[1]);
|
| if(!AllDigits(hs) || !AllDigits(ms))
|
| return false;
|
| const int h = (int)StringToInteger(hs);
|
| const int m = (int)StringToInteger(ms);
|
| if(h < 0 || h > 23 || m < 0 || m > 59)
|
| return false;
|
| minutes = h * 60 + m;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Session helpers |
|
| //+------------------------------------------------------------------+
|
| string SessionTag(const int session)
|
| {
|
| switch(session)
|
| {
|
| case ICT_ASIA: return "Asia";
|
| case ICT_LONDON: return "London";
|
| case ICT_NEWYORK: return "NY";
|
| }
|
| return "Sess";
|
| }
|
|
|
| string SessionLabel(const int session)
|
| {
|
| switch(session)
|
| {
|
| case ICT_ASIA: return "Asia";
|
| case ICT_LONDON: return "London";
|
| case ICT_NEWYORK: return "New York";
|
| }
|
| return "Session";
|
| }
|
|
|
| color SessionColor(const int session)
|
| {
|
| switch(session)
|
| {
|
| case ICT_ASIA: return InpAsiaColor;
|
| case ICT_LONDON: return InpLondonColor;
|
| case ICT_NEWYORK: return InpNewYorkColor;
|
| }
|
| return clrGray;
|
| }
|
|
|
| bool SessionEnabled(const int session)
|
| {
|
| switch(session)
|
| {
|
| case ICT_ASIA: return InpShowAsia;
|
| case ICT_LONDON: return InpShowLondon;
|
| case ICT_NEWYORK: return InpShowNewYork;
|
| }
|
| return false;
|
| }
|
|
|
| string TimeBaseName(const ENUM_ICT_TIMEBASE tb)
|
| {
|
| switch(tb)
|
| {
|
| case ICT_TB_NEWYORK: return "NewYork";
|
| case ICT_TB_SERVER: return "Server";
|
| case ICT_TB_GMT: return "GMT";
|
| }
|
| return "Unknown";
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Parse one session window list, appending to dst. |
|
| //| Returns the number of windows added. Invalid tokens are skipped |
|
| //| with a diagnostic instead of aborting the whole list. |
|
| //+------------------------------------------------------------------+
|
| int ParseWindowList(const string src, const int session, MacroWindow &dst[])
|
| {
|
| if(StringLen(Trim(src)) == 0)
|
| return 0;
|
|
|
| int added = 0;
|
| string parts[];
|
| const int count = StringSplit(src, ';', parts);
|
| for(int i = 0; i < count; i++)
|
| {
|
| const string token = Trim(parts[i]);
|
| if(token == "")
|
| continue;
|
|
|
| string range[];
|
| if(StringSplit(token, '-', range) != 2)
|
| {
|
| PrintFormat("ICTMacros: skipped window '%s' - expected HH:MM-HH:MM", token);
|
| continue;
|
| }
|
|
|
| int startMin = 0, endMin = 0;
|
| if(!ParseHHMM(range[0], startMin) || !ParseHHMM(range[1], endMin))
|
| {
|
| PrintFormat("ICTMacros: skipped window '%s' - invalid time", token);
|
| continue;
|
| }
|
| if(endMin == startMin)
|
| {
|
| PrintFormat("ICTMacros: skipped window '%s' - zero length", token);
|
| continue;
|
| }
|
|
|
| const int n = ArraySize(dst);
|
| if(ArrayResize(dst, n + 1) != n + 1)
|
| {
|
| Print("ICTMacros: out of memory while parsing macro windows");
|
| break;
|
| }
|
| dst[n].session = session;
|
| dst[n].index = added + 1;
|
| dst[n].startMin = startMin;
|
| dst[n].endMin = (endMin < startMin) ? endMin + ICT_MIN_PER_DAY : endMin;
|
| dst[n].label = StringFormat("%s %02d:%02d-%02d:%02d",
|
| SessionLabel(session),
|
| startMin / 60, startMin % 60,
|
| endMin / 60, endMin % 60);
|
| added++;
|
| }
|
| return added;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| America/New_York DST rules |
|
| //| DST starts 02:00 local (07:00 UTC) on the 2nd Sunday of March, |
|
| //| DST ends 02:00 local (06:00 UTC) on the 1st Sunday of November|
|
| //+------------------------------------------------------------------+
|
| datetime NthSundayUtc(const int year, const int month, const int nth, const int hourUtc)
|
| {
|
| MqlDateTime d;
|
| d.year = year; d.mon = month; d.day = 1; d.hour = hourUtc;
|
| d.min = 0; d.sec = 0; d.day_of_week = 0; d.day_of_year = 0;
|
| const datetime first = StructToTime(d);
|
|
|
| MqlDateTime f;
|
| TimeToStruct(first, f);
|
| const int dow = f.day_of_week; // 0 = Sunday
|
| const int offsetDays = ((7 - dow) % 7) + (nth - 1) * 7;
|
| return (datetime)((long)first + (long)offsetDays * ICT_SEC_PER_DAY);
|
| }
|
|
|
| bool IsUsDst(const datetime utc)
|
| {
|
| MqlDateTime d;
|
| TimeToStruct(utc, d);
|
| const datetime dstStart = NthSundayUtc(d.year, 3, 2, 7);
|
| const datetime dstEnd = NthSundayUtc(d.year, 11, 1, 6);
|
| return (utc >= dstStart && utc < dstEnd);
|
| }
|
|
|
| //| NY local = UTC + offset (EDT -4h, EST -5h) |
|
| int NyUtcOffsetSec(const datetime utc)
|
| {
|
| return IsUsDst(utc) ? -4 * 3600 : -5 * 3600;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Time conversion helpers |
|
| //+------------------------------------------------------------------+
|
| datetime DayStart(const datetime t)
|
| {
|
| return (datetime)((long)t - (long)((long)t % ICT_SEC_PER_DAY));
|
| }
|
|
|
| datetime MakeNaiveDay(const int year, const int month, const int day)
|
| {
|
| MqlDateTime d;
|
| d.year = year; d.mon = month; d.day = day;
|
| d.hour = 0; d.min = 0; d.sec = 0; d.day_of_week = 0; d.day_of_year = 0;
|
| return StructToTime(d);
|
| }
|
|
|
| //| Convert a window boundary (minutes from midnight of refDay in the |
|
| //| reference zone) into broker server time. |
|
| datetime WindowTimeToServer(const datetime refDay, int minutesOfDay)
|
| {
|
| long extraDays = 0;
|
| while(minutesOfDay >= ICT_MIN_PER_DAY)
|
| {
|
| minutesOfDay -= ICT_MIN_PER_DAY;
|
| extraDays++;
|
| }
|
| const datetime naive = (datetime)((long)refDay + extraDays * ICT_SEC_PER_DAY + (long)minutesOfDay * 60);
|
|
|
| if(InpTimeBase == ICT_TB_SERVER)
|
| return naive; // the list is already in server time
|
|
|
| datetime utc = naive; // for GMT the naive stamp is UTC
|
| if(InpTimeBase == ICT_TB_NEWYORK)
|
| {
|
| const int off1 = NyUtcOffsetSec(naive); // first guess from the naive stamp
|
| utc = (datetime)((long)naive - (long)off1);
|
| const int off2 = NyUtcOffsetSec(utc); // second pass, correct across the DST switch
|
| if(off2 != off1)
|
| utc = (datetime)((long)naive - (long)off2);
|
| }
|
| return (datetime)((long)utc + (long)g_srvOffsetSec);
|
| }
|
|
|
| //| "Now" expressed in the wall clock of the configured time base. |
|
| datetime ReferenceNow()
|
| {
|
| const datetime srvNow = TimeTradeServer();
|
| if(InpTimeBase == ICT_TB_SERVER)
|
| return srvNow;
|
|
|
| const datetime utcNow = (datetime)((long)srvNow - (long)g_srvOffsetSec);
|
| if(InpTimeBase == ICT_TB_GMT)
|
| return utcNow;
|
|
|
| return (datetime)((long)utcNow + (long)NyUtcOffsetSec(utcNow));
|
| }
|
|
|
| //| Broker server UTC offset in seconds, snapped to 5 minutes. |
|
| int DetectServerOffsetSec()
|
| {
|
| if(InpTimeBase == ICT_TB_SERVER)
|
| return 0;
|
| if(InpServerOffsetMode == ICT_SRV_MANUAL)
|
| return (int)MathRound(InpManualServerGmtOffset * 3600.0 / 300.0) * 300;
|
|
|
| const double diff = (double)((long)TimeTradeServer() - (long)TimeGMT());
|
| return (int)MathRound(diff / 300.0) * 300;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| First index whose time is >= value (arrays arrive oldest-first). |
|
| //+------------------------------------------------------------------+
|
| int LowerBound(const datetime &time[], const int total, const datetime value)
|
| {
|
| int lo = 0, hi = total;
|
| while(lo < hi)
|
| {
|
| const int mid = lo + (hi - lo) / 2;
|
| if(time[mid] < value)
|
| lo = mid + 1;
|
| else
|
| hi = mid;
|
| }
|
| return lo;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Chart object helpers (own namespace only) |
|
| //+------------------------------------------------------------------+
|
| void SetCommonProps(const string name, const color clr, const int width, const bool back)
|
| {
|
| ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
|
| ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_SOLID);
|
| ObjectSetInteger(0, name, OBJPROP_WIDTH, width);
|
| ObjectSetInteger(0, name, OBJPROP_BACK, back);
|
| ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
|
| ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
|
| ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
|
| }
|
|
|
| bool EnsureRect(const string name, const datetime t1, const double p1,
|
| const datetime t2, const double p2, const color clr)
|
| {
|
| if(ObjectFind(0, name) < 0)
|
| {
|
| if(!ObjectCreate(0, name, OBJ_RECTANGLE, 0, t1, p1, t2, p2))
|
| {
|
| PrintFormat("ICTMacros: ObjectCreate failed for %s (error %d)", name, GetLastError());
|
| return false;
|
| }
|
| }
|
| else
|
| {
|
| ObjectMove(0, name, 0, t1, p1);
|
| ObjectMove(0, name, 1, t2, p2);
|
| }
|
| SetCommonProps(name, clr, 1, true);
|
| ObjectSetInteger(0, name, OBJPROP_FILL, InpFillBox);
|
| return true;
|
| }
|
|
|
| bool EnsureTrend(const string name, const datetime t1, const double p1,
|
| const datetime t2, const double p2, const color clr)
|
| {
|
| if(ObjectFind(0, name) < 0)
|
| {
|
| if(!ObjectCreate(0, name, OBJ_TREND, 0, t1, p1, t2, p2))
|
| {
|
| PrintFormat("ICTMacros: ObjectCreate failed for %s (error %d)", name, GetLastError());
|
| return false;
|
| }
|
| }
|
| else
|
| {
|
| ObjectMove(0, name, 0, t1, p1);
|
| ObjectMove(0, name, 1, t2, p2);
|
| }
|
| SetCommonProps(name, clr, 1, true);
|
| ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_DOT);
|
| ObjectSetInteger(0, name, OBJPROP_RAY_LEFT, false);
|
| ObjectSetInteger(0, name, OBJPROP_RAY_RIGHT, false);
|
| return true;
|
| }
|
|
|
| bool EnsureVLine(const string name, const datetime t, const color clr)
|
| {
|
| if(ObjectFind(0, name) < 0)
|
| {
|
| if(!ObjectCreate(0, name, OBJ_VLINE, 0, t, 0.0))
|
| {
|
| PrintFormat("ICTMacros: ObjectCreate failed for %s (error %d)", name, GetLastError());
|
| return false;
|
| }
|
| }
|
| else
|
| ObjectMove(0, name, 0, t, 0.0);
|
|
|
| SetCommonProps(name, clr, 1, true);
|
| ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_DOT);
|
| return true;
|
| }
|
|
|
| bool EnsureText(const string name, const datetime t, const double price,
|
| const string text, const color clr, const int fontSize)
|
| {
|
| if(ObjectFind(0, name) < 0)
|
| {
|
| if(!ObjectCreate(0, name, OBJ_TEXT, 0, t, price))
|
| {
|
| PrintFormat("ICTMacros: ObjectCreate failed for %s (error %d)", name, GetLastError());
|
| return false;
|
| }
|
| }
|
| else
|
| ObjectMove(0, name, 0, t, price);
|
|
|
| SetCommonProps(name, clr, 1, false);
|
|
|
| int fs = fontSize;
|
| if(fs < 6) fs = 6;
|
| if(fs > 20) fs = 20;
|
|
|
| ObjectSetString(0, name, OBJPROP_TEXT, text);
|
| ObjectSetString(0, name, OBJPROP_TOOLTIP, text);
|
| ObjectSetString(0, name, OBJPROP_FONT, "Arial");
|
| ObjectSetInteger(0, name, OBJPROP_FONTSIZE, fs);
|
| ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Object name registry (never touches objects of other programs) |
|
| //+------------------------------------------------------------------+
|
| void RegisterName(const string name)
|
| {
|
| const int size = ArraySize(g_names);
|
| if(g_nameCount >= size)
|
| {
|
| if(ArrayResize(g_names, size + 64) <= size)
|
| return; // registry full: keep drawing, skip tracking
|
| }
|
| g_names[g_nameCount] = name;
|
| g_nameCount++;
|
| }
|
|
|
| bool NameInList(const string name, string &list[], const int count)
|
| {
|
| for(int i = 0; i < count; i++)
|
| if(list[i] == name)
|
| return true;
|
| return false;
|
| }
|
|
|
| bool CapacityOk()
|
| {
|
| if(g_nameCount + 4 > InpMaxObjects)
|
| {
|
| if(!g_capWarned)
|
| {
|
| PrintFormat("ICTMacros: object cap InpMaxObjects=%d reached - older windows are skipped", InpMaxObjects);
|
| g_capWarned = true;
|
| }
|
| return false;
|
| }
|
| return true;
|
| }
|
|
|
| //| Remove ICTMacros_ objects left behind by a former run. Runs once per |
|
| //| initialization. Disable InpCleanStaleObjects when two copies of this |
|
| //| indicator share one chart. |
|
| void SweepOrphanObjects()
|
| {
|
| if(!InpCleanStaleObjects || g_orphanSwept)
|
| return;
|
| g_orphanSwept = true;
|
|
|
| const int total = ObjectsTotal(0, -1, -1);
|
| string doomed[];
|
| int doomedCount = 0;
|
|
|
| for(int i = 0; i < total; i++)
|
| {
|
| const string name = ObjectName(0, i, -1, -1);
|
| if(StringFind(name, ICT_PREFIX) != 0) // only this program's namespace
|
| continue;
|
| if(NameInList(name, g_names, g_nameCount))
|
| continue;
|
|
|
| const int size = ArraySize(doomed);
|
| if(doomedCount >= size)
|
| if(ArrayResize(doomed, size + 32) <= size)
|
| break;
|
| doomed[doomedCount] = name;
|
| doomedCount++;
|
| }
|
|
|
| for(int i = 0; i < doomedCount; i++)
|
| ObjectDelete(0, doomed[i]);
|
|
|
| if(doomedCount > 0)
|
| PrintFormat("ICTMacros: removed %d leftover object(s) from a previous run", doomedCount);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Drawing |
|
| //+------------------------------------------------------------------+
|
| string DateTag(const datetime refDay)
|
| {
|
| MqlDateTime d;
|
| TimeToStruct(refDay, d);
|
| return StringFormat("%04d%02d%02d", d.year, d.mon, d.day);
|
| }
|
|
|
| void DrawWindow(const int wi, const datetime refDay, const datetime tStart, const datetime tEnd,
|
| const double hi, const double lo)
|
| {
|
| const int session = g_win[wi].session;
|
| const color clr = SessionColor(session);
|
| const string base = StringFormat("%s%s_%02d_%s",
|
| ICT_PREFIX, SessionTag(session), g_win[wi].index, DateTag(refDay));
|
|
|
| if(InpDrawBox || InpFillBox)
|
| if(EnsureRect(base, tStart, lo, tEnd, hi, clr))
|
| RegisterName(base);
|
|
|
| if(InpMidline)
|
| {
|
| const string midName = base + "_mid";
|
| const double mid = (hi + lo) / 2.0;
|
| if(EnsureTrend(midName, tStart, mid, tEnd, mid, clr))
|
| RegisterName(midName);
|
| }
|
|
|
| if(InpVerticalLines)
|
| {
|
| const string startName = base + "_S";
|
| const string endName = base + "_E";
|
| if(EnsureVLine(startName, tStart, clr))
|
| RegisterName(startName);
|
| if(EnsureVLine(endName, tEnd, clr))
|
| RegisterName(endName);
|
| }
|
|
|
| if(InpShowLabels)
|
| {
|
| const string labelName = base + "_L";
|
| if(EnsureText(labelName, tStart, hi, g_win[wi].label, clr, InpLabelFontSize))
|
| RegisterName(labelName);
|
| }
|
| }
|
|
|
| //| Full rebuild. Runs on init and on every new bar. |
|
| void RebuildAll(const datetime &time[], const double &high[], const double &low[], const int rates_total)
|
| {
|
| g_nameCount = 0;
|
| g_capWarned = false;
|
| g_liveHi = 0.0;
|
| g_liveLo = 0.0;
|
|
|
| int days = InpHistoryDays;
|
| if(days < 0) days = 0;
|
| if(days > 200) days = 200;
|
|
|
| const datetime refDay = DayStart(ReferenceNow());
|
| bool stop = false;
|
|
|
| for(int d = 0; d <= days && !stop; d++)
|
| {
|
| const datetime day = (datetime)((long)refDay - (long)d * ICT_SEC_PER_DAY);
|
|
|
| for(int w = 0; w < g_winCount && !stop; w++)
|
| {
|
| if(!SessionEnabled(g_win[w].session))
|
| continue;
|
| if(!CapacityOk())
|
| {
|
| stop = true;
|
| break;
|
| }
|
|
|
| const datetime t1 = WindowTimeToServer(day, g_win[w].startMin);
|
| const datetime t2 = WindowTimeToServer(day, g_win[w].endMin);
|
|
|
| const int i1 = LowerBound(time, rates_total, t1);
|
| if(i1 >= rates_total)
|
| continue; // window has not started yet
|
| const int i2 = LowerBound(time, rates_total, t2);
|
| const int last = i2 - 1; // last bar inside the window
|
| if(last < i1)
|
| continue; // no bars (weekend / holiday / gap)
|
|
|
| double hi = high[i1];
|
| double lo = low[i1];
|
| for(int i = i1 + 1; i <= last; i++)
|
| {
|
| if(high[i] > hi) hi = high[i];
|
| if(low[i] < lo) lo = low[i];
|
| }
|
|
|
| datetime tEnd = (datetime)((long)time[last] + PeriodSeconds());
|
| if(tEnd > t2)
|
| tEnd = t2;
|
|
|
| DrawWindow(w, day, time[i1], tEnd, hi, lo);
|
| }
|
| }
|
|
|
| //--- drop objects of the previous rebuild that are no longer valid
|
| for(int i = 0; i < g_prevCount; i++)
|
| if(!NameInList(g_prevNames[i], g_names, g_nameCount))
|
| ObjectDelete(0, g_prevNames[i]);
|
|
|
| //--- swap registries
|
| if(ArrayResize(g_prevNames, g_nameCount) != g_nameCount)
|
| Print("ICTMacros: could not resize the object registry");
|
| for(int i = 0; i < g_nameCount; i++)
|
| g_prevNames[i] = g_names[i];
|
| g_prevCount = g_nameCount;
|
|
|
| ChartRedraw();
|
| }
|
|
|
| //| Refresh only the window that is currently open (tick path). |
|
| void RefreshLiveWindow(const datetime &time[], const double &high[], const double &low[], const int rates_total)
|
| {
|
| if(!InpLiveBox || rates_total < 2)
|
| return;
|
|
|
| const datetime lastBar = time[rates_total - 1];
|
| const datetime refDay = DayStart(ReferenceNow());
|
|
|
| for(int w = 0; w < g_winCount; w++)
|
| {
|
| if(!SessionEnabled(g_win[w].session))
|
| continue;
|
|
|
| const datetime t1 = WindowTimeToServer(refDay, g_win[w].startMin);
|
| const datetime t2 = WindowTimeToServer(refDay, g_win[w].endMin);
|
| if(lastBar < t1 || lastBar >= t2)
|
| continue; // this window is not open right now
|
|
|
| const int i1 = LowerBound(time, rates_total, t1);
|
| if(i1 >= rates_total)
|
| return;
|
|
|
| double hi = high[i1];
|
| double lo = low[i1];
|
| for(int i = i1 + 1; i < rates_total; i++)
|
| {
|
| if(high[i] > hi) hi = high[i];
|
| if(low[i] < lo) lo = low[i];
|
| }
|
| if(hi == g_liveHi && lo == g_liveLo)
|
| return; // extremes unchanged: nothing to do
|
|
|
| const string base = StringFormat("%s%s_%02d_%s",
|
| ICT_PREFIX, SessionTag(g_win[w].session), g_win[w].index, DateTag(refDay));
|
| if(ObjectFind(0, base) < 0)
|
| return; // box of this window not built yet
|
|
|
| datetime tEnd = (datetime)((long)lastBar + PeriodSeconds());
|
| if(tEnd > t2)
|
| tEnd = t2;
|
|
|
| ObjectMove(0, base, 0, time[i1], lo);
|
| ObjectMove(0, base, 1, tEnd, hi);
|
|
|
| if(InpMidline)
|
| {
|
| const string midName = base + "_mid";
|
| if(ObjectFind(0, midName) >= 0)
|
| {
|
| const double mid = (hi + lo) / 2.0;
|
| ObjectMove(0, midName, 0, time[i1], mid);
|
| ObjectMove(0, midName, 1, tEnd, mid);
|
| }
|
| }
|
| if(InpShowLabels)
|
| {
|
| const string labelName = base + "_L";
|
| if(ObjectFind(0, labelName) >= 0)
|
| ObjectMove(0, labelName, 0, time[i1], hi);
|
| }
|
|
|
| g_liveHi = hi;
|
| g_liveLo = lo;
|
| ChartRedraw();
|
| return;
|
| }
|
| }
|
|
|
| void LogSummary()
|
| {
|
| if(!InpVerboseLog)
|
| return;
|
|
|
| int asia = 0, london = 0, ny = 0;
|
| for(int i = 0; i < g_winCount; i++)
|
| {
|
| if(g_win[i].session == ICT_ASIA) asia++;
|
| else if(g_win[i].session == ICT_LONDON) london++;
|
| else ny++;
|
| }
|
|
|
| PrintFormat("ICTMacros: base=%s server offset=%d min windows=%d (Asia %d, London %d, NY %d) history=%d d objects=%d",
|
| TimeBaseName(InpTimeBase), g_srvOffsetSec / 60, g_winCount,
|
| asia, london, ny, InpHistoryDays, g_nameCount);
|
|
|
| if(InpTimeBase == ICT_TB_NEWYORK)
|
| {
|
| const datetime utcNow = (datetime)((long)TimeTradeServer() - (long)g_srvOffsetSec);
|
| const datetime nyNow = (datetime)((long)utcNow + (long)NyUtcOffsetSec(utcNow));
|
| string zoneTag = "EST";
|
| if(IsUsDst(utcNow))
|
| zoneTag = "EDT";
|
| PrintFormat("ICTMacros: New York local time now %s (%s)",
|
| TimeToString(nyNow, TIME_DATE | TIME_MINUTES), zoneTag);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Indicator events |
|
| //+------------------------------------------------------------------+
|
| int OnInit()
|
| {
|
| IndicatorSetString(INDICATOR_SHORTNAME, "ICT Macros");
|
|
|
| ArrayResize(g_win, 0);
|
| g_winCount = 0;
|
| g_winCount += ParseWindowList(InpAsiaMacros, ICT_ASIA, g_win);
|
| g_winCount += ParseWindowList(InpLondonMacros, ICT_LONDON, g_win);
|
| g_winCount += ParseWindowList(InpNYMacros, ICT_NEWYORK, g_win);
|
|
|
| g_srvOffsetSec = DetectServerOffsetSec();
|
| g_lastBarTime = 0;
|
| g_liveHi = 0.0;
|
| g_liveLo = 0.0;
|
| g_loggedSummary = false;
|
| g_capWarned = false;
|
| g_orphanSwept = false;
|
| g_nameCount = 0;
|
| g_prevCount = 0;
|
| ArrayResize(g_names, 0);
|
| ArrayResize(g_prevNames, 0);
|
|
|
| if(g_winCount == 0)
|
| Print("ICTMacros: no macro windows configured - nothing will be drawn");
|
| if(!InpShowAsia && !InpShowLondon && !InpShowNewYork)
|
| Print("ICTMacros: all sessions are disabled - nothing will be drawn");
|
| if(g_winCount > 0 && PeriodSeconds() > 1800)
|
| PrintFormat("ICTMacros: chart period is %d s, macro windows may cover 0 or 1 bar (M1-M15 recommended)",
|
| PeriodSeconds());
|
| if(InpTimeBase != ICT_TB_SERVER && InpServerOffsetMode == ICT_SRV_AUTO && InpVerboseLog)
|
| PrintFormat("ICTMacros: server/UTC offset detected as %d minutes", g_srvOffsetSec / 60);
|
|
|
| return INIT_SUCCEEDED;
|
| }
|
|
|
| void OnDeinit(const int reason)
|
| {
|
| for(int i = 0; i < g_nameCount; i++)
|
| ObjectDelete(0, g_names[i]);
|
| for(int i = 0; i < g_prevCount; i++)
|
| ObjectDelete(0, g_prevNames[i]);
|
|
|
| g_nameCount = 0;
|
| g_prevCount = 0;
|
| ArrayResize(g_names, 0);
|
| ArrayResize(g_prevNames, 0);
|
| ChartRedraw();
|
| }
|
|
|
| int OnCalculate(const int rates_total,
|
| const int prev_calculated,
|
| const datetime &time[],
|
| const double &open[],
|
| const double &high[],
|
| const double &low[],
|
| const double &close[],
|
| const long &tick_volume[],
|
| const long &volume[],
|
| const int &spread[])
|
| {
|
| if(rates_total < 2)
|
| return 0;
|
|
|
| const bool newBar = (time[rates_total - 1] != g_lastBarTime);
|
| const bool firstPass = (prev_calculated <= 0) || (prev_calculated > rates_total);
|
|
|
| if(firstPass || newBar)
|
| {
|
| //--- keep the server offset in sync with broker DST switches
|
| if(InpTimeBase != ICT_TB_SERVER && InpServerOffsetMode == ICT_SRV_AUTO)
|
| {
|
| const int detected = DetectServerOffsetSec();
|
| if(detected != g_srvOffsetSec)
|
| {
|
| if(InpVerboseLog)
|
| PrintFormat("ICTMacros: server/UTC offset changed from %d to %d minutes",
|
| g_srvOffsetSec / 60, detected / 60);
|
| g_srvOffsetSec = detected;
|
| }
|
| }
|
|
|
| g_lastBarTime = time[rates_total - 1];
|
| RebuildAll(time, high, low, rates_total);
|
|
|
| if(!g_loggedSummary)
|
| {
|
| g_loggedSummary = true;
|
| LogSummary();
|
| }
|
| SweepOrphanObjects();
|
| }
|
| else
|
| RefreshLiveWindow(time, high, low, rates_total);
|
|
|
| return rates_total;
|
| }
|
| //+------------------------------------------------------------------+
|
