HTF Candles

#property version     "1.00"
#property description "Higher timeframe candles next to your chart (ICT Power of Three): one or two timeframes,"
#property description "auto pairs (M15 -> H4 + D1 ...), live candle with lines to where its open, high and low were"
#property description "made, countdown, above / below open. Built from the chart's own candles. Alerts and buffers"
#property description "for EAs. Read-only: never trades."
#property indicator_chart_window
#property indicator_buffers 6
#property indicator_plots   6
#property indicator_type1   DRAW_NONE
#property indicator_label1  "HTF open"
#property indicator_type2   DRAW_NONE
#property indicator_label2  "HTF high so far"
#property indicator_type3   DRAW_NONE
#property indicator_label3  "HTF low so far"
#property indicator_type4   DRAW_NONE
#property indicator_label4  "Previous HTF high"
#property indicator_type5   DRAW_NONE
#property indicator_label5  "Previous HTF low"
#property indicator_type6   DRAW_NONE
#property indicator_label6  "Previous HTF close"

input ENUM_TIMEFRAMES InpTF1        = PERIOD_CURRENT;  // Higher timeframe 1 (current = auto)
input int             InpCount1     = 4;               // Finished candles of timeframe 1
input bool            InpUseTF2     = true;            // Show a second higher timeframe
input ENUM_TIMEFRAMES InpTF2        = PERIOD_CURRENT;  // Higher timeframe 2 (current = auto)
input int             InpCount2     = 3;               // Finished candles of timeframe 2
input int             InpCandlePx   = 14;              // Candle width (pixels, kept at every zoom)
input int             InpGapPx      = 6;               // Gap between candles (pixels)
input int             InpOffsetPx   = 24;              // Distance from the last chart candle (pixels)
input bool            InpOrigin     = true;            // Live candle: lines to its open / high / low
input bool            InpTimeLabels = true;            // Time under each candle
input bool            InpPrevHL     = false;           // Previous candle high / low on the chart (timeframe 1)
input bool            InpShift      = true;            // Turn chart shift on for room (restored on removal)
input int             InpBars       = 5000;            // Bars for the buffers
input color           InpBullColor  = C'38,166,154';   // Bullish candle colour
input color           InpBearColor  = C'239,83,80';    // Bearish candle colour
input color           InpWickColor  = clrDimGray;      // Wick colour
input color           InpLineColor  = clrDarkGray;     // Lines colour
input color           InpTextColor  = clrDimGray;      // Text colour
input bool            InpAlertNew   = false;           // Alert when a timeframe 1 candle opens
input bool            InpAlertOpen  = false;           // Alert when a candle closes across the timeframe 1 open
input bool            InpPush       = false;           // Alerts also as push notification
input bool            InpEmail      = false;           // Alerts also by e-mail

#define PREFIX    "HTFC_"
#define MAX_CNDL  12

struct HCandle
  {
   datetime          start;      // bucket start (server time)
   double            o;
   double            h;
   double            l;
   double            c;
   int               firstIdx;   // chart candles of the open, high and low
   int               hiIdx;
   int               loIdx;
  };

struct HSet
  {
   bool              on;
   ENUM_TIMEFRAMES   tf;
   int               count;      // finished candles to show
   int               n;          // candles found (finished + live)
   HCandle           c[MAX_CNDL];
  };

double   g_bOpen[], g_bHigh[], g_bLow[], g_bPrevH[], g_bPrevL[], g_bPrevC[];
HSet     g_set[2];

int      g_lastClosed = -1;
datetime g_closedTime = 0;
HCandle  g_cur, g_prev;
bool     g_hasCur = false, g_hasPrev = false;
bool     g_live = false;
datetime g_lastBar = 0;
uint     g_drawTick = 0;
bool     g_dirty = true;
string   g_drawn[];

bool     g_shiftSet = false;
long     g_oldShift = 0;
double   g_oldShiftSize = 0;

datetime g_alertNew = 0;
int      g_openSide = 0;

datetime g_mFrom = 0, g_mTo = 0;
bool     g_draw = true;               // false in a Strategy Tester run without visualization

int OnInit()
  {
      // код доступен только после оплаты
   }

void OnDeinit(const int reason)
  {
   ObjectsDeleteAll(0, PREFIX);
   if(g_shiftSet)
     {
      ChartSetInteger(0, CHART_SHIFT, g_oldShift);
      ChartSetDouble(0, CHART_SHIFT_SIZE, g_oldShiftSize);
     }
   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[])
  {
      // код доступен только после оплаты
   }

void AddCandle(const int k, const datetime t, const double o, const double h, const double l, const double c)
  {
   datetime bs = BucketStart(t, g_set[0].tf);
   if(!g_hasCur || bs != g_cur.start)
     {
      if(g_hasCur)
        {
         g_prev    = g_cur;
         g_hasPrev = true;
        }
      StartCandle(g_cur, bs, k, o, h, l, c);
      g_hasCur   = true;
      g_openSide = 0;
      return;
     }
   GrowCandle(g_cur, k, h, l, c);
  }

void StartCandle(HCandle &x, const datetime bs, const int k, const double o, const double h, const double l, const double c)
  {
   x.start    = bs;
   x.o        = o;
   x.h        = h;
   x.l        = l;
   x.c        = c;
   x.firstIdx = k;
   x.hiIdx    = k;
   x.loIdx    = k;
  }

void GrowCandle(HCandle &x, const int k, const double h, const double l, const double c)
  {
   if(h > x.h)
     {
      x.h     = h;
      x.hiIdx = k;
     }
   if(l < x.l)
     {
      x.l     = l;
      x.loIdx = k;
     }
   x.c = c;
  }

void SetBuffers(const int k, const HCandle &x, const bool prev)
  {
   g_bOpen[k]  = x.o;
   g_bHigh[k]  = x.h;
   g_bLow[k]   = x.l;
   g_bPrevH[k] = (prev ? g_prev.h : EMPTY_VALUE);
   g_bPrevL[k] = (prev ? g_prev.l : EMPTY_VALUE);
   g_bPrevC[k] = (prev ? g_prev.c : EMPTY_VALUE);
  }

void Collect(HSet &s, const datetime &time[], const double &open[], const double &high[], const double &low[],
             const double &close[], const int rates_total)
  {
   int      want = s.count + 1;
   HCandle  tmp[MAX_CNDL];
   int      n = 0;
   datetime bs = 0;
   bool     complete = false;
   for(int k = rates_total - 1; k >= 0; k--)
     {
      datetime b = BucketStart(time[k], s.tf);
      if(n == 0 || b != bs)
        {
         if(n == want)
           {
            complete = true;           // the oldest candle we keep has its first chart candle
            break;
           }
         bs = b;
         StartCandle(tmp[n], b, k, open[k], high[k], low[k], close[k]);
         n++;
         continue;
        }

      HCandle x = tmp[n - 1];
      if(high[k] >= x.h)
        {
         x.h     = high[k];
         x.hiIdx = k;
        }
      if(low[k] <= x.l)
        {
         x.l     = low[k];
         x.loIdx = k;
        }
      x.o        = open[k];
      x.firstIdx = k;
      tmp[n - 1] = x;
     }

   if(!

Показано первые 50% кода (символов: 17252)