timezonerectangle

ÿþ//+------------------------------------------------------------------+

//| Time Zone Rectangles                                             |

//+------------------------------------------------------------------+

#property copyright "Copyright 2015,  Daisuke"

#property link      "http://mt4program.blogspot.jp/"

#property version   "1.10"

#property strict

#property indicator_chart_window



// ONE HOUR

#define ONEHOUR (60*60)

// OBJECT NAME

#define OBJECT_NAME_RANGE "OBJ_TIMERANGE"

// GMT offset of america

#define GMT_TO_AMERICA (-18000)



input int GMTOffset=2;// Gmt Offset 

input bool IsSummerTime=true;// Chart summer time enabled

                             // Black on White Colors

input color JapanColor=C'0xaa, 0xaa, 0xff';// Japan color

input color EuColor=C'0xff,0xff,0xaa';// EU color

input color AmericaColor=C'0xff, 0xaa, 0xaa';// America color

/*

// Green on Black Colors

input color JapanColor=C'0x11, 0x11, 0xbb';// Japan color

input color EuColor=C'0x40,0x40,0x0';// EU color

input color AmericaColor=C'0xaa, 0x0, 0x0';// America color

*/

//+------------------------------------------------------------------+

//| Initialize                                                       |

//+------------------------------------------------------------------+

int OnInit()

  {

   string short_name="TR";

   IndicatorShortName(short_name);



   return(INIT_SUCCEEDED);

  }

//+------------------------------------------------------------------+

//| DeInitialize                                                     |

//+------------------------------------------------------------------+

void OnDeinit(const int reason)

  {

   long chartId=ChartID();



   int total=ObjectsTotal(chartId);

   for(int i=total-1; i>=0; i--)

     {

      string name=ObjectName(chartId,i);



      if(StringFind(name,OBJECT_NAME_RANGE)==0)

        {

         ObjectDelete(chartId,name);

        }

     }

  }

//+------------------------------------------------------------------+

//| OnCalculate                                                      |

//+------------------------------------------------------------------+

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( Period() > PERIOD_H1 ) return rates_total;



   int i=0;

   while(!IsStopped() && i<(rates_total-prev_calculated))

     {

      bool includeTime=false;



      int offset=GMTOffset*ONEHOUR;

      if(IsSummerTime && IsAmericaSummerTime(time[i]))

        {

         offset+=ONEHOUR;

        }

      datetime gmt=time[i]-offset;



      datetime japan=gmt+9*ONEHOUR;



      MqlDateTime current;

      TimeToStruct(japan,current);



      MqlDateTime startStruct;

      startStruct.year= current.year;

      startStruct.mon = current.mon;

      startStruct.day = current.day;

      startStruct.hour= 9;

      startStruct.min = 0;

      startStruct.sec = 0;

      datetime start=StructToTime(startStruct);



      MqlDateTime endStruct;

      endStruct.year= current.year;

      endStruct.mon = current.mon;

      endStruct.day = current.day;

      endStruct.hour= 15;

      endStruct.min = 0;

      endStruct.sec = 0;

      datetime end=StructToTime(endStruct);



      if(start<=japan && japan<end)

        {

         datetime chartStart=start+offset-9*ONEHOUR;

         datetime chartEnd=end+offset-9*ONEHOUR;



         FourValue result = GetFourValue(Symbol(),PERIOD_M30,chartStart,chartEnd);

         if(result.close != 0 && result.open != 0 )

           {

            string name=GetObjectName("JP",japan);

            CreateRectangleObject(name,chartStart,chartEnd,result.high,result.low,JapanColor);

           }

         while(i<rates_total && time[i]>=chartStart) i++;

         includeTime=true;

        }



      int summerTimeOffset=0;

      if(IsEnglandSummerTime(gmt))

        {

         summerTimeOffset=ONEHOUR;

        }

      datetime eu=gmt+summerTimeOffset;



      TimeToStruct(eu,current);



      startStruct.year= current.year;

      startStruct.mon = current.mon;

      startStruct.day = current.day;

      startStruct.hour= 7;

      startStruct.min = 0;

      startStruct.sec = 0;

      start=StructToTime(startStruct);



      endStruct.year= current.year;

      endStruct.mon = current.mon;

      endStruct.day = current.day;

      endStruct.hour= 16;

      endStruct.min = 30;

      endStruct.sec = 0;

      end=StructToTime(endStruct);



      if(start<=eu && eu<end)

        {

         datetime chartStart=start+offset-summerTimeOffset;

         datetime chartEnd=end+offset-summerTimeOffset;



         FourValue result = GetFourValue(Symbol(),PERIOD_M30,chartStart,chartEnd);

         if(result.close != 0 && result.open != 0 )

           {

            string name=GetObjectName("EU",eu);

            CreateRectangleObject(name,chartStart,chartEnd,result.high,result.low,EuColor);

           }

         while(i<rates_total && time[i]>=chartStart) i++;

         includeTime=true;

        }



      summerTimeOffset=0;

      if(IsAmericaSummerTime(gmt))

        {

         summerTimeOffset=ONEHOUR;

        }

      datetime america=gmt+summerTimeOffset-5*ONEHOUR;



      TimeToStruct(america,current);



      startStruct.year= current.year;

      startStruct.mon = current.mon;

      startStruct.day = current.day;

      startStruct.hour= 9;

      startStruct.min = 0;

      startStruct.sec = 0;

      start=StructToTime(startStruct);



      endStruct.year= current.year;

      endStruct.mon = current.mon;

      endStruct.day = current.day;

      endStruct.hour= 16;

      endStruct.min = 00;

      endStruct.sec = 0;

      end=StructToTime(endStruct);



      if(start<=america && america<end)

        {

         datetime chartStart=start+offset+5*ONEHOUR-summerTimeOffset;

         datetime chartEnd=end+offset+5*ONEHOUR-summerTimeOffset;



         FourValue result = GetFourValue(Symbol(),PERIOD_M30,chartStart,chartEnd);

         if(result.close != 0 && result.open != 0 )

           {

            string name=GetObjectName("NY",eu);

            CreateRectangleObject(name,chartStart,chartEnd,result.high,result.low,AmericaColor);

           }

         while(i<rates_total && time[i]>=chartStart) i++;

         includeTime=true;

        }



      if(!includeTime) i++;

     }



   return(rates_total - 1);

  }

