Code Adjustment can't fix

New comment
 

Hello all, I have this indicator which draws resistance lines at the highs, lows, and closes of weekly, monthly, etc. periods. The lines are only drawn for the length of time that it is calculating, and I would like it to draw them with no end - like when you draw an ordinary line on mt4. I can't see how I would easily do this (not good at coding). Any help appreciated :) P.S, I do not own this indicator.


#property copyright "Copyright 2015, Alexandre Borela"
#property link ""
#property version "1.1"
#property strict
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 White
#property indicator_color2 White
#property indicator_color3 White
#property indicator_style1 STYLE_SOLID;
#property indicator_style2 STYLE_SOLID;
#property indicator_style3 STYLE_SOLID;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
enum AvailablePeriods
  {
   PreviousDay=PERIOD_D1,// Previous day
   PreviousWeek=PERIOD_W1,// Previous week
   PreviousMonth=PERIOD_MN1 // Previous month
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
struct TimeRange
  {
   bool Failed;
   datetime StartTime;
   datetime EndTime;

   TimeRange()
     {
      Failed=false;
      StartTime=0;
      EndTime=0;
     }
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
struct PeriodData
  {
   TimeRange PeriodRange;

   double PeriodHigh;
   double PeriodClose;
   double PeriodLow;

   PeriodData()
     {
      PeriodHigh=0;
      PeriodClose=0;
      PeriodLow=0;
     }
  };

input string _sepTimeShift=""; // /////// Calculation
input ENUM_TIMEFRAMES Precision=PERIOD_W1; // Precision
input AvailablePeriods TargetTimeFrame=PreviousWeek; // Period
input int PeriodsToCalculate=200; // Periods to calculate
input int HoursShift=2; // Hours shift
input int MinutesShift=0; // Minutes shift
input bool IgnoreSunday=true; // Ignore Sunday
input bool IgnoreSaturday=true; // Ignore Saturday

input string _sepBufferVisibility=""; // /////// Buffer visibility
input bool ShowHighBuffer=true; // High
input bool ShowCloseBuffer=false; // Close
input bool ShowLowBuffer=true; // Low

input string _sepProbeVisibility=""; // /////// Probe visibility
input bool ShowHighProbe=false; // High
input bool ShowCloseProbe=false; // Close
input bool ShowLowProbe=false; // Low

input string _sepProbeColor=""; // /////// Probe color
input color HighColor=C'83,173,52'; // High
input color CloseColor=C'83,173,52'; // Close
input color LowColor=C'83,173,52'; // Low

input string _sepProbeSize=""; // /////// Probe size
input int HighSize=1; // High
input int CloseSize=1; // Close
input int LowSize=1; // Low

input string _sepCustomLabel=""; // /////// Data window label
input string HighLabel="P.Day High"; // High
input string CloseLabel="P.Day Close"; // Close
input string LowLabel="P.Day Low"; // Low

string HighProbeName="HighPrevious"+IntegerToString(TargetTimeFrame)+IntegerToString(HoursShift)+IntegerToString(MinutesShift);
string CloseProbeName="ClosePrevious"+IntegerToString(TargetTimeFrame)+IntegerToString(HoursShift)+IntegerToString(MinutesShift);
string LowProbeName="LowPrevious"+IntegerToString(TargetTimeFrame)+IntegerToString(HoursShift)+IntegerToString(MinutesShift);

double PeriodHighBuffer[];
double PeriodCloseBuffer[];
double PeriodLowBuffer[];

PeriodData TempData;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
PeriodData CalculateCommonSRData(datetime targetTime,TimeRange &periodRange)
  {
   if(TempData.PeriodRange.StartTime==periodRange.StartTime &&
      TempData.PeriodRange.EndTime==periodRange.EndTime)
      return( TempData );

   PeriodData result;

   int firstBar= iBarShift(Symbol(),Precision,periodRange.StartTime);
   int lastBar = iBarShift(Symbol(),Precision,periodRange.EndTime);

   datetime firstBarTime= iTime(Symbol(),Precision,firstBar);
   datetime lastBarTime = iTime(Symbol(),Precision,lastBar);

   int startBar=lastBar;
   int bars=firstBar-lastBar+1;

   int highestBar= iHighest(Symbol(),Precision,MODE_HIGH,bars,startBar);
   int lowestBar = iLowest(Symbol(),Precision,MODE_LOW,bars,startBar);

   result.PeriodRange= periodRange;
   result.PeriodHigh = iHigh(Symbol(),Precision,highestBar);
   result.PeriodClose= iClose(Symbol(),Precision,lastBar);
   result.PeriodLow=iLow(Symbol(),Precision,lowestBar);

   TempData=result;
   return( result );
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
datetime MoveDateToEndOfDay(datetime target)
  {
   MqlDateTime targetTime;
   TimeToStruct(target,targetTime);

   targetTime.hour= 23;
   targetTime.min = 59;
   targetTime.sec = 59;

   return( StructToTime( targetTime ) );
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
datetime MoveDateToEndOfMonth(datetime target)
  {
   MqlDateTime targetTime;
   TimeToStruct(target,targetTime);

   targetTime.mon++;
   targetTime.day=1;
   targetTime.hour= 0;
   targetTime.min = 0;
   targetTime.sec = 0;

   return( StructToTime( targetTime ) - 1 );
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
datetime MoveDateToEndOfWeek(datetime target)
  {
   MqlDateTime targetTime;
   TimeToStruct(target,targetTime);

   targetTime.day += 5 - targetTime.day_of_week;
   targetTime.hour = 23;
   targetTime.min = 59;
   targetTime.sec = 59;

   return( StructToTime( targetTime ) );
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
TimeRange CalculateTargetTimeRange(datetime targetTime,AvailablePeriods targetPeriod,int periodShift,ENUM_TIMEFRAMES precision,int hoursShift,int minutesShift,bool ignoreSunday,bool ignoreSaturday)
  {
   TimeRange currentRange=CalculateTimeRange(targetTime,(ENUM_TIMEFRAMES)(int)targetPeriod,precision,0,hoursShift,minutesShift,ignoreSunday,ignoreSaturday);

   if(targetTime<currentRange.StartTime)
      periodShift++;

   if(targetTime>currentRange.EndTime)
      periodShift--;

   if(periodShift==0)
      return( currentRange );

   TimeRange target=CalculateTimeRange(targetTime,(ENUM_TIMEFRAMES)(int)targetPeriod,precision,periodShift,hoursShift,minutesShift,ignoreSunday,ignoreSaturday);
   return( target );
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
TimeRange CalculateTimeRange(datetime targetTime,ENUM_TIMEFRAMES targetPeriod,ENUM_TIMEFRAMES precision,int periodShift,int hoursShift,int minutesShift,bool ignoreSunday,bool ignoreSaturday)
  {
   if(targetPeriod<precision)
      precision=targetPeriod;

   TimeRange result;
   int totalShift=hoursShift*3600+minutesShift*60;

// Start time.
   int periodStartBar=iBarShift(Symbol(),targetPeriod,targetTime)+periodShift;
   datetime periodStartTime=iTime(Symbol(),targetPeriod,periodStartBar);

   int precisePeriodStartBar=iBarShift(Symbol(),precision,periodStartTime);
   datetime precisePeriodStartTime=iTime(Symbol(),precision,precisePeriodStartBar);

   if(precisePeriodStartTime==0)
      result.Failed=true;

   if(precisePeriodStartTime>periodStartTime)
     {
      precisePeriodStartTime=iTime(Symbol(),precision,precisePeriodStartBar+1);

      if(precisePeriodStartTime==0)
         result.Failed=true;
     }

   if(result.Failed)
      return( result );

   if(precisePeriodStartTime<periodStartTime)
      precisePeriodStartTime=MoveDateToEndOfDay(precisePeriodStartTime)+1;

   result.StartTime=precisePeriodStartTime;

// End time.
   int nextPeriodStartBar = periodStartBar - 1;
   if(nextPeriodStartBar >= 0 )
     {
      //        Exact calculation.
      datetime nextPeriodStartTime=iTime(Symbol(),targetPeriod,nextPeriodStartBar);

      int preciseNextPeriodStartBar=iBarShift(Symbol(),precision,nextPeriodStartTime);
      datetime preciseNextPeriodStartTime=iTime(Symbol(),precision,preciseNextPeriodStartBar);

      if(preciseNextPeriodStartTime==0)
         result.Failed=true;

      if(preciseNextPeriodStartTime>=nextPeriodStartTime)
        {
         preciseNextPeriodStartTime=iTime(Symbol(),precision,preciseNextPeriodStartBar+1);

         if(preciseNextPeriodStartTime==0)
            result.Failed=true;
        }

      if(result.Failed)
         return( result );

      if(preciseNextPeriodStartTime<nextPeriodStartTime)
         preciseNextPeriodStartTime=MoveDateToEndOfDay(preciseNextPeriodStartTime);

      if(TimeHour(preciseNextPeriodStartTime)==0)
         preciseNextPeriodStartTime--;

      result.EndTime=preciseNextPeriodStartTime;
     }
   else
     {
      //        Approximation.
      switch(targetPeriod)
        {
         case PERIOD_D1 :
            result.EndTime=MoveDateToEndOfDay(iTime(Symbol(),precision,0));
            break;
         case PERIOD_W1 :
            result.EndTime=MoveDateToEndOfWeek(iTime(Symbol(),precision,0));
            break;
         case PERIOD_MN1 :
            result.EndTime=MoveDateToEndOfMonth(iTime(Symbol(),precision,0));
            break;
        }
     }

// Resulting shifted time.
   result.StartTime+=totalShift;
   result.EndTime+=totalShift;

// Sunday and saturday fix.
   if(targetPeriod==PERIOD_D1)
     {
      if(TimeDayOfWeek(result.StartTime)==SUNDAY && ignoreSunday)
         result.StartTime-=86400;

      if(TimeDayOfWeek(result.EndTime)==SATURDAY && ignoreSaturday)
         result.EndTime+=86400;
     }

   return( result );
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawRightPriceProbe(int window,bool selectable,string name,int lineWidth,color lineColor,datetime date,double price,bool visible=true,int zorder=0,string tooltip="\n")
  {
   bool create=false;
   int foundAtWindow=ObjectFind(ChartID(),name);

   if(foundAtWindow<0)
      create=true;

   if(foundAtWindow>=0 && window!=foundAtWindow)
     {
      ObjectDelete(ChartID(),name);
      create=true;
     }

   if(!create)
     {
      ObjectSetInteger(ChartID(),name,OBJPROP_TIME,date);
      ObjectSetDouble(ChartID(),name,OBJPROP_PRICE,price);
     }
   else
      ObjectCreate(ChartID(),name,OBJ_ARROW_RIGHT_PRICE,window,date,price);

   ObjectSetInteger(ChartID(),name,OBJPROP_COLOR,lineColor);
   ObjectSetInteger(ChartID(),name,OBJPROP_WIDTH,lineWidth);
   ObjectSetInteger(ChartID(),name,OBJPROP_HIDDEN,!selectable);
   ObjectSetInteger(ChartID(),name,OBJPROP_SELECTABLE,selectable);

   if(!visible)
      ObjectSetInteger(ChartID(),name,OBJPROP_TIMEFRAMES,OBJ_NO_PERIODS);

   ObjectSetInteger(ChartID(),name,OBJPROP_ZORDER,zorder);
   ObjectSetString(ChartID(),name,OBJPROP_TOOLTIP,tooltip);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ObjectDelete(ChartID(),HighProbeName);
   ObjectDelete(ChartID(),CloseProbeName);
   ObjectDelete(ChartID(),LowProbeName);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int OnInit()
  {
   SetIndexStyle(0,DRAW_LINE);
   SetIndexStyle(1,DRAW_LINE);
   SetIndexStyle(2,DRAW_LINE);

   SetIndexBuffer(0,PeriodHighBuffer);
   SetIndexBuffer(1,PeriodCloseBuffer);
   SetIndexBuffer(2,PeriodLowBuffer);

   SetIndexLabel(0,HighLabel);
   SetIndexLabel(1,CloseLabel);
   SetIndexLabel(2,LowLabel);

   return( INIT_SUCCEEDED );
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
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()>=TargetTimeFrame)
      return( rates_total );

   int total=rates_total-prev_calculated;

   if(total>0)
     {
      int i = -1;
      int n = ( total + 7 ) / 8;
      int remainingPeriods=PeriodsToCalculate;

      PeriodData currentData;
      TimeRange currentTimeRange;
      TimeRange previousTimeRange;

      switch(total%8)
        {
         case 0 : OnCalculateStep( currentData, currentTimeRange, previousTimeRange, remainingPeriods, time, ++i );
         case 7 : OnCalculateStep( currentData, currentTimeRange, previousTimeRange, remainingPeriods, time, ++i );
         case 6 : OnCalculateStep( currentData, currentTimeRange, previousTimeRange, remainingPeriods, time, ++i );
         case 5 : OnCalculateStep( currentData, currentTimeRange, previousTimeRange, remainingPeriods, time, ++i );
         case 4 : OnCalculateStep( currentData, currentTimeRange, previousTimeRange, remainingPeriods, time, ++i );
         case 3 : OnCalculateStep( currentData, currentTimeRange, previousTimeRange, remainingPeriods, time, ++i );
         case 2 : OnCalculateStep( currentData, currentTimeRange, previousTimeRange, remainingPeriods, time, ++i );
         case 1 : OnCalculateStep( currentData, currentTimeRange, previousTimeRange, remainingPeriods, time, ++i );
        }

      while(--n>0)
        {
         OnCalculateStep(currentData,currentTimeRange,previousTimeRange,remainingPeriods,time,++i);
         OnCalculateStep(currentData,currentTimeRange,previousTimeRange,remainingPeriods,time,++i);
         OnCalculateStep(currentData,currentTimeRange,previousTimeRange,remainingPeriods,time,++i);
         OnCalculateStep(currentData,currentTimeRange,previousTimeRange,remainingPeriods,time,++i);
         OnCalculateStep(currentData,currentTimeRange,previousTimeRange,remainingPeriods,time,++i);
         OnCalculateStep(currentData,currentTimeRange,previousTimeRange,remainingPeriods,time,++i);
         OnCalculateStep(currentData,currentTimeRange,previousTimeRange,remainingPeriods,time,++i);
         OnCalculateStep(currentData,currentTimeRange,previousTimeRange,remainingPeriods,time,++i);
        }

      if(total==1)
        {
         TimeRange olderBarRange=CalculateTargetTimeRange(time[1],TargetTimeFrame,1,Precision,HoursShift,MinutesShift,IgnoreSunday,IgnoreSaturday);

         if(olderBarRange.StartTime!=currentTimeRange.StartTime)
           {
            PeriodHighBuffer[1]=EMPTY_VALUE;
            PeriodCloseBuffer[1]=EMPTY_VALUE;
            PeriodLowBuffer[1]=EMPTY_VALUE;
           }
        }
     }

   if(total>0 || prev_calculated>0)
     {
      if(ShowHighProbe && ShowHighBuffer)
         DrawRightPriceProbe(
                             ChartWindowFind(),
                             false,
                             HighProbeName,
                             HighSize,
                             HighColor,
                             time[0],
                             PeriodHighBuffer[0]
                             );

      if(ShowCloseProbe && ShowCloseBuffer)
         DrawRightPriceProbe(
                             ChartWindowFind(),
                             false,
                             CloseProbeName,
                             CloseSize,
                             CloseColor,
                             time[0],
                             PeriodCloseBuffer[0]
                             );

      if(ShowLowProbe && ShowLowBuffer)
         DrawRightPriceProbe(
                             ChartWindowFind(),
                             false,
                             LowProbeName,
                             LowSize,
                             LowColor,
                             time[0],
                             PeriodLowBuffer[0]
                             );
     }

   return( rates_total );
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnCalculateStep(PeriodData &currentData,TimeRange &currentTimeRange,TimeRange &previousTimeRange,int &remainingPeriods,const datetime &time[],int i)
  {
   if(currentTimeRange.Failed || remainingPeriods<1)
     {
      PeriodHighBuffer[i]=EMPTY_VALUE;
      PeriodCloseBuffer[i]=EMPTY_VALUE;
      PeriodLowBuffer[i]=EMPTY_VALUE;
      return;
     }

   currentTimeRange=CalculateTargetTimeRange(time[i],TargetTimeFrame,1,Precision,HoursShift,MinutesShift,IgnoreSunday,IgnoreSaturday);

   if(i==0)
     {
      currentData=CalculateCommonSRData(time[i],currentTimeRange);
      previousTimeRange=currentTimeRange;
     }

   if(previousTimeRange.StartTime==currentTimeRange.StartTime)
     {
      if(ShowHighBuffer)
         PeriodHighBuffer[i]=currentData.PeriodHigh;

      if(ShowCloseBuffer)
         PeriodCloseBuffer[i]=currentData.PeriodClose;

      if(ShowLowBuffer)
         PeriodLowBuffer[i]=currentData.PeriodLow;
     }
   else
     {
      PeriodHighBuffer[i]=EMPTY_VALUE;
      PeriodCloseBuffer[i]=EMPTY_VALUE;
      PeriodLowBuffer[i]=EMPTY_VALUE;

      if(--remainingPeriods<1)
         return;

      currentData=CalculateCommonSRData(time[i],currentTimeRange);
     }

   previousTimeRange=currentTimeRange;
  }
//+------------------------------------------------------------------+
New comment
Reason: