I will code your EAs and Indicators for no charge

Quoting MwlRCT

Disliked

{quote} --- Download v1.06: {file}

Ignored

Quoting walvekarraje

Disliked

{quote} The beauty of the dashboard is that i can have different Lb settings for all timeframes on one dashboard.{image} Eagerly waiting Sir,

Ignored

Quoting MwlRCT

Disliked

{quote} Waiting For your "input" Check PM

Ignored

Quoting MwlRCT

Disliked

{quote} Waiting For your "input" Check PM

Ignored

/*--------------------------------------------------------------------
Change-log: BRI
Date: 27-02-2025
By: MwlRCT
FileName: 'BRI V.11.mq4'
--------------------------------------------------------------------
- [Added] Input parameter 'TimeFrame' to allow drawing imbalance lines based on a user-defined timeframe, independent of the chart timeframe.
-        This enhancement enables Multi-TimeFrame (MTF) analysis and visualization of imbalance levels from different timeframes on a single chart.
--------------------------------------------------------------------*/

 //+------------------------------------------------------------------+
//|                                                          BRI.mq4 |
//| Credit:                                                          |
//| Some code borrowed from:                                         |
//|   * RSI Colors (Bar Color part)                                  |
//|   * Candle Pip Size Indicator                                    |
//|   * Imbalance Trading idea from Bluerain of FF                   |
//|     (https://www.forexfactory.com/Bluerain)                      |
//| Changes:                                                         |
//|   * Change 3: 2nd line is now closing retracing                 |
//|   * Change 4: 4/22/2020 - Added extra condition to measure      |
//|               Range and Candle HH/LL                             |
//|   * Change 5: 27-02-2025 | Added TimeFrame parameter for independent drawing  |
//|              timeframe and robust object cleanup                 |
//|   * Change 6: Fixed infinite line extension issue.               |
//|               Corrected futureTime calculation and set isRay=false|
//+------------------------------------------------------------------+
/*--------------------------------------------------------------------
Change-log: BRI
Date: 27-02-2025
By: MwlRCT
URL: https://www.forexfactory.com/mwlrct
FileName: 'BRI V.11.mq4'
--------------------------------------------------------------------
- [Added] Input parameter 'TimeFrame' to allow drawing imbalance lines based on a user-defined timeframe, independent of the chart timeframe.
-        This enhancement enables Multi-TimeFrame (MTF) analysis and visualization of imbalance levels from different timeframes on a single chart.
--------------------------------------------------------------------*/
#property copyright "mer071898"
#property link      "https://www.forexfactory.com/mer071898"
#property description "BRI (Blue Rain Imbalance)"
#property description "Draws lines on top and bottom zones of imbalance candles."
#property description "Tool can be used to trade Market Maker (MM) strategies."
#property description "BRI_v11 Fixed Line Length"
#property indicator_chart_window
#property indicator_buffers 6
#property indicator_color1 DarkBlue    // Wick (up)
#property indicator_color2 FireBrick   // Wick (down)
#property indicator_color3 DarkBlue    // Candle (up)
#property indicator_color4 FireBrick   // Candle (down)
#property indicator_color5 FireBrick   // Arrow up
#property indicator_color6 DarkBlue    // Arrow down
#property indicator_width1 1
#property indicator_width2 1
#property indicator_width3 3
#property indicator_width4 3
#property strict
//=== CANDLE SETTINGS ===
input string sep_CandleSettings = "=== CANDLE SETTINGS ==="; // —————————————————————
input int    TimeFrame           = 30;     // Drawing timeframe (0 = current, 1 = M1, 5 = M5, etc.)
input int    BarMaxLimit           = 2000;  // Max bars to process
input double MinimumPipSize        = 50;    // Minimum pip size for imbalance (e.g., 50 pips)
input bool   Use_AutoAveragePipSize  = true;  // Use ATR for pip size filter
input int    ATRperiod             = 144;   // ATR period for averaging pip size
input double AutoPipSizeMultiplier  = 1.0;   // Multiplier for ATR-based pip size
//=== PIP TEXT SETTINGS ===
input string sep_PipTextSettings = "=== PIP TEXT SETTINGS ==="; // —————————————————————
input color PipTextColor          = clrMagenta; // Color for pip size text
input int   PipTextAngle          = 60;         // Angle for pip size text display
//=== LINE SETTINGS ===
input string sep_LineSettings = "=== LINE SETTINGS ==="; // —————————————————————
input int             MinBarDistance  = 2;           // Minimum bars between imbalance lines
input int             HLLineThickness = 2;           // Thickness of horizontal lines
input ENUM_LINE_STYLE Line1Style      = STYLE_SOLID; // Style for primary imbalance lines
input ENUM_LINE_STYLE Line2Style      = STYLE_DOT;   // Style for secondary lines
//=== DISPLAY OPTIONS ===
input string sep_DisplayOptions = "=== DISPLAY OPTIONS ==="; // —————————————————————
input bool HideCandleColors      = true;  // Hide candle body colors if true
input bool HideBlockedLines      = false; // Hide blocked imbalance lines if true
input bool HideSecondaryLines    = true;  // Hide secondary lines if true
input bool ShowImbalancePipSize  = false; // Show pip size for imbalance candles
input bool ShowAllPipSizes       = false; // Show pip size for all candles
input bool ShowArrows            = true;  // Display arrows at imbalance points
//=== ALERT SETTINGS ===
input string sep_AlertSettings = "=== ALERT SETTINGS ==="; // —————————————————————
input bool   AlertsOn            = false; // Enable price alerts
input bool   AlertsOnCurrentBar  = false; // Alert on current bar if true
input bool   AlertsMessage       = false; // Show alert pop-up messages
input bool   AlertsNotification  = false; // Send push notifications
input bool   AlertsSound         = false; // Play alert sound
input bool   AlertsEmail         = false; // Send alert email
//--- Global Variables
int    BarWidth             = 1;                    // Width for wick histograms
int    CandleWidth          = 3;                    // Width for candle histograms
double Bar1[], Bar2[],                              // Buffers for wick histograms (up/down)
       Candle1[], Candle2[],                        // Buffers for candle histograms (up/down)
       ArrowUp[], ArrowDn[],                        // Buffers for arrow markers
       BRILinesUp[], BRILinesDown[];                // Buffers storing imbalance line prices
string BRIIdentifier        = "BRI_";               // Prefix for all indicator objects
double AvgPipSize;                                  // Average pip size based on ATR
datetime PrevTime           = 0;                    // Tracks last processed bar time
color  LineColor            = clrAqua;              // Default color for lines
double PointValue           = Point;                // Adjusted point value for digits
int    TimeOffset           = 0;                    // Time offset (not used currently)
int    EffectiveTimeframe   = 0;                    // Effective timeframe for calculations
//+------------------------------------------------------------------+
//| Initialization Function                                          |
//+------------------------------------------------------------------+
int init()
{
   IndicatorShortName("BRI");
   IndicatorBuffers(8); // Total buffers: 6 visible + 2 for line prices
   // Assign indicator buffers
   SetIndexBuffer(0, Bar1);         SetIndexLabel(0, "Wick Up");
   SetIndexBuffer(1, Bar2);         SetIndexLabel(1, "Wick Down");
   SetIndexBuffer(2, Candle1);      SetIndexLabel(2, "Candle Up");
   SetIndexBuffer(3, Candle2);      SetIndexLabel(3, "Candle Down");
   SetIndexBuffer(4, ArrowUp);      SetIndexLabel(4, "Arrow Up");
   SetIndexBuffer(5, ArrowDn);      SetIndexLabel(5, "Arrow Down");
   SetIndexBuffer(6, BRILinesUp);   SetIndexLabel(6, "Lines Up");
   SetIndexBuffer(7, BRILinesDown); SetIndexLabel(7, "Lines Down");
   // Set drawing styles
   SetIndexStyle(0, DRAW_HISTOGRAM, EMPTY, BarWidth);
   SetIndexStyle(1, DRAW_HISTOGRAM, EMPTY, BarWidth);
   SetIndexStyle(2, DRAW_HISTOGRAM, EMPTY, CandleWidth);
   SetIndexStyle(3, DRAW_HISTOGRAM, EMPTY, CandleWidth);
   SetIndexStyle(4, DRAW_ARROW, EMPTY, 1);
   SetIndexStyle(5, DRAW_ARROW, EMPTY, 1);
   SetIndexArrow(4, 119); // Wingding upward arrow
   SetIndexArrow(5, 119); // Wingding downward arrow
   SetIndexStyle(6, DRAW_NONE); // Hidden buffer for line prices
   SetIndexStyle(7, DRAW_NONE); // Hidden buffer for line prices
   // Set empty values to prevent unwanted drawing
   SetIndexEmptyValue(0, EMPTY_VALUE);
   SetIndexEmptyValue(1, EMPTY_VALUE);
   SetIndexEmptyValue(2, EMPTY_VALUE);
   SetIndexEmptyValue(3, EMPTY_VALUE);
   SetIndexEmptyValue(4, EMPTY_VALUE);
   SetIndexEmptyValue(5, EMPTY_VALUE);
   SetIndexEmptyValue(6, EMPTY_VALUE);
   SetIndexEmptyValue(7, EMPTY_VALUE);
   // Configure arrays as timeseries
   ArraySetAsSeries(ArrowUp, true);
   ArraySetAsSeries(ArrowDn, true);
   // Disable arrows if ShowArrows is false
   if (!ShowArrows)
   {
      SetIndexStyle(4, DRAW_NONE);
      SetIndexStyle(5, DRAW_NONE);
   }
   // Adjust PointValue for 3 or 5 digit brokers
   if (Digits == 3 || Digits == 5)
      PointValue = Point * 10;
   DeleteObjects(); // Ensure a clean slate on initialization
   return(0);
}
//+------------------------------------------------------------------+
//| Deinitialization Function                                        |
//+------------------------------------------------------------------+
int deinit()
{
   DeleteObjects(); // Clean up all objects when indicator is removed
   return(0);
}
//+------------------------------------------------------------------+
//| Main Iteration Function                                          |
//+------------------------------------------------------------------+
int start()
{
   // Set effective timeframe: use chart's timeframe if TimeFrame is 0
   EffectiveTimeframe = (TimeFrame == 0) ? _Period : TimeFrame;
   DeleteObjects(); // Remove existing objects before redrawing
   // Calculate average pip size using ATR on specified timeframe
   AvgPipSize = iATR(Symbol(), EffectiveTimeframe, ATRperiod, 0) / PointValue;
   double thresholdPipSize = Use_AutoAveragePipSize ? AvgPipSize * AutoPipSizeMultiplier : MinimumPipSize;
   // Display ATR labels on chart
   ObjectCreate(BRIIdentifier + "AvgLabel", OBJ_LABEL, 0, 0, 0);
   ObjectSet(BRIIdentifier + "AvgLabel", OBJPROP_CORNER, CORNER_RIGHT_LOWER);
   ObjectSet(BRIIdentifier + "AvgLabel", OBJPROP_XDISTANCE, 85);
   ObjectSet(BRIIdentifier + "AvgLabel", OBJPROP_YDISTANCE, 20);
   ObjectSetText(BRIIdentifier + "AvgLabel", " ATR ", 10, "Arial", clrWhite);
   ObjectCreate(BRIIdentifier + "AvgValue", OBJ_LABEL, 0, 0, 0);
   ObjectSet(BRIIdentifier + "AvgValue", OBJPROP_CORNER, CORNER_RIGHT_LOWER);
   ObjectSet(BRIIdentifier + "AvgValue", OBJPROP_XDISTANCE, 5);
   ObjectSet(BRIIdentifier + "AvgValue", OBJPROP_YDISTANCE, 20);
   ObjectSetText(BRIIdentifier + "AvgValue", DoubleToStr(AvgPipSize, 2), 10, "Arial", clrWhite);
   // Show pip sizes for all bars if enabled
   if (ShowAllPipSizes)
   {
      for (int i = 0; i < BarMaxLimit && i < Bars; i++)
         DrawPipNumbers(i, MathAbs(High[i] - Low[i]) / PointValue);
   }
   // Determine number of bars on specified timeframe, capped by BarMaxLimit
   int bars_tf = MathMin(iBars(Symbol(), EffectiveTimeframe), BarMaxLimit);
   // Process bars on the specified timeframe
   for (int i_tf = 0; i_tf < bars_tf; i_tf++)
   {
      datetime time_tf = iTime(Symbol(), EffectiveTimeframe, i_tf);
      int i = iBarShift(Symbol(), 0, time_tf, false); // Map to current chart
      if (i >= Bars) continue; // Skip if bar index is out of range
      double range = 0;
      // Calculate imbalance range based on candle direction
      if (IsUpCandle(i_tf, EffectiveTimeframe) && IsHigherHighCandle(i_tf, EffectiveTimeframe))
         range = MathAbs(iHigh(Symbol(), EffectiveTimeframe, i_tf) - iHigh(Symbol(), EffectiveTimeframe, i_tf + 1)) / PointValue;
      else if (!IsUpCandle(i_tf, EffectiveTimeframe) && IsLowerLowCandle(i_tf, EffectiveTimeframe))
         range = MathAbs(iLow(Symbol(), EffectiveTimeframe, i_tf + 1) - iLow(Symbol(), EffectiveTimeframe, i_tf)) / PointValue;
      // Identify imbalance if range exceeds threshold
      if (range > thresholdPipSize)
      {
         if (ShowImbalancePipSize)
         {
            double pipSize = MathAbs(iHigh(Symbol(), EffectiveTimeframe, i_tf) - iLow(Symbol(), EffectiveTimeframe, i_tf)) / PointValue;
            DrawPipNumbers(i, pipSize);
         }
         if (IsUpCandle(i_tf, EffectiveTimeframe))
         {
            if (!HideCandleColors) SetImbalanceCandleColor(1, i);
            DrawImbalanceLine(1, i_tf, EffectiveTimeframe);
         }
         else
         {
            if (!HideCandleColors) SetImbalanceCandleColor(2, i);
            DrawImbalanceLine(2, i_tf, EffectiveTimeframe);
         }
      }
   }
   // Handle price alerts for imbalance lines
   if (AlertsOn)
   {
      for (int i = 0; i < BarMaxLimit && i < Bars; i++)
      {
         if (BRILinesUp[i] != EMPTY_VALUE && Close[0] >= BRILinesUp[i])
         {
            string msg = StringConcatenate(Symbol(), ", ", TimeframeToString(EffectiveTimeframe), " BRI ",
                                          "Price Reached Imbalance Line Up @ ",
                                          TimeToStr(TimeLocal(), TIME_SECONDS));
            DoAlert(i, msg);
         }
         else if (BRILinesDown[i] != EMPTY_VALUE && Close[0] <= BRILinesDown[i])
         {
            string msg = StringConcatenate(Symbol(), ", ", TimeframeToString(EffectiveTimeframe), " BRI ",
                                          "Price Reached Imbalance Line Down @ ",
                                          TimeToStr(TimeLocal(), TIME_SECONDS));
            DoAlert(i, msg);
         }
      }
   }
   WindowRedraw();
   ManageAlerts();
   return(0);
}
//+------------------------------------------------------------------+
//| Helper Functions                                                 |
//+------------------------------------------------------------------+
// Check if candle is bullish on specified timeframe
bool IsUpCandle(int i_tf, int timeframe)
{
   if (i_tf >= iBars(Symbol(), timeframe)) return false;
   return iClose(Symbol(), timeframe, i_tf) > iOpen(Symbol(), timeframe, i_tf);
}
// Check if candle has a higher high
bool IsHigherHighCandle(int i_tf, int timeframe)
{
   if (i_tf + 1 >= iBars(Symbol(), timeframe)) return false;
   return iHigh(Symbol(), timeframe, i_tf) > iHigh(Symbol(), timeframe, i_tf + 1);
}
// Check if candle has a lower low
bool IsLowerLowCandle(int i_tf, int timeframe)
{
   if (i_tf + 1 >= iBars(Symbol(), timeframe)) return false;
   return iLow(Symbol(), timeframe, i_tf) < iLow(Symbol(), timeframe, i_tf + 1);
}
// Draw imbalance lines for up or down candles
void DrawImbalanceLine(int direction, int i_tf, int timeframe)
{
   // Generate unique object names using timeframe-specific bar time
   string nameMainUp   = BRIIdentifier + ":HL"  + TimeToStr(iTime(Symbol(), timeframe, i_tf));
   string nameMainDown = BRIIdentifier + ":LL"  + TimeToStr(iTime(Symbol(), timeframe, i_tf));
   string nameSecUp    = BRIIdentifier + "::HL" + TimeToStr(iTime(Symbol(), timeframe, i_tf));
   string nameSecDown  = BRIIdentifier + "::LL" + TimeToStr(iTime(Symbol(), timeframe, i_tf));
   double atr = iATR(Symbol(), timeframe, 100, i_tf);
   datetime timeStart = iTime(Symbol(), timeframe, i_tf);
   int chartIndex = iBarShift(Symbol(), 0, timeStart, false);
   // Set line color based on direction (up = aqua, down = magenta)
   LineColor = (direction == 1) ? clrAqua : clrMagenta;
   // Calculate timeX based on EffectiveTimeframe - for non-blocked line extension
   double timeX = 0;
   if(EffectiveTimeframe==1)    timeX=60;
   if(EffectiveTimeframe==5)    timeX=300;
   if(EffectiveTimeframe==15)   timeX=900;
   if(EffectiveTimeframe==30)   timeX=1800;
   if(EffectiveTimeframe==60)   timeX=3600;
   if(EffectiveTimeframe==240)  timeX=14400;
   if(EffectiveTimeframe==1440) timeX=86400;
   if(EffectiveTimeframe==10080)timeX=604800;
   if(EffectiveTimeframe==43200)timeX=2592000;
 
   if (direction == 1) // Upward imbalance
   {
      double highValue = iHigh(Symbol(), timeframe, i_tf + 1);
      bool isBlocked = false;
      int blockingIndex_tf = -1;
      // Check for a blocking candle
      for (int x_tf = i_tf - 1; x_tf >= 0; x_tf--)
      {
         if (iLow(Symbol(), timeframe, x_tf) <= highValue)
         {
            isBlocked = true;
            blockingIndex_tf = x_tf;
            break;
         }
      }
      double price = highValue;
      if (isBlocked)
      {
         if (!HideBlockedLines)
         {
            datetime timeEnd = iTime(Symbol(), timeframe, blockingIndex_tf);
            int blockingChartIndex = iBarShift(Symbol(), 0, timeEnd, false);
            if (chartIndex - blockingChartIndex > MinBarDistance)
            {
               DrawLine(nameMainDown, Time[chartIndex], Time[blockingChartIndex], price, price,
                        LineColor, HLLineThickness, Line1Style, false);
               ArrowUp[chartIndex] = High[chartIndex] + atr / 6;
            }
            if (!HideSecondaryLines)
            {
               int lowest_tf = iLowest(Symbol(), timeframe, MODE_LOW, i_tf - blockingIndex_tf - 1, blockingIndex_tf + 1);
               double lowPrice = iLow(Symbol(), timeframe, lowest_tf);
               if (lowPrice >= highValue)
               {
                  DrawLine(nameSecUp, Time[chartIndex], Time[blockingChartIndex], lowPrice, lowPrice,
                           LineColor, HLLineThickness, Line2Style, false);
               }
            }
         }
      }
      else
      {
         // Corrected futureTime calculation based on timeframe and set isRay to false
         datetime futureTime = Time[chartIndex] + (datetime)(timeX * 5);
         DrawLine(nameMainDown, Time[chartIndex], futureTime, price, price,
                  LineColor, HLLineThickness, Line1Style, false); // isRay = false
         ArrowUp[chartIndex] = High[chartIndex] + atr / 6;
         BRILinesUp[chartIndex] = price;
         if (!HideSecondaryLines)
         {
            int lowest_tf = iLowest(Symbol(), timeframe, MODE_LOW, i_tf, 0);
            double lowPrice = iLow(Symbol(), timeframe, lowest_tf);
            if (lowPrice >= highValue)
            {
               DrawLine(nameSecUp, Time[chartIndex], Time[chartIndex] + (datetime)(timeX * 5), lowPrice, lowPrice, // Corrected futureTime, isRay = false
                        LineColor, HLLineThickness, Line2Style, false); // isRay = false
            }
         }
      }
   }
   else // Downward imbalance (direction == 2)
   {
      double lowValue = iLow(Symbol(), timeframe, i_tf + 1);
      bool isBlocked = false;
      int blockingIndex_tf = -1;
      for (int x_tf = i_tf - 1; x_tf >= 0; x_tf--)
      {
         if (iHigh(Symbol(), timeframe, x_tf) >= lowValue)
         {
            isBlocked = true;
            blockingIndex_tf = x_tf;
            break;
         }
      }
      double price = lowValue;
      if (isBlocked)
      {
         if (!HideBlockedLines)
         {
            datetime timeEnd = iTime(Symbol(), timeframe, blockingIndex_tf);
            int blockingChartIndex = iBarShift(Symbol(), 0, timeEnd, false);
            if (chartIndex - blockingChartIndex > MinBarDistance)
            {
               DrawLine(nameMainUp, Time[chartIndex], Time[blockingChartIndex], price, price,
                        LineColor, HLLineThickness, Line1Style, false);
               ArrowDn[chartIndex] = Low[chartIndex] - atr / 6;
            }
            if (!HideSecondaryLines)
            {
               int highest_tf = iHighest(Symbol(), timeframe, MODE_HIGH, i_tf - blockingIndex_tf - 1, blockingIndex_tf + 1);
               double highPrice = iHigh(Symbol(), timeframe, highest_tf);
               if (highPrice <= lowValue)
               {
                  DrawLine(nameSecDown, Time[chartIndex], Time[blockingChartIndex], highPrice, highPrice,
                           LineColor, HLLineThickness, Line2Style, false);
               }
            }
         }
      }
      else
      {
         // Corrected futureTime calculation based on timeframe and set isRay to false
         datetime futureTime = Time[chartIndex] + (datetime)(timeX * 5);
         DrawLine(nameMainUp, Time[chartIndex], futureTime, price, price,
                  LineColor, HLLineThickness, Line1Style, false); // isRay = false
         ArrowDn[chartIndex] = Low[chartIndex] - atr / 6;
         BRILinesDown[chartIndex] = price;
         if (!HideSecondaryLines)
         {
            int highest_tf = iHighest(Symbol(), timeframe, MODE_HIGH, i_tf, 0);
            double highPrice = iHigh(Symbol(), timeframe, highest_tf);
            if (highPrice <= lowValue)
            {
               DrawLine(nameSecDown, Time[chartIndex], Time[chartIndex] + (datetime)(timeX * 5), highPrice, highPrice, // Corrected futureTime, isRay = false
                        LineColor, HLLineThickness, Line2Style, false); // isRay = false
            }
         }
      }
   }
}
// Draw pip size text above bars
void DrawPipNumbers(int i, double pipSize)
{
   double atr = iATR(NULL, 0, 100, i); // Use current chart ATR for text positioning
   string objName = BRIIdentifier + ":Pip" + IntegerToString(i);
   if (ObjectFind(objName) >= 0) ObjectDelete(objName);
   ObjectCreate(objName, OBJ_TEXT, 0, Time[i], High[i] + atr);
   ObjectSet(objName, OBJPROP_ANGLE, PipTextAngle);
   ObjectSetText(objName, DoubleToStr(pipSize, 2), 10, "Corbel", PipTextColor);
}
// Clean up all indicator objects
void DeleteObjects()
{
   string prefix = BRIIdentifier;
   int prefixLength = StringLen(prefix);
   for (int i = ObjectsTotal() - 1; i >= 0; i--)
   {
      string objName = ObjectName(i);
      if (StringSubstr(objName, 0, prefixLength) == prefix)
         ObjectDelete(objName);
   }
   WindowRedraw();
}
// Draw a trend line with optional ray extension
void DrawLine(string name, datetime time1, datetime time2, double price1, double price2,
              color lineColor, int width, ENUM_LINE_STYLE style, bool isRay)
{
   if (ObjectFind(name) >= 0) ObjectDelete(name);
   ObjectCreate(name, OBJ_TREND, 0, time1, price1, time2, price2);
   ObjectSet(name, OBJPROP_COLOR, lineColor);
   if (style == STYLE_SOLID) ObjectSet(name, OBJPROP_WIDTH, width);
   ObjectSet(name, OBJPROP_STYLE, style);
   ObjectSet(name, OBJPROP_RAY, isRay);
   WindowRedraw();
}
// Manage bar-based alerts
void ManageAlerts()
{
   if (!AlertsOn) return;
   int barIndex = AlertsOnCurrentBar ? 0 : 1;
   if (ArrowUp[barIndex] != EMPTY_VALUE)
   {
      string msg = StringConcatenate(Symbol(), ", ", TimeframeToString(EffectiveTimeframe), " BRI ",
                                    "Bar Up @ ", TimeToStr(TimeLocal(), TIME_SECONDS));
      DoAlert(barIndex, msg);
   }
   if (ArrowDn[barIndex] != EMPTY_VALUE)
   {
      string msg = StringConcatenate(Symbol(), ", ", TimeframeToString(EffectiveTimeframe), " BRI ",
                                    "Bar Down @ ", TimeToStr(TimeLocal(), TIME_SECONDS));
      DoAlert(barIndex, msg);
   }
}
// Execute alert actions
void DoAlert(int barIndex, string message)
{
   static string lastAlert = "";
   static datetime lastTime = 0;
   if (lastAlert != message && lastTime != Time[barIndex])
   {
      lastAlert = message;
      lastTime = Time[barIndex];
      if (AlertsMessage) Alert(message);
      if (AlertsEmail) SendMail(Symbol() + " BRI Alert", message);
      if (AlertsNotification) SendNotification(message);
      if (AlertsSound) PlaySound("alert2.wav");
   }
}
// Convert timeframe integer to readable string
string TimeframeToString(int timeframe)
{
   string tfNames[] = {"M1", "M5", "M10", "M15", "M30", "H1", "H4", "D1", "W1", "MN"};
   int tfValues[] = {1, 5, 10, 15, 30, 60, 240, 1440, 10080, 43200};
   for (int i = 0; i < ArraySize(tfValues); i++)
      if (timeframe == tfValues[i]) return tfNames[i];
   return StringFormat("TF%d", timeframe); // Fallback for non-standard timeframes
}
// Color imbalance candles
void SetImbalanceCandleColor(int direction, int i)
{
   double high = High[i], low = Low[i], bodyHigh, bodyLow;
   if (direction == 1) // Up candle
   {
      bodyHigh = MathMax(Open[i], Close[i]);
      bodyLow = High[i + 1];
      Bar1[i] = high;
      Candle1[i] = bodyHigh;
   }
   else // Down candle
   {
      bodyHigh = Low[i + 1];
      bodyLow = MathMin(Open[i], Close[i]);
      Bar2[i] = low;
      Candle2[i] = bodyLow;
   }
}
//+------------------------------------------------------------------+