//+------------------------------------------------------------------+

//| Create Object Name                                               |

//+------------------------------------------------------------------+

string GetObjectName(string prefix,datetime localTime)

  {

   MqlDateTime current;

   TimeToStruct(localTime,current);



   MqlDateTime start;

   start.year= current.year;

   start.mon = current.mon;

   start.day = current.day;

   start.hour= 0;

   start.min = 0;

   start.sec = 0;



   return OBJECT_NAME_RANGE + prefix + TimeToString( StructToTime( start ) );

  }

//+------------------------------------------------------------------+

//| Draw Rectangle                                                   |

//+------------------------------------------------------------------+

bool CreateRectangleObject(string name,

                           datetime startTime,

                           datetime endTime,

                           double top,

                           double bottom,

                           color backColor)

  {

   long chartId=ChartID();



   int index=ObjectFind(chartId,name);

   if(index<0)

     {

      if(ObjectCreate(chartId,name,OBJ_RECTANGLE,0,startTime,top,endTime,bottom)==false)

        {

         return false;

        }

     }

   else

     {

      ObjectSetInteger(chartId,name,OBJPROP_TIME1,startTime);

      ObjectSetInteger(chartId,name,OBJPROP_TIME2,endTime);

      ObjectSetDouble(chartId,name,OBJPROP_PRICE1,top);

      ObjectSetDouble(chartId,name,OBJPROP_PRICE2,bottom);

     }

   ObjectSetInteger(chartId,name,OBJPROP_COLOR,backColor);

   return true;

  }

//+------------------------------------------------------------------+

//| America Summer Time                                              |

//+------------------------------------------------------------------+

