| //+------------------------------------------------------------------+
|
| //| SessionLevels.mq4 |
|
| //| 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.|
|
| //| MT4 edition: the same calculation, inputs and 7 iCustom buffers |
|
| //| as the MT5 one. MT4 has no transparency, so a filled box is the |
|
| //| session colour blended into the chart background. |
|
| //+------------------------------------------------------------------+
|
| // 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.1"
|
| #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 indicator_chart_window
|
| #property indicator_buffers 7
|
|
|
| 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 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 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 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 bool InpSessionLabels = true; // Label each box
|
| input bool InpFillBoxes = true; // Fill the boxes (translucent)
|
| 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 ENUM_SL_CLOCK InpClock = SL_CLOCK_AUTO; // Broker server clock
|
| input int InpFixedUTC = 0; // Broker offset from UTC, hours (Fixed offset only)
|
| 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>
|
|
|
| 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[];
|
| //--- 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
|
|
|
| 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];
|
| 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(!IsTesting())
|
| {
|
| datetime gmt=TimeGMT();
|
| //--- MT4 has no TimeTradeServer(): the last tick's server time; stale while the market is closed, so an
|
| //--- offset that is no real UTC offset keeps the New York close assumption
|
| int off=(int)MathRound((double)(TimeCurrent()-gmt)/1800.0)*1800;
|
| if(off<-12*3600 || off>14*3600 || 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);
|
| }
|
|
|
| int OnInit()
|
| {
|
| CkDebugStart(PRODUCT,"1.1",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)",
|
| InpDays,InpShowAsia,InpAsiaStart,InpAsiaEnd,InpShowLondon,InpLondonStart,InpLondonEnd,InpShowNY,InpNYStart,InpNYEnd,
|
| InpShowPD,InpShowPW,InpShowOpen,(int)InpClock,InpFixedUTC));
|
| 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);
|
| }
|
| IndicatorBuffers(20);
|
| 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_nyw,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(8,g_dk,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(9,g_wk,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(10,g_dhi,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(11,g_dlo,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(12,g_dop,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(13,g_whi,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(14,g_wlo,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(15,g_aown,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(16,g_adk,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(17,g_ahi,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(18,g_alo,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(19,g_flag,INDICATOR_CALCULATIONS);
|
| string names[7]={"Prev day high","Prev day low","Prev week high","Prev week low","Asia high (so far)",
|
| "Asia low (so far)","Signal"};
|
| for(int p=0; p<20; p++)
|
| {
|
| SetIndexStyle(p,DRAW_NONE);
|
| SetIndexEmptyValue(p,EMPTY_VALUE);
|
| SetIndexLabel(p,p<7 ? names[p] : NULL);
|
| }
|
| IndicatorShortName("Session Levels");
|
| IndicatorDigits(_Digits);
|
| 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(IsTesting() && 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=(IsTesting() && !IsVisualMode());
|
| 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);
|
| }
|
|
|
| //--- MT4 cannot draw a translucent rectangle: blend the colour into the chart background by `alpha` (0-255)
|
| color Blend(const color c,const int alpha)
|
| {
|
| color bg=(color)ChartGetInteger(0,CHART_COLOR_BACKGROUND);
|
| int r=((c&0xFF)*alpha+(bg&0xFF)*(255-alpha))/255;
|
| int g=(((c>>8)&0xFF)*alpha+((bg>>8)&0xFF)*(255-alpha))/255;
|
| int b=(((c>>16)&0xFF)*alpha+((bg>>16)&0xFF)*(255-alpha))/255;
|
| return((color)(r|(g<<8)|(b<<16)));
|
| }
|
|
|
| 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 ? Blend(g_s_clr[s],60) : g_s_clr[s]);
|
| OsInt(nm,OBJPROP_FILL,InpFillBoxes);
|
| OsInt(nm,OBJPROP_BACK,InpFillBoxes); // MT4 fills a rectangle drawn in the background
|
| 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);
|
| }
|
| //--- 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);
|
| //--- count bars from the oldest, as MT5 does (prices and every buffer)
|
| ArraySetAsSeries(time,false);
|
| ArraySetAsSeries(open,false);
|
| ArraySetAsSeries(high,false);
|
| ArraySetAsSeries(low,false);
|
| ArraySetAsSeries(close,false);
|
| ArraySetAsSeries(g_pdh,false); ArraySetAsSeries(g_pdl,false); ArraySetAsSeries(g_pwh,false);
|
| ArraySetAsSeries(g_pwl,false); ArraySetAsSeries(g_ash,false); ArraySetAsSeries(g_asl,false);
|
| ArraySetAsSeries(g_sig,false); ArraySetAsSeries(g_nyw,false); ArraySetAsSeries(g_dk,false);
|
| ArraySetAsSeries(g_wk,false); ArraySetAsSeries(g_dhi,false); ArraySetAsSeries(g_dlo,false);
|
| ArraySetAsSeries(g_dop,false); ArraySetAsSeries(g_whi,false); ArraySetAsSeries(g_wlo,false);
|
| ArraySetAsSeries(g_aown,false); ArraySetAsSeries(g_adk,false); ArraySetAsSeries(g_ahi,false);
|
| ArraySetAsSeries(g_alo,false); ArraySetAsSeries(g_flag,false);
|
| 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];
|
| }
|
| //--- 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);
|
| //--- 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((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 && 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(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);
|
| }
|
| //+------------------------------------------------------------------+
|