Quoting sinohe6

Disliked

{quote} Hello Bro would you please add multi time frame option to this indicator {file}

Ignored

Quoting zeroline

Disliked

{quote} Hello MwlRCT, how are you? Can you add a weighted moving average inside this indicator (parameterizable period), so that the crossing of the indicator with the average generates buy and sell arrows (with buffers)? It's for mt5. Thank you very much for your help https://www.mql5.com/en/code/1660

Ignored

Quoting BestTraderEv

Disliked

{quote} Ah, so! No more Kisses* for me then???

Ignored

Quoting zeroline

Disliked

{quote} LOL you broke my heart hahaha. I need the arrows generated at the intersections because I need the buffers to test in the EA.

Ignored

Quoting BestTraderEv

Disliked

{quote} Well, I can tell you already that this indicator alone will not make money with an EA. There is more to it than just this indicator. Sure, it may be useful, but like for all indicators, it must be applied in a much broader context and under more condtions. The following image can serve as a good example: {image} To be clear, look at this: {image} The highlighted area was pretty uncertain, because we could have expected the price to go up,or to have doubts with the short. Still, the overall tendency of the MAGIQWAVE was Bearish. And, if you...

Ignored

Quoting zeroline

Disliked

{quote} Yes, I know that the SSA recalculates by nature, it is normal for this indicator. That is why I need what I requested if it is possible to do, because with the signals I will be able to optimize parameters and combinations through an EA. Without this, just by eye adding an average within the indicator, it is impossible.