bool IsAmericaSummerTime(datetime gmt)

  {

   datetime americaTime=gmt+GMT_TO_AMERICA;



   MqlDateTime dt;

   TimeToStruct(americaTime,dt);



   datetime startSummerTime;

   datetime endSummerTime;

   MqlDateTime work;

   int week;

   if(dt.year<2007)

     {

      work.year= dt.year;

      work.mon = 4;

      work.day = 1;

      work.hour= 2;

      work.min = 0;

      work.sec = 0;

      week=TimeDayOfWeek(StructToTime(work));



      if(week!=SUNDAY)

         work.day=work.day+7-week;

      startSummerTime=StructToTime(work);



      work.mon = 10;

      work.day = EndOfMonth(work.year, work.mon);

      work.hour= 2;

      work.min =  0;

      work.sec = 0;

      week=TimeDayOfWeek(StructToTime(work));

      work.day=work.day-week;



      endSummerTime=StructToTime(work);

     }

   else

     {

      work.year= dt.year;

      work.mon = 3;

      work.day = 8;

      work.hour= 2;

      work.min = 0;

      work.sec = 0;



      week=TimeDayOfWeek(StructToTime(work));

      if(week!=SUNDAY)

         work.day=work.day+7-week;

      startSummerTime=StructToTime(work);



      work.mon = 11;

      work.day = 1;

      work.hour= 2;

      work.min = 0;

      work.sec = 0;

      week=TimeDayOfWeek(StructToTime(work));

      if(week!=SUNDAY)

         work.day=work.day+7-week;

      endSummerTime=StructToTime(work);

     }



   return startSummerTime <= americaTime && americaTime < endSummerTime;

  }

//+------------------------------------------------------------------+

//| Eu Summer Time                                                   |

//+------------------------------------------------------------------+

bool IsEnglandSummerTime(datetime gmt)

  {

   datetime londonTime=gmt;



   MqlDateTime dt;

   TimeToStruct(londonTime,dt);



   datetime startSummerTime;

   datetime endSummerTime;

   MqlDateTime work;

   int week;



   work.year= dt.year;

   work.mon = 3;

   work.day = EndOfMonth(work.year, work.mon);;

   work.hour= 1;

   work.min = 0;

   work.sec = 0;

   week=TimeDayOfWeek(StructToTime(work));

   work.day=work.day-week;



   startSummerTime=StructToTime(work);



   work.mon = 10;

   work.day = EndOfMonth(work.year, work.mon);

   work.hour= 1;

   work.min = 0;

   work.sec = 0;

   week=TimeDayOfWeek(StructToTime(work));

   work.day=work.day-week;



   endSummerTime=StructToTime(work);



   return startSummerTime <= londonTime && londonTime < endSummerTime;

  }

//+------------------------------------------------------------------+

//| End Of Month                                                     |

//+------------------------------------------------------------------+

int EndOfMonth(int year,

               int month)

  {

   MqlDateTime work;

   work.year= year;

   work.mon = month + 1;

   work.day = 1;

   work.hour= 0;

   work.min = 0;

   work.sec = 0;



   if(work.mon>=13)

     {

      work.mon=1;

      work.year=work.year+1;

     }

   return TimeDay( StructToTime(work) - 1 );

  }

//+------------------------------------------------------------------+

//| Four Values                                                      |

//+------------------------------------------------------------------+

struct FourValue

  {

   double            open;

   double            close;

   double            high;

   double            low;

  };

//+------------------------------------------------------------------+

//| Get Time Zone Four Values                                        |

//+------------------------------------------------------------------+

FourValue GetFourValue(string symbol,

                       ENUM_TIMEFRAMES timeframe,

                       datetime startTime,

                       datetime endTime)

  {

   FourValue result;

   result.open=0;

   result.close= 0;

   result.high = 0;

   result.low=0;



   datetime lastTime=iTime(symbol,timeframe,0);

   int i=0;

   if(lastTime>endTime)

     {

      i=iBarShift(symbol,timeframe,endTime-PeriodSeconds(timeframe),true);

      if(i<0)

        {

         return result;

        }

     }



   i--;

   if(i<0) i=0;



   double close= 0;

   double open = 0;

   double low=iClose(symbol,timeframe,0)*1000;

   double high=0;

   while(!IsStopped())

     {

      datetime current=iTime(symbol,timeframe,i);

      if(current<=0) break;



      if(startTime<=current && current<endTime)

        {

         if(close==0) close=iClose(symbol,timeframe,i);

         open=iOpen(symbol,timeframe,i);

         double currentHigh= iHigh(symbol,timeframe,i);

         double currentLow = iLow(symbol,timeframe,i);



         if(low>currentLow) low=currentLow;

         if(high<currentHigh) high=currentHigh;

        }

      if(current<startTime) break;

      i++;

     }



   result.open=open;

   result.close= close;

   result.high = high;

   result.low=low;



   return result;

  }

//+------------------------------------------------------------------+