| //+------------------------------------------------------------------+
|
| //| SessionLevels.mq5 |
|
| //| Copyright 2026, Allan Niñal |
|
| //| https://www.allanninal.dev/mql5 |
|
| //+------------------------------------------------------------------+
|
| //| Trading sessions (Asia, London, New York) as translucent boxes |
|
| //| with their high and low, plus the previous day and previous week |
|
| //| high/low and today's open as lines. Session times are entered in |
|
| //| New York time and converted per bar from the broker's clock, so |
|
| //| daylight saving is right on any broker. A trading day ends at |
|
| //| the 17:00 New York close. |
|
| //| Alerts (closed bars only, each at most once per trading day): |
|
| //| close above the previous day high / below the previous day low, |
|
| //| and after the Asia session, close above its high / below its low.|
|
| //+------------------------------------------------------------------+
|
| // SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0 (see LICENSE)
|
| #property copyright "Copyright 2026, Allan Niñal <https://www.allanninal.dev/mql5>"
|
| #property link "https://www.allanninal.dev/mql5"
|
| #property version "1.2"
|
| #property description "Asia / London / New York session boxes, previous day and week high/low, today's open. Times in New York time, DST-safe."
|
| #property description "Alerts on closed bars: break of the previous day high/low and of the Asia range. Non-repainting."
|
| #property description "Optional fakeout marker: a break of the overnight range that closes back inside it (a marker and an alert, not a trade signal)."
|
| #property indicator_chart_window
|
| #property indicator_buffers 28
|
| #property indicator_plots 8
|
| #property indicator_label1 "Prev day high"
|
| #property indicator_type1 DRAW_NONE
|
| #property indicator_label2 "Prev day low"
|
| #property indicator_type2 DRAW_NONE
|
| #property indicator_label3 "Prev week high"
|
| #property indicator_type3 DRAW_NONE
|
| #property indicator_label4 "Prev week low"
|
| #property indicator_type4 DRAW_NONE
|
| #property indicator_label5 "Asia high (so far)"
|
| #property indicator_type5 DRAW_NONE
|
| #property indicator_label6 "Asia low (so far)"
|
| #property indicator_type6 DRAW_NONE
|
| #property indicator_label7 "Signal"
|
| #property indicator_type7 DRAW_NONE
|
| #property indicator_label8 "Fakeout"
|
| #property indicator_type8 DRAW_NONE
|
|
|
| enum ENUM_SL_CLOCK
|
| {
|
| SL_CLOCK_AUTO=0, // Auto: detect from the live server time
|
| SL_CLOCK_NY=1, // New York close: UTC+2/+3 with US daylight saving
|
| SL_CLOCK_EET=2, // UTC+2/+3 with European daylight saving
|
| SL_CLOCK_FIXED=3 // Fixed offset from UTC (set below), no daylight saving
|
| };
|
|
|
| input int InpDays = 5; // Days to draw
|
| input group "Asia session (New York time)"
|
| input bool InpShowAsia = true; // Draw Asia
|
| input string InpAsiaStart = "19:00"; // Asia start HH:MM
|
| input string InpAsiaEnd = "04:00"; // Asia end HH:MM
|
| input color InpAsiaColor = 16748574; // Asia colour
|
| input group "London session (New York time)"
|
| input bool InpShowLondon = true; // Draw London
|
| input string InpLondonStart = "03:00"; // London start HH:MM
|
| input string InpLondonEnd = "12:00"; // London end HH:MM
|
| input color InpLondonColor = 42495; // London colour
|
| input group "New York session (New York time)"
|
| input bool InpShowNY = true; // Draw New York
|
| input string InpNYStart = "08:00"; // New York start HH:MM
|
| input string InpNYEnd = "17:00"; // New York end HH:MM
|
| input color InpNYColor = 7451452; // New York colour
|
| input group "Session boxes"
|
| input bool InpSessionLabels = true; // Label each box
|
| input bool InpFillBoxes = true; // Fill the boxes (translucent)
|
| input group "Levels"
|
| input bool InpShowPD = true; // Previous day high/low
|
| input bool InpShowPW = true; // Previous week high/low
|
| input bool InpShowOpen = true; // Today's open
|
| input color InpPDColor = 55295; // Previous day colour
|
| input color InpPWColor = 14053594; // Previous week colour
|
| input color InpOpenColor = 12632256; // Today's open colour
|
| input bool InpLevelLabels = true; // Price labels on the levels
|
| input int InpLevelWidth = 1; // Line width
|
| input group "Broker clock"
|
| input ENUM_SL_CLOCK InpClock = SL_CLOCK_AUTO; // Broker server clock
|
| input int InpFixedUTC = 0; // Broker offset from UTC, hours (Fixed offset only)
|
| input group "Alert kinds"
|
| input bool InpAlertPDH = true; // Close above previous day high
|
| input bool InpAlertPDL = true; // Close below previous day low
|
| input bool InpAlertAsiaH = true; // Close above Asia high (after Asia)
|
| input bool InpAlertAsiaL = true; // Close below Asia low (after Asia)
|
|
|
| #include "SignalAlerts.mqh"
|
| #include "ObjSync.mqh"
|
| #include <ChartKit/CkDebug.mqh>
|
|
|
| //--- new in 1.2, declared after the alert inputs so the order of every earlier input is unchanged for iCustom callers
|
| input group "Fakeout marker (overnight range, New York time)"
|
| input bool InpFoOn = true; // Mark fakeouts of the overnight range
|
| input string InpFoRangeStart= "17:00"; // Range start HH:MM
|
| input string InpFoRangeEnd = "02:00"; // Range end HH:MM
|
| input string InpFoWinStart = "02:00"; // Fakeout window start HH:MM
|
| input string InpFoWinEnd = "11:00"; // Fakeout window end HH:MM
|
| input int InpFoBars = 2; // Bars to close back inside (1 = break bar only, 2 = break bar or the next)
|
| input bool InpFoTrend = false; // Daily-structure filter (lower highs and lows: bearish only; higher: bullish only)
|
| input bool InpFoMarkers = true; // Draw the marker (arrow and label)
|
| input color InpFoBearColor = clrTomato; // Bearish fakeout colour (above the high)
|
| input color InpFoBullColor = clrDodgerBlue; // Bullish fakeout colour (below the low)
|
| input bool InpAlertFakeout= true; // Alert on a fakeout
|
| input group "Support"
|
| input bool InpDebug = false; // Debug log for bug reports (Experts tab)
|
|
|
| //--- buffers shown to the outside
|
| double g_pdh[],g_pdl[],g_pwh[],g_pwl[],g_ash[],g_asl[],g_sig[],g_fo[];
|
| //--- internal state, one value per bar so a recalculation can restart from any bar
|
| double g_nyw[]; // New York wall time of the bar (seconds)
|
| double g_dk[]; // trading-day number (New York close clock)
|
| double g_wk[]; // trading-week number
|
| double g_dhi[],g_dlo[],g_dop[]; // the day so far
|
| double g_whi[],g_wlo[]; // the week so far
|
| double g_aown[]; // owner date of the running Asia instance
|
| double g_adk[]; // trading day the running Asia instance belongs to
|
| double g_ahi[],g_alo[];
|
| double g_flag[]; // signals already given today: 1 PDH, 2 PDL, 4 Asia high, 8 Asia low
|
| double g_frh[],g_frl[],g_frc[]; // fakeout range so far today: high, low, bar count
|
| double g_fsh[],g_fsl[]; // fakeout state per side: 0 no break yet, n>0 broke n bars ago and waiting, -1 finished
|
| double g_ftr[]; // daily structure of today: +1 higher highs and lows, -1 lower, 0 mixed
|
| double g_dord[]; // trading-day ordinal (0 = first day on the chart)
|
| double g_dayhi[],g_daylo[]; // per trading-day ordinal: final high and low (indexed by ordinal, not by bar)
|
|
|
| const string PRODUCT="Session Levels";
|
| const int NY_CLOSE_SHIFT=7*3600; // New York-close clock minus New York wall clock
|
|
|
| ENUM_SL_CLOCK g_clock=SL_CLOCK_NY;
|
| int g_fixed_off=0;
|
| bool g_native=true;
|
| long g_sh_hour=-1;
|
| int g_sh_val=0;
|
| int g_s_start[3],g_s_end[3];
|
| int g_fo_rs=-1,g_fo_re=-1,g_fo_ws=-1,g_fo_we=-1,g_fo_need=1;
|
| bool g_fo_ok=false;
|
| bool g_s_on[3];
|
| color g_s_clr[3];
|
| string g_s_name[3]={"Asia","London","New York"};
|
| string g_pfx="";
|
| int g_obj_fail=0,g_dbg_fail=0; // objects the chart refused in the last pass / last reported
|
| datetime g_draw_bar=0;
|
| uint g_draw_tick=0;
|
| double g_draw_hi=0,g_draw_lo=0;
|
| int g_secs=60;
|
| bool g_no_draw=false; // set in OnInit: tester without visual mode (no chart to draw on)
|
|
|
| //+------------------------------------------------------------------+
|
| //| Broker clock -> New York time (ported from Gold Trend Sentinel) |
|
| //+------------------------------------------------------------------+
|
| //--- Sunday on or after `day` of `month` in year `y`, at `hour` UTC
|
| datetime SundayFrom(const int y,const int month,const int day,const int hour)
|
| {
|
| MqlDateTime t;
|
| ZeroMemory(t);
|
| t.year=y;
|
| t.mon=month;
|
| t.day=day;
|
| datetime d=StructToTime(t);
|
| TimeToStruct(d,t);
|
| return(d+(datetime)(((7-t.day_of_week)%7)*86400+hour*3600));
|
| }
|
|
|
| //--- US daylight saving (second Sunday of March 07:00 UTC to first Sunday of November 06:00 UTC)
|
| bool UsDst(const datetime utc)
|
| {
|
| MqlDateTime t;
|
| TimeToStruct(utc,t);
|
| return(utc>=SundayFrom(t.year,3,8,7) && utc<SundayFrom(t.year,11,1,6));
|
| }
|
|
|
| //--- EU summer time (last Sunday of March to last Sunday of October, 01:00 UTC)
|
| bool EuDst(const datetime utc)
|
| {
|
| MqlDateTime t;
|
| TimeToStruct(utc,t);
|
| return(utc>=SundayFrom(t.year,3,25,1) && utc<SundayFrom(t.year,10,25,1));
|
| }
|
|
|
| int NyOffset(const datetime utc) { return(UsDst(utc) ? 3*3600 : 2*3600); }
|
|
|
| //--- the broker's offset from UTC at server time `srv`
|
| int BrokerOffset(const datetime srv)
|
| {
|
| if(g_clock==SL_CLOCK_FIXED)
|
| return(g_fixed_off);
|
| if(g_clock==SL_CLOCK_EET)
|
| return(EuDst(srv-2*3600) ? 3*3600 : 2*3600);
|
| return(NyOffset(srv-2*3600));
|
| }
|
|
|
| //--- seconds to add to server time to get New York-close time (cached per hour: offsets change on the hour)
|
| int Shift(const datetime srv)
|
| {
|
| if(g_native)
|
| return(0);
|
| long h=(long)srv/3600;
|
| if(h!=g_sh_hour)
|
| {
|
| int b=BrokerOffset(srv);
|
| g_sh_val=NyOffset(srv-b)-b;
|
| g_sh_hour=h;
|
| }
|
| return(g_sh_val);
|
| }
|
|
|
| //--- decide the clock once: the inputs, or the live server time against UTC (the tester can't tell)
|
| void ResolveClock(void)
|
| {
|
| g_clock=InpClock;
|
| g_fixed_off=InpFixedUTC*3600;
|
| if(InpClock==SL_CLOCK_AUTO)
|
| {
|
| g_clock=SL_CLOCK_NY;
|
| if(!MQLInfoInteger(MQL_TESTER))
|
| {
|
| datetime gmt=TimeGMT();
|
| int off=(int)MathRound((double)(TimeTradeServer()-gmt)/1800.0)*1800;
|
| if(off==NyOffset(gmt))
|
| g_clock=SL_CLOCK_NY;
|
| else
|
| if(off==(EuDst(gmt) ? 3*3600 : 2*3600))
|
| g_clock=SL_CLOCK_EET;
|
| else
|
| {
|
| g_clock=SL_CLOCK_FIXED;
|
| g_fixed_off=off;
|
| }
|
| }
|
| }
|
| g_native=(g_clock==SL_CLOCK_NY);
|
| g_sh_hour=-1;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Helpers |
|
| //+------------------------------------------------------------------+
|
| //--- "HH:MM" -> minutes since midnight, -1 when invalid
|
| int ParseHM(const string s)
|
| {
|
| string p[];
|
| if(StringSplit(s,':',p)!=2)
|
| return(-1);
|
| int h=(int)StringToInteger(p[0]),m=(int)StringToInteger(p[1]);
|
| if(h<0 || h>23 || m<0 || m>59)
|
| return(-1);
|
| return(h*60+m);
|
| }
|
|
|
| //--- is minute-of-day `m` inside [s,e) ? A session with s>e crosses midnight
|
| bool InSession(const int m,const int s,const int e)
|
| {
|
| if(s==e)
|
| return(false);
|
| if(s<e)
|
| return(m>=s && m<e);
|
| return(m>=s || m<e);
|
| }
|
|
|
| //--- owner date of a session bar: a session that crosses midnight belongs to the day it ends on
|
| long OwnerDate(const long nyw,const int m,const int s,const int e)
|
| {
|
| long d=nyw/86400;
|
| return((s>e && m>=s) ? d+1 : d);
|
| }
|
|
|
| //--- daily structure for trading-day ordinal `ord` from the days before it: the last two confirmed swing highs and
|
| //--- lows (3 days each side; a swing is confirmed 3 days later). +1 both rose, -1 both fell, 0 otherwise.
|
| int DailyStructure(const int ord)
|
| {
|
| double hs[2],ls[2];
|
| int nh=0,nl=0;
|
| for(int j=ord-4; j>=3 && (nh<2 || nl<2); j--)
|
| {
|
| double mh=g_dayhi[j],ml=g_daylo[j];
|
| for(int q=j-3; q<=j+3; q++)
|
| {
|
| mh=MathMax(mh,g_dayhi[q]);
|
| ml=MathMin(ml,g_daylo[q]);
|
| }
|
| if(nh<2 && g_dayhi[j]==mh)
|
| hs[nh++]=g_dayhi[j];
|
| if(nl<2 && g_daylo[j]==ml)
|
| ls[nl++]=g_daylo[j];
|
| }
|
| if(nh<2 || nl<2)
|
| return(0);
|
| //--- hs[0] is the latest swing high, hs[1] the one before
|
| if(hs[0]>hs[1] && ls[0]>ls[1])
|
| return(1);
|
| if(hs[0]<hs[1] && ls[0]<ls[1])
|
| return(-1);
|
| return(0);
|
| }
|
|
|
| int OnInit()
|
| {
|
| CkDebugStart(PRODUCT,"1.2",InpDebug,StringFormat("days %d, sessions Asia %d %s-%s, London %d %s-%s, NY %d %s-%s, PD %d, PW %d, open %d, clock %d (UTC %d), fakeout %d (range %s-%s, window %s-%s, %d bars, trend %d)",
|
| InpDays,InpShowAsia,InpAsiaStart,InpAsiaEnd,InpShowLondon,InpLondonStart,InpLondonEnd,InpShowNY,InpNYStart,InpNYEnd,
|
| InpShowPD,InpShowPW,InpShowOpen,(int)InpClock,InpFixedUTC,
|
| InpFoOn,InpFoRangeStart,InpFoRangeEnd,InpFoWinStart,InpFoWinEnd,InpFoBars,InpFoTrend));
|
| g_s_start[0]=ParseHM(InpAsiaStart); g_s_end[0]=ParseHM(InpAsiaEnd);
|
| g_s_start[1]=ParseHM(InpLondonStart); g_s_end[1]=ParseHM(InpLondonEnd);
|
| g_s_start[2]=ParseHM(InpNYStart); g_s_end[2]=ParseHM(InpNYEnd);
|
| for(int s=0; s<3; s++)
|
| if(g_s_start[s]<0 || g_s_end[s]<0)
|
| {
|
| Print("Session Levels: session times must be HH:MM (00:00 to 23:59)");
|
| CkDbg("init refused: session times");
|
| return(INIT_PARAMETERS_INCORRECT);
|
| }
|
| g_s_on[0]=InpShowAsia; g_s_clr[0]=InpAsiaColor;
|
| g_s_on[1]=InpShowLondon; g_s_clr[1]=InpLondonColor;
|
| g_s_on[2]=InpShowNY; g_s_clr[2]=InpNYColor;
|
| if(InpDays<1 || InpLevelWidth<1 || InpLevelWidth>5 || InpFixedUTC<-12 || InpFixedUTC>14)
|
| {
|
| Print("Session Levels: days to draw at least 1, line width 1-5, broker offset from UTC -12 to 14 hours");
|
| CkDbg("init refused: days, line width or UTC offset");
|
| return(INIT_PARAMETERS_INCORRECT);
|
| }
|
| SetIndexBuffer(0,g_pdh,INDICATOR_DATA);
|
| SetIndexBuffer(1,g_pdl,INDICATOR_DATA);
|
| SetIndexBuffer(2,g_pwh,INDICATOR_DATA);
|
| SetIndexBuffer(3,g_pwl,INDICATOR_DATA);
|
| SetIndexBuffer(4,g_ash,INDICATOR_DATA);
|
| SetIndexBuffer(5,g_asl,INDICATOR_DATA);
|
| SetIndexBuffer(6,g_sig,INDICATOR_DATA);
|
| SetIndexBuffer(7,g_fo,INDICATOR_DATA);
|
| SetIndexBuffer(8,g_nyw,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(9,g_dk,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(10,g_wk,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(11,g_dhi,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(12,g_dlo,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(13,g_dop,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(14,g_whi,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(15,g_wlo,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(16,g_aown,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(17,g_adk,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(18,g_ahi,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(19,g_alo,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(20,g_flag,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(21,g_frh,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(22,g_frl,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(23,g_frc,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(24,g_fsh,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(25,g_fsl,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(26,g_ftr,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(27,g_dord,INDICATOR_CALCULATIONS);
|
| for(int p=0; p<8; p++)
|
| PlotIndexSetDouble(p,PLOT_EMPTY_VALUE,EMPTY_VALUE);
|
| IndicatorSetString(INDICATOR_SHORTNAME,"Session Levels");
|
| IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
|
| g_fo_rs=ParseHM(InpFoRangeStart); g_fo_re=ParseHM(InpFoRangeEnd);
|
| g_fo_ws=ParseHM(InpFoWinStart); g_fo_we=ParseHM(InpFoWinEnd);
|
| if(g_fo_rs<0 || g_fo_re<0 || g_fo_ws<0 || g_fo_we<0 || InpFoBars<1 || InpFoBars>5)
|
| {
|
| Print("Session Levels: fakeout times must be HH:MM and the bars to close back inside 1 to 5");
|
| CkDbg("init refused: fakeout times or bars");
|
| return(INIT_PARAMETERS_INCORRECT);
|
| }
|
| g_secs=PeriodSeconds();
|
| //--- fakeout: M1 to H1 only; the range must hold at least 5/6 of its bars (30 of 36 on M15 for a 9-hour range)
|
| int rmin=((g_fo_re-g_fo_rs)%1440+1440)%1440;
|
| g_fo_ok=(InpFoOn && g_secs<=3600 && rmin>0 && g_fo_ws!=g_fo_we);
|
| g_fo_need=MathMax(1,(int)MathCeil((double)rmin*60.0/(double)g_secs*30.0/36.0));
|
| ResolveClock();
|
| CkDbg(StringFormat("clock resolved: mode %d, offset from UTC %d s, %s",(int)g_clock,g_fixed_off,g_native ? "server time is New York close" : "converted per bar"));
|
| if(MQLInfoInteger(MQL_TESTER) && InpClock==SL_CLOCK_AUTO)
|
| Print("Session Levels: the Strategy Tester can't detect the broker's clock; New York close is assumed. ",
|
| "Set 'Broker server clock' for a broker on another clock.");
|
| g_secs=PeriodSeconds();
|
| g_pfx="SLV"+IntegerToString((int)(GetMicrosecondCount()%1000000))+"_";
|
| g_draw_bar=0;
|
| g_obj_fail=0;
|
| g_dbg_fail=0;
|
| g_no_draw=(MQLInfoInteger(MQL_TESTER) && !MQLInfoInteger(MQL_VISUAL_MODE));
|
| return(INIT_SUCCEEDED);
|
| }
|
|
|
| void OnDeinit(const int reason)
|
| {
|
| if(g_pfx!="")
|
| {
|
| ObjectsDeleteAll(0,g_pfx);
|
| ChartRedraw();
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Drawing |
|
| //+------------------------------------------------------------------+
|
| void PutObj(const string name,const ENUM_OBJECT type,const datetime t1,const double p1,const datetime t2,const double p2)
|
| {
|
| if(!OsPlace(name,type,2,t1,p1,t2,p2))
|
| {
|
| g_obj_fail++;
|
| return;
|
| }
|
| OsInt(name,OBJPROP_BACK,true);
|
| }
|
|
|
| void PutText(const string name,const datetime t,const double price,const string text,const color clr,const ENUM_ANCHOR_POINT anchor)
|
| {
|
| if(!OsPlace(name,OBJ_TEXT,1,t,price,0,0))
|
| {
|
| g_obj_fail++;
|
| return;
|
| }
|
| OsStr(name,OBJPROP_TEXT,text);
|
| OsInt(name,OBJPROP_COLOR,clr);
|
| OsInt(name,OBJPROP_ANCHOR,anchor);
|
| OsInt(name,OBJPROP_FONTSIZE,8);
|
| }
|
|
|
| void DrawBox(const int s,const long owner,const datetime t1,const datetime t2,const double hi,const double lo)
|
| {
|
| string nm=g_pfx+"B"+IntegerToString(s)+"_"+IntegerToString(owner);
|
| PutObj(nm,OBJ_RECTANGLE,t1,hi,t2,lo);
|
| OsInt(nm,OBJPROP_COLOR,InpFillBoxes ? ColorToARGB(g_s_clr[s],60) : g_s_clr[s]);
|
| OsInt(nm,OBJPROP_FILL,InpFillBoxes);
|
| OsInt(nm,OBJPROP_WIDTH,1);
|
| if(InpSessionLabels)
|
| PutText(g_pfx+"T"+IntegerToString(s)+"_"+IntegerToString(owner),t1,hi,g_s_name[s],g_s_clr[s],ANCHOR_LEFT_LOWER);
|
| }
|
|
|
| void DrawLevel(const string tag,const string label,const double price,const color clr,const int a,const int b,
|
| const bool current,const datetime &time[],const int last,const ENUM_LINE_STYLE style)
|
| {
|
| if(price==EMPTY_VALUE || price<=0)
|
| return;
|
| datetime t1=time[a],t2=(current ? time[last]+g_secs : time[b]+g_secs);
|
| string nm=g_pfx+"L"+tag+"_"+IntegerToString((long)time[a]);
|
| PutObj(nm,OBJ_TREND,t1,price,t2,price);
|
| OsInt(nm,OBJPROP_COLOR,clr);
|
| OsInt(nm,OBJPROP_WIDTH,InpLevelWidth);
|
| OsInt(nm,OBJPROP_STYLE,style);
|
| OsInt(nm,OBJPROP_RAY_RIGHT,current);
|
| if(current && InpLevelLabels)
|
| PutText(g_pfx+"P"+tag,time[last]+3*g_secs,price,label+" "+DoubleToString(price,_Digits),clr,ANCHOR_LEFT);
|
| }
|
|
|
| //--- redraw everything for the last InpDays days (objects are deleted first, so old days disappear)
|
| void Draw(const int rates_total,const datetime &time[],const double &high[],const double &low[])
|
| {
|
| int last=rates_total-1;
|
| bool intraday=(g_secs<=PeriodSeconds(PERIOD_H4));
|
| int days=(intraday ? MathMin(InpDays,60) : 1);
|
| OsBegin();
|
| g_obj_fail=0;
|
| //--- first bar of the oldest day to draw
|
| int first=last,cnt=1;
|
| for(int k=last; k>0; k--)
|
| {
|
| if(g_dk[k-1]!=g_dk[k])
|
| {
|
| if(cnt>=days)
|
| break;
|
| cnt++;
|
| }
|
| first=k-1;
|
| }
|
| //--- session boxes
|
| if(intraday)
|
| for(int s=0; s<3; s++)
|
| {
|
| if(!g_s_on[s])
|
| continue;
|
| bool open=false;
|
| long owner=0;
|
| int st=0,en=0;
|
| double hi=0,lo=0;
|
| for(int j=first; j<=last; j++)
|
| {
|
| int m=(int)(((long)g_nyw[j]%86400)/60);
|
| if(InSession(m,g_s_start[s],g_s_end[s]))
|
| {
|
| long ow=OwnerDate((long)g_nyw[j],m,g_s_start[s],g_s_end[s]);
|
| if(open && ow==owner)
|
| {
|
| en=j;
|
| hi=MathMax(hi,high[j]);
|
| lo=MathMin(lo,low[j]);
|
| }
|
| else
|
| {
|
| if(open)
|
| DrawBox(s,owner,time[st],time[en]+g_secs,hi,lo);
|
| open=true;
|
| owner=ow;
|
| st=j;
|
| en=j;
|
| hi=high[j];
|
| lo=low[j];
|
| }
|
| }
|
| else
|
| if(open)
|
| {
|
| DrawBox(s,owner,time[st],time[en]+g_secs,hi,lo);
|
| open=false;
|
| }
|
| }
|
| if(open)
|
| DrawBox(s,owner,time[st],time[en]+g_secs,hi,lo);
|
| }
|
| //--- fakeout markers: an arrow and the label in one text object at the confirming bar
|
| if(InpFoMarkers && g_fo_ok)
|
| for(int j=first; j<last; j++)
|
| {
|
| if(g_fo[j]==EMPTY_VALUE)
|
| continue;
|
| string tag=g_pfx+"F"+IntegerToString((long)time[j]);
|
| int v=(int)g_fo[j];
|
| if(v==-1 || v==2)
|
| PutText(tag+"A",time[j],high[j],"▼ Fakeout",InpFoBearColor,ANCHOR_LOWER);
|
| if(v==1 || v==2)
|
| PutText(tag+"B",time[j],low[j],"▲ Fakeout",InpFoBullColor,ANCHOR_UPPER);
|
| }
|
| //--- level lines, one segment per day; the current day is a ray to the right
|
| int a=first;
|
| while(a<=last)
|
| {
|
| int b=a;
|
| while(b<last && g_dk[b+1]==g_dk[a])
|
| b++;
|
| bool cur=(b==last);
|
| if(InpShowPD)
|
| {
|
| DrawLevel("PDH","PDH",g_pdh[a],InpPDColor,a,b,cur,time,last,STYLE_SOLID);
|
| DrawLevel("PDL","PDL",g_pdl[a],InpPDColor,a,b,cur,time,last,STYLE_SOLID);
|
| }
|
| if(InpShowPW)
|
| {
|
| DrawLevel("PWH","PWH",g_pwh[a],InpPWColor,a,b,cur,time,last,STYLE_DASH);
|
| DrawLevel("PWL","PWL",g_pwl[a],InpPWColor,a,b,cur,time,last,STYLE_DASH);
|
| }
|
| if(InpShowOpen && intraday)
|
| DrawLevel("OP","Open",g_dop[a],InpOpenColor,a,b,cur,time,last,STYLE_DOT);
|
| a=b+1;
|
| }
|
| OsEnd(g_pfx);
|
| if(g_obj_fail!=g_dbg_fail)
|
| {
|
| g_dbg_fail=g_obj_fail;
|
| CkDbg(StringFormat("the chart refused %d object(s), error %d",g_obj_fail,GetLastError()));
|
| }
|
| g_draw_bar=time[last];
|
| g_draw_tick=GetTickCount();
|
| g_draw_hi=high[last];
|
| g_draw_lo=low[last];
|
| 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);
|
| int start=(prev_calculated>0 ? prev_calculated-1 : 0);
|
| for(int i=start; i<rates_total; i++)
|
| {
|
| long nyc=(long)time[i]+Shift(time[i]);
|
| long nyw=nyc-NY_CLOSE_SHIFT;
|
| long dk=nyc/86400,wk=(dk+3)/7;
|
| int m=(int)((nyw%86400)/60);
|
| g_nyw[i]=(double)nyw;
|
| g_dk[i]=(double)dk;
|
| g_wk[i]=(double)wk;
|
| bool new_day=(i==0 || (long)g_dk[i-1]!=dk);
|
| bool new_week=(i==0 || (long)g_wk[i-1]!=wk);
|
| int fl=0;
|
| //--- day: previous day levels and today's range
|
| if(new_day)
|
| {
|
| g_pdh[i]=(i>0 ? g_dhi[i-1] : EMPTY_VALUE);
|
| g_pdl[i]=(i>0 ? g_dlo[i-1] : EMPTY_VALUE);
|
| g_dhi[i]=high[i];
|
| g_dlo[i]=low[i];
|
| g_dop[i]=open[i];
|
| }
|
| else
|
| {
|
| g_pdh[i]=g_pdh[i-1];
|
| g_pdl[i]=g_pdl[i-1];
|
| g_dhi[i]=MathMax(g_dhi[i-1],high[i]);
|
| g_dlo[i]=MathMin(g_dlo[i-1],low[i]);
|
| g_dop[i]=g_dop[i-1];
|
| fl=(int)g_flag[i-1];
|
| }
|
| //--- trading-day ordinal and the daily structure (built from the chart's own bars)
|
| if(new_day)
|
| {
|
| int ord=(i>0 ? (int)g_dord[i-1]+1 : 0);
|
| if(ArraySize(g_dayhi)<ord+1)
|
| {
|
| ArrayResize(g_dayhi,ord+1+512);
|
| ArrayResize(g_daylo,ord+1+512);
|
| }
|
| if(i>0)
|
| {
|
| g_dayhi[ord-1]=g_dhi[i-1];
|
| g_daylo[ord-1]=g_dlo[i-1];
|
| }
|
| g_dord[i]=ord;
|
| g_ftr[i]=(g_fo_ok && InpFoTrend ? DailyStructure(ord) : 0);
|
| }
|
| else
|
| {
|
| g_dord[i]=g_dord[i-1];
|
| g_ftr[i]=g_ftr[i-1];
|
| }
|
| //--- week
|
| if(new_week)
|
| {
|
| g_pwh[i]=(i>0 ? g_whi[i-1] : EMPTY_VALUE);
|
| g_pwl[i]=(i>0 ? g_wlo[i-1] : EMPTY_VALUE);
|
| g_whi[i]=high[i];
|
| g_wlo[i]=low[i];
|
| }
|
| else
|
| {
|
| g_pwh[i]=g_pwh[i-1];
|
| g_pwl[i]=g_pwl[i-1];
|
| g_whi[i]=MathMax(g_whi[i-1],high[i]);
|
| g_wlo[i]=MathMin(g_wlo[i-1],low[i]);
|
| }
|
| //--- Asia range of the current trading day
|
| if(i>0)
|
| {
|
| g_aown[i]=g_aown[i-1];
|
| g_adk[i]=g_adk[i-1];
|
| g_ahi[i]=g_ahi[i-1];
|
| g_alo[i]=g_alo[i-1];
|
| }
|
| else
|
| {
|
| g_aown[i]=-1;
|
| g_adk[i]=-1;
|
| g_ahi[i]=0;
|
| g_alo[i]=0;
|
| }
|
| bool in_asia=InSession(m,g_s_start[0],g_s_end[0]);
|
| if(in_asia)
|
| {
|
| long ow=OwnerDate(nyw,m,g_s_start[0],g_s_end[0]);
|
| if((long)g_aown[i]!=ow)
|
| {
|
| g_aown[i]=(double)ow;
|
| g_adk[i]=(double)dk;
|
| g_ahi[i]=high[i];
|
| g_alo[i]=low[i];
|
| }
|
| else
|
| {
|
| g_ahi[i]=MathMax(g_ahi[i],high[i]);
|
| g_alo[i]=MathMin(g_alo[i],low[i]);
|
| }
|
| }
|
| bool asia_ok=((long)g_adk[i]==dk && g_aown[i]!=-1);
|
| g_ash[i]=(asia_ok ? g_ahi[i] : EMPTY_VALUE);
|
| g_asl[i]=(asia_ok ? g_alo[i] : EMPTY_VALUE);
|
| //--- fakeout of the overnight range: a bar trades beyond one side inside the window and that bar (or one of the
|
| //--- next InpFoBars-1) closes back inside the range. Decided on the bar's close; once per side per day.
|
| int fo=0;
|
| double fo_hi=0,fo_lo=0;
|
| if(g_fo_ok)
|
| {
|
| if(new_day)
|
| {
|
| g_frh[i]=0;
|
| g_frl[i]=0;
|
| g_frc[i]=0;
|
| g_fsh[i]=0;
|
| g_fsl[i]=0;
|
| }
|
| else
|
| {
|
| g_frh[i]=g_frh[i-1];
|
| g_frl[i]=g_frl[i-1];
|
| g_frc[i]=g_frc[i-1];
|
| g_fsh[i]=g_fsh[i-1];
|
| g_fsl[i]=g_fsl[i-1];
|
| }
|
| if(InSession(m,g_fo_rs,g_fo_re))
|
| {
|
| g_frh[i]=(g_frc[i]==0 ? high[i] : MathMax(g_frh[i],high[i]));
|
| g_frl[i]=(g_frc[i]==0 ? low[i] : MathMin(g_frl[i],low[i]));
|
| g_frc[i]+=1;
|
| }
|
| else
|
| if(InSession(m,g_fo_ws,g_fo_we) && (int)g_frc[i]>=g_fo_need)
|
| {
|
| double rh=g_frh[i],rl=g_frl[i];
|
| bool inside=(close[i]<rh && close[i]>rl);
|
| //--- high side: bearish fakeout
|
| int st=(int)g_fsh[i];
|
| if(st>=0 && (!InpFoTrend || (int)g_ftr[i]==-1))
|
| {
|
| if(st>0 || high[i]>rh)
|
| {
|
| st++;
|
| if(inside)
|
| {
|
| fo|=1;
|
| fo_hi=rh;
|
| st=-1;
|
| }
|
| else
|
| if(st>=InpFoBars)
|
| st=-1;
|
| }
|
| g_fsh[i]=st;
|
| }
|
| //--- low side: bullish fakeout
|
| st=(int)g_fsl[i];
|
| if(st>=0 && (!InpFoTrend || (int)g_ftr[i]==1))
|
| {
|
| if(st>0 || low[i]<rl)
|
| {
|
| st++;
|
| if(inside)
|
| {
|
| fo|=2;
|
| fo_lo=rl;
|
| st=-1;
|
| }
|
| else
|
| if(st>=InpFoBars)
|
| st=-1;
|
| }
|
| g_fsl[i]=st;
|
| }
|
| }
|
| else
|
| {
|
| //--- outside the window a pending break can no longer be confirmed
|
| if(g_fsh[i]>0)
|
| g_fsh[i]=-1;
|
| if(g_fsl[i]>0)
|
| g_fsl[i]=-1;
|
| }
|
| }
|
| g_fo[i]=EMPTY_VALUE;
|
| //--- signals: closed bars only, each kind once per trading day
|
| g_sig[i]=EMPTY_VALUE;
|
| if(i<=rates_total-2)
|
| {
|
| int kinds=0;
|
| if(g_pdh[i]!=EMPTY_VALUE)
|
| {
|
| if((fl&1)==0 && close[i]>g_pdh[i])
|
| kinds|=1;
|
| if((fl&2)==0 && close[i]<g_pdl[i])
|
| kinds|=2;
|
| }
|
| if(asia_ok && !in_asia)
|
| {
|
| if((fl&4)==0 && close[i]>g_ahi[i])
|
| kinds|=4;
|
| if((fl&8)==0 && close[i]<g_alo[i])
|
| kinds|=8;
|
| }
|
| fl|=kinds;
|
| if(fo!=0)
|
| g_fo[i]=(fo==3 ? 2 : (fo==1 ? -1 : 1));
|
| if((kinds&1)!=0)
|
| g_sig[i]=1;
|
| else
|
| if((kinds&2)!=0)
|
| g_sig[i]=-1;
|
| else
|
| if((kinds&4)!=0)
|
| g_sig[i]=2;
|
| else
|
| if((kinds&8)!=0)
|
| g_sig[i]=-2;
|
| if((kinds!=0 || fo!=0) && i==rates_total-2)
|
| {
|
| string txt="";
|
| if((kinds&1)!=0 && InpAlertPDH)
|
| txt+="closed above previous day high "+DoubleToString(g_pdh[i],_Digits)+"; ";
|
| if((kinds&2)!=0 && InpAlertPDL)
|
| txt+="closed below previous day low "+DoubleToString(g_pdl[i],_Digits)+"; ";
|
| if((kinds&4)!=0 && InpAlertAsiaH)
|
| txt+="closed above Asia high "+DoubleToString(g_ahi[i],_Digits)+"; ";
|
| if((kinds&8)!=0 && InpAlertAsiaL)
|
| txt+="closed below Asia low "+DoubleToString(g_alo[i],_Digits)+"; ";
|
| if((fo&1)!=0 && InpAlertFakeout)
|
| txt+="fakeout above the range high "+DoubleToString(fo_hi,_Digits)+", closed back inside (bearish); ";
|
| if((fo&2)!=0 && InpAlertFakeout)
|
| txt+="fakeout below the range low "+DoubleToString(fo_lo,_Digits)+", closed back inside (bullish); ";
|
| if(txt!="")
|
| {
|
| CkDbg("alert for the closed bar "+TimeToString(time[i])+": "+StringSubstr(txt,0,StringLen(txt)-2));
|
| SignalAlert(PRODUCT,StringSubstr(txt,0,StringLen(txt)-2),time[i],prev_calculated>0);
|
| }
|
| }
|
| }
|
| g_flag[i]=fl;
|
| }
|
| if(g_no_draw)
|
| return(rates_total);
|
| //--- objects: on a new bar, or (throttled) when the live bar widens the live session
|
| int last=rates_total-1;
|
| bool newbar=(time[last]!=g_draw_bar);
|
| bool widen=(g_secs<=PeriodSeconds(PERIOD_H4) && (high[last]>g_draw_hi || low[last]<g_draw_lo) && GetTickCount()-g_draw_tick>=1000);
|
| if(newbar || widen)
|
| Draw(rates_total,time,high,low);
|
| return(rates_total);
|
| }
|
| //+------------------------------------------------------------------+
|