Ignored

Quoting BestTraderEv

Disliked

{quote} Also, adding another MA to what already is a smoothed MA, which is an attempt to do more smoothing on an already smoothed MA, means only more lagging signals...

Ignored

Quoting zeroline

Disliked

{quote} No, the MA that I asked to add to the indicator would be to check the 'crossover' between the indicator line and this MA that was added...

Ignored

Quoting BestTraderEv

Disliked

{quote} I just realised something.... The MQL5 version which you suggested isn't the correct code - it has only one buffer and only one plot. So, it's not the correct code... And, I only have the ex.4 file of the correct code, and it uses the libSSA.dll

Ignored

Quoting BestTraderEv

Disliked

{quote} Also, adding another MA to what already is a smoothed MA means only more lagging signals...

Ignored

Quoting zeroline

Disliked

{quote} Yes, I need to add an average inside it to make it look like the image you posted of your graph and to plot buy and sell arrows at the intersection, that's all.

Ignored

Quoting BestTraderEv

Disliked

{quote} {file} Include folder: {file} {image} You can play around with MA_Handle2 parameters to maybe achieve different results, like MODE_EMA or MODE_LWMA, maybe change the PeriodNorm ... {image}

Ignored

for(i = 0; i < limit; i++)
      {
        double sumRangeH = 0.0;
        double sumRangeL = 0.0;
        
        // Суммируем диапазоны для Inp_RangePeriod закрытых баров после бара с индексом i
        for(int j = 0; j <= Inp_RangePeriod; j++)
           {
           sumRangeH += (iHigh(_Symbol, PERIOD_CURRENT, i+j) + iClose(_Symbol, PERIOD_CURRENT, i+j))/2.0;
           }
           double avgRangeH = sumRangeH / Inp_RangePeriod;
      
        for(int j = 0; j <= Inp_RangePeriod; j++)
           {
           sumRangeL += (iLow(_Symbol, PERIOD_CURRENT, i+j) + iClose(_Symbol, PERIOD_CURRENT, i+j))/2.0;
           }  
           double avgRangeL = sumRangeL / Inp_RangePeriod; 
      
           
           double midPrice = (avgRangeH+avgRangeL)/2.0;
    
           // Получаем значение ATR для текущего бара (сдвиг i+1, чтобы не брать текущий незакрытый бар)
           double atr = iATR(_Symbol, PERIOD_CURRENT, Inp_RangePeriod, i);
      
           // Включаем ATR в расчёт. Например, можно прибавить ATR к центральной цене:
           //midHL[i] = midPrice + atr;
           midHL[i] = midPrice * (1 + atr / midPrice);
      
    
     }

Quoting Shargyn

Disliked

{quote} Doesn't look very good.

Ignored

Quoting Shargyn

Disliked

{quote} Hey bro, have you tried to smooth it out through : ExtWPRBuffer = (double)MathRound(wpr); I sometimes do this, but the very essence of the indicator is not lost. This is just an option. I don’t want to download indicators if they posted a code so that you can see what it is. Perhaps someone would join this conversation. Below is an example on the chart that is standard and smoothed, it removes unnecessary twitching of the WPR indicator. It’s not very visible visually, but in the advisor’s algorithm it looks better than the original. {image}...

Ignored

Quoting BestTraderEv

Disliked

{quote} {file} Include folder: {file} {image} You can play around with MA_Handle2 parameters to maybe achieve different results, like MODE_EMA or MODE_LWMA, maybe change the PeriodNorm ... {image}

Ignored