Pivot SuperTrend

#property version   "1.00"
#property description "Pivot-driven adaptive trend indicator with a weighted pivot center."

#property indicator_chart_window
#property indicator_buffers 15
#property indicator_plots   7

#property indicator_label1  "Pivot Trend Trail"
#property indicator_type1   DRAW_COLOR_LINE
#property indicator_color1  clrLime,clrRed,clrNONE
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2

#property indicator_label2  "Weighted Pivot Center"
#property indicator_type2   DRAW_COLOR_LINE
#property indicator_color2  clrDodgerBlue,clrTomato
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1

#property indicator_label3  "Confirmed Support"
#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrLime
#property indicator_width3  1

#property indicator_label4  "Confirmed Resistance"
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrRed
#property indicator_width4  1

#property indicator_label5  "Long Signal Price"
#property indicator_type5   DRAW_NONE
#property indicator_label6  "Short Signal Price"
#property indicator_type6   DRAW_NONE
#property indicator_label7  "Trend Direction"
#property indicator_type7   DRAW_NONE

input group "01. Pivot SuperTrend Engine"
input int     bclSwingRadius           = 2;             // Bars on each side of a confirmed pivot
input double  bclAtrMultiplier         = 3.0;           // ATR multiplier applied to the trend trail
input int     bclAtrPeriod             = 10;            // ATR calculation period

input group "02. Chart Presentation"
input bool    bclShowSwingMarks        = false;         // Show confirmed pivot-high and pivot-low marks
input bool    bclShowTradeTags         = true;          // Show BUY and SELL signal tags
input bool    bclShowCenterLine        = false;         // Show the weighted pivot center line
input bool    bclShowPivotLevels       = false;         // Show confirmed support and resistance levels
input int     bclHistoryBars           = 1500;          // Maximum history used for chart text objects
input int     bclTrendLineWidth        = 2;             // Trend trail line width
input int     bclTextSize              = 8;             // Pivot and signal text size

input group "03. Display Colors"
input color   bclBullTrailColor        = clrLime;       // Bullish trend trail color
input color   bclBearTrailColor        = clrRed;        // Bearish trend trail color
input color   bclCenterBelowPriceColor = clrDodgerBlue; // Center color when below the bar midpoint
input color   bclCenterAbovePriceColor = clrTomato;     // Center color when above the bar midpoint
input color   bclSupportColor          = clrLime;       // Confirmed support color
input color   bclResistanceColor       = clrRed;        // Confirmed resistance color
input color   bclBuyTagColor           = clrLime;       // BUY tag color
input color   bclSellTagColor          = clrRed;        // SELL tag color

input group "04. Signal Notifications"
input bool    bclEnablePopupAlert      = false;         // Enable terminal popup alerts
input bool    bclEnablePushAlert       = false;         // Enable mobile push notifications
input bool    bclEnableEmailAlert      = false;         // Enable email notifications
input bool    bclAlertOnClosedBar      = true;          // Generate alerts only from a closed candle

double bclTrailBuffer[];
double bclTrailColorBuffer[];
double bclCenterBuffer[];
double bclCenterColorBuffer[];
double bclSupportBuffer[];
double bclResistanceBuffer[];
double bclLongSignalBuffer[];
double bclShortSignalBuffer[];
double bclTrendDirectionBuffer[];

double bclCenterStateBuffer[];
double bclUpperTrailStateBuffer[];
double bclLowerTrailStateBuffer[];
double bclSupportStateBuffer[];
double bclResistanceStateBuffer[];
double bclActiveTrailStateBuffer[];

int      bclAtrHandle         = INVALID_HANDLE;
string   bclObjectPrefix      = "";
datetime bclLastBuyAlertTime  = 0;
datetime bclLastSellAlertTime = 0;

bool BclIsValidValue(const double bclValue)
  {
   return(bclValue != EMPTY_VALUE && MathIsValidNumber(bclValue));
  }

bool BclIsConfirmedPivotHigh(const double &bclHigh[],
                             const int bclCandidateBar,
                             const int bclRadius,
                             const int bclTotalBars)
  {
   if(bclCandidateBar - bclRadius < 0 ||
      bclCandidateBar + bclRadius >= bclTotalBars)
     {
      return(false);
     }

   const double bclCandidatePrice = bclHigh[bclCandidateBar];

   for(int bclOffset = 1; bclOffset <= bclRadius; bclOffset++)
     {
      if(bclHigh[bclCandidateBar - bclOffset] > bclCandidatePrice)
         return(false);
     }

   for(int bclOffset = 1; bclOffset <= bclRadius; bclOffset++)
     {
      if(bclHigh[bclCandidateBar + bclOffset] >= bclCandidatePrice)
         return(false);
     }

   return(true);
  }

bool BclIsConfirmedPivotLow(const double &bclLow[],
                            const int bclCandidateBar,
                            const int bclRadius,
                            const int bclTotalBars)
  {
   if(bclCandidateBar - bclRadius < 0 ||
      bclCandidateBar + bclRadius >= bclTotalBars)
     {
      return(false);
     }

   const double bclCandidatePrice = bclLow[bclCandidateBar];

   for(int bclOffset = 1; bclOffset <= bclRadius; bclOffset++)
     {
      if(bclLow[bclCandidateBar - bclOffset] < bclCandidatePrice)
         return(false);
     }

   for(int bclOffset = 1; bclOffset <= bclRadius; bclOffset++)
     {
      if(bclLow[bclCandidateBar + bclOffset] <= bclCandidatePrice)
         return(false);
     }

   return(true);
  }

void BclSetTextMarker(const string bclObjectName,
                      const datetime bclMarkerTime,
                      const double bclMarkerPrice,
                      const string bclMarkerText,
                      const color bclMarkerColor,
                      const ENUM_ANCHOR_POINT bclAnchor)
  {
   if(ObjectFind(0, bclObjectName) < 0)
     {
      if(!ObjectCreate(0,
                       bclObjectName,
                       OBJ_TEXT,
                       0,
                       bclMarkerTime,
                       bclMarkerPrice))
        {
         return;
        }
     }
   else
     {
      if(!ObjectMove(0,
                     bclObjectName,
                     0,
                     bclMarkerTime,
                     bclMarkerPrice))
        {
         return;
        }
     }

   ObjectSetString(0,
                   bclObjectName,
                   OBJPROP_TEXT,
                   bclMarkerText);

   ObjectSetString(0,
                   bclObjectName,
                   OBJPROP_FONT,
                   "Arial");

   ObjectSetInteger(0,
                    bclObjectName,
                    OBJPROP_FONTSIZE,
                    bclTextSize);

   ObjectSetInteger(0,
                    bclObjectName,
                    OBJPROP_COLOR,
                    bclMarkerColor);

   ObjectSetInteger(0,
                    bclObjectName,
                    OBJPROP_ANCHOR,
                    bclAnchor);

   ObjectSetInteger(0,
                    bclObjectName,
                    OBJPROP_SELECTABLE,
                    false);

   ObjectSetInteger(0,
                    bclObjectName,
                    OBJPROP_SELECTED,
                    false);

   ObjectSetInteger(0,
                    bclObjectName,
                    OBJPROP_HIDDEN,
                    true);

   ObjectSetInteger(0,
                    bclObjectName,
                    OBJPROP_BACK,
                    false);
  }

void BclDeleteFeatureObjects(const string bclFeaturePrefix)
  {
   ObjectsDeleteAll(0, bclObjectPrefix + bclFeaturePrefix);
  }

void BclSendSignalAlert(const string bclSignalName,
                        const datetime bclSignalTime,
                        const double bclSignalPrice)
  {
   const string bclTimeframeName =
      EnumToString((ENUM_TIMEFRAMES)_Period);

   const string bclMessage =
      StringFormat("%s %s | %s | Price: %s | %s",
                   _Symbol,
                   bclTimeframeName,
                   bclSignalName,
                   DoubleToString(bclSignalPrice, _Digits),
                   TimeToString(bclSignalTime,
                                TIME_DATE | TIME_MINUTES));

   if(bclEnablePopupAlert)
      Alert(bclMessage);

   if(bclEnablePushAlert)
      SendNotification(bclMessage);

   if(bclEnableEmailAlert)
     {
      SendMail("BhanuCodeLab Pivot Trend Signal",
               bclMessage);
     }
  }

void BclProcessLatestAlert(const int bclRatesTotal,
                           const datetime &bclTime[])
  {
   if(!bclEnablePopupAlert &&
      !bclEnablePushAlert &&
      !bclEnableEmailAlert)
     {
      return;
     }

   const int bclSignalBar =
      bclAlertOnClosedBar
      ? bclRatesTotal - 2
      : bclRatesTotal - 1;

   if(bclSignalBar < 1)
      return;

   if(BclIsValidValue(bclLongSignalBuffer[bclSignalBar]) &&
      bclLastBuyAlertTime != bclTime[bclSignalBar])
     {
      bclLastBuyAlertTime = bclTime[bclSignalBar];

      BclSendSignalAlert("BUY signal",
                         bclTime[bclSignalBar],
                         bclLongSignalBuffer[bclSignalBar]);
     }

   if(BclIsValidValue(bclShortSignalBuffer[bclSignalBar]) &&
      bclLastSellAlertTime != bclTime[bclSignalBar])
     {
      bclLastSellAlertTime = bclTime[bclSignalBar];

      BclSendSignalAlert("SELL signal",
                         bclTime[bclSignalBar],
                         bclShortSignalBuffer[bclSignalBar]);
     }
  }

bool BclValidateInputs()
  {
   if(bclSwingRadius < 1 || bclSwingRadius > 50)
     {
      Print("Swing radius must be between 1 and 50.");
      return(false);
     }

   if(bclAtrMultiplier < 0.1 || bclAtrPeriod < 1)
     {
      Print("ATR multiplier and ATR period must be positive.");
      return(false);
     }

   if(bclHistoryBars < 100)
     {
      Print("History bars must be at least 100.");
      return(false);
     }

   if(bclTrendLineWidth < 1 || bclTrendLineWidth > 5)
     {
      Print("Trend line width must be between 1 and 5.");
      return(false);
     }

   if(bclTextSize < 6 || bclTextSize > 20)
     {
      Print("Text size must be between 6 and 20.");
      return(false);
     }

   return(true);
  }

bool BclConfigureBuffers()
  {
   if(!SetIndexBuffer(0,
                      bclTrailBuffer,
                      INDICATOR_DATA) ||
      !SetIndexBuffer(1,
                      bclTrailColorBuffer,
                      INDICATOR_COLOR_INDEX) ||
      !SetIndexBuffer(2,
                      bclCenterBuffer,
                      INDICATOR_DATA) ||
      !SetIndexBuffer(3,
                      bclCenterColorBuffer,
                      INDICATOR_COLOR_INDEX) ||
      !SetIndexBuffer(4,
                      bclSupportBuffer,
                      INDICATOR_DATA) ||
      !SetIndexBuffer(5,
                      bclResistanceBuffer,
                      INDICATOR_DATA) ||
      !SetIndexBuffer(6,
                      bclLongSignalBuffer,
                      INDICATOR_DATA) ||
      !SetIndexBuffer(7,
                      bclShortSignalBuffer,
                      INDICATOR_DATA) ||
      !SetIndexBuffer(8,
                      bclTrendDirectionBuffer,
                      INDICATOR_DATA) ||
      !SetIndexBuffer(9,
                      bclCenterStateBuffer,
                      INDICATOR_CALCULATIONS) ||
      !SetIndexBuffer(10,
                      bclUpperTrailStateBuffer,
                      INDICATOR_CALCULATIONS) ||
      !SetIndexBuffer(11,
                      bclLowerTrailStateBuffer,
                      INDICATOR_CALCULATIONS) ||
      !SetIndexBuffer(12,
                      bclSupportStateBuffer,
                      INDICATOR_CALCULATIONS) ||
      !SetIndexBuffer(13,
                      bclResistanceStateBuffer,
                      INDICATOR_CALCULATIONS) ||
      !SetIndexBuffer(14,
                      bclActiveTrailStateBuffer,
                      INDICATOR_CALCULATIONS))
     {
      Print("Failed to bind one or more indicator buffers. Error: ",
            GetLastError());

      return(false);
     }

   ArraySetAsSeries(bclTrailBuffer, false);
   ArraySetAsSeries(bclTrailColorBuffer, false);
   ArraySetAsSeries(bclCenterBuffer, false);
   ArraySetAsSeries(bclCenterColorBuffer, false);
   ArraySetAsSeries(bclSupportBuffer, false);
   ArraySetAsSeries(bclResistanceBuffer, false);
   ArraySetAsSeries(bclLongSignalBuffer, false);
   ArraySetAsSeries(bclShortSignalBuffer, false);
   ArraySetAsSeries(bclTrendDirectionBuffer, false);
   ArraySetAsSeries(bclCenterStateBuffer, false);
   ArraySetAsSeries(bclUpperTrailStateBuffer, false);
   ArraySetAsSeries(bclLowerTrailStateBuffer, false);
   ArraySetAsSeries(bclSupportStateBuffer, false);
   ArraySetAsSeries(bclResistanceStateBuffer, false);
   ArraySetAsSeries(bclActiveTrailStateBuffer, false);

   return(true);
  }

void BclConfigurePlots()
  {
   PlotIndexSetInteger(0,
                       PLOT_LINE_WIDTH,
                       bclTrendLineWidth);

   PlotIndexSetInteger(0,
                       PLOT_LINE_COLOR,
                       0,
                       bclBullTrailColor);

   PlotIndexSetInteger(0,
                       PLOT_LINE_COLOR,
                       1,
                       bclBearTrailColor);

   PlotIndexSetInteger(0,
                       PLOT_LINE_COLOR,
                       2,
                       clrNONE);

   PlotIndexSetInteger(1,
                       PLOT_LINE_COLOR,
                       0,
                       bclCenterBelowPriceColor);

   PlotIndexSetInteger(1,
                       PLOT_LINE_COLOR,
                       1,
                       bclCenterAbovePriceColor);

   PlotIndexSetInteger(2,
                       PLOT_ARROW,
                       159);

   PlotIndexSetInteger(2,
                       PLOT_LINE_COLOR,
                       0,
                       bclSupportColor);

   PlotIndexSetInteger(2,
                       PLOT_SHIFT,
                       -bclSwingRadius);

   PlotIndexSetInteger(3,
                       PLOT_ARROW,
                       159);

   PlotIndexSetInteger(3,
                       PLOT_LINE_COLOR,
                       0,
                       bclResistanceColor);

   PlotIndexSetInteger(3,
                       PLOT_SHIFT,
                       -bclSwingRadius);

   for(int bclPlotIndex = 0;
       bclPlotIndex < 7;
       bclPlotIndex++)
     {
      PlotIndexSetDouble(bclPlotIndex,
            

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