val_fvg_mt5_ea/Volume Sequence Indicator.txt

//+------------------------------------------------------------------+
//|                    SequentialVolumeProfileWithFVG.mq5           |
//|                                    Copyright 2025                |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025"
#property link      "https://www.mql5.com"
#property version   "1.00"
#property indicator_chart_window

//--- Input parameters for Volume Profile
input int      BinsCount=100;          // Number of price bins
input double   ValueAreaPercent=70;    // Value Area percentage (70% default)
input color    VALColor=clrDarkBlue;   // Value Area Low color
input color    VAHColor=clrDarkBlue;   // Value Area High color
input color    AbsLowColor=clrBlack;   // Absolute Low color
input color    AbsHighColor=clrBlack;  // Absolute High color
input color    TimeLineColor=clrRed;   // Time marker line color
input int      LineWidth=2;            // Line width for all value lines
input int      TimeLineWidth=2;        // Line width for time marker lines
input int      MaxDaysBack=30;         // Maximum number of trading days to look back
input ENUM_LINE_STYLE VALStyle=STYLE_SOLID;    // Value Area Low line style
input ENUM_LINE_STYLE VAHStyle=STYLE_SOLID;    // Value Area High line style
input ENUM_LINE_STYLE AbsLowStyle=STYLE_SOLID; // Absolute Low line style
input ENUM_LINE_STYLE AbsHighStyle=STYLE_SOLID; // Absolute High line style
input bool     ShowLabels=true;        // Show price labels
input bool     ShowComment=true;       // Show comment with most recent levels

//--- Input parameters for Fair Value Gap (FVG)
input bool     ShowFVG=true;           // Enable Fair Value Gap detection
input color    BullishFVGColor=clrLime;      // Bullish FVG color
input color    BearishFVGColor=clrDeepPink;  // Bearish FVG color
input double   MinFVGSize=0.0;         // Minimum FVG size in points (0 = any size)
input int      MaxBarsBack=300;        // How many bars to look back for FVG

// Structure to hold volume profile data for a day
struct VolumeProfileData {
   datetime date;          // Trading day date
   datetime startTime;     // Start time for calculation (23:59 previous day)
   datetime endTime;       // End time for calculation (23:59 current day) 
   datetime displayStart;  // When to start displaying this profile (= endTime)
   datetime displayEnd;    // When to stop displaying this profile (= next day's endTime)
   double val;             // Value Area Low
   double vah;             // Value Area High
   double poc;             // Point of Control (needed for internal calculation)
   double absLow;          // Absolute Low
   double absHigh;         // Absolute High
   bool calculated;        // Whether the calculation is complete
};

// Array to store volume profile data for multiple days
VolumeProfileData g_Profiles[];

// Prefix for FVG objects
string prefix;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   // Set up FVG object prefix
   prefix = "VProfFVG_";
   
   // Initialize profile storage
   ArrayResize(g_Profiles, MaxDaysBack);
   for(int i = 0; i < MaxDaysBack; i++)
   {
      g_Profiles[i].date = 0;
      g_Profiles[i].startTime = 0;
      g_Profiles[i].endTime = 0;
      g_Profiles[i].displayStart = 0;
      g_Profiles[i].displayEnd = 0;
      g_Profiles[i].val = 0;
      g_Profiles[i].vah = 0;
      g_Profiles[i].poc = 0;
      g_Profiles[i].absLow = 0;
      g_Profiles[i].absHigh = 0;
      g_Profiles[i].calculated = false;
   }
   
   // Initialize all profiles
   CalculateAllVolumeProfiles();
   
   // Set up timer to check for new day
   EventSetTimer(60); // Check every minute
   
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // Clean up chart objects
   ObjectsDeleteAll(0, "VProfile_");
   ObjectsDeleteAll(0, prefix);
   
   // Kill the timer
   EventKillTimer();
   
   // Clear the comment
   Comment("");
}

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
{
   // Check if we need to update the profiles
   datetime currentTime = TimeCurrent();
   MqlDateTime mdt;
   TimeToStruct(currentTime, mdt);
   
   // Check if it's near the 23:59 boundary (update a bit before and after)
   if((mdt.hour == 23 && mdt.min >= 58) || (mdt.hour == 0 && mdt.min <= 5))
   {
      CalculateAllVolumeProfiles();
   }
}

//+------------------------------------------------------------------+
//| Helper function to round a value to the specified tick size     |
//+------------------------------------------------------------------+
double RoundToTickSize(double value, double tickSize)
{
   return MathRound(value / tickSize) * tickSize;
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
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[])
{
   // Check for insufficient data
   if(rates_total < 3) 
      return 0;
   
   // Calculate Volume Profiles if needed
   if(prev_calculated == 0)
   {
      CalculateAllVolumeProfiles();
   }
   
   // Detect Fair Value Gaps if enabled
   if(ShowFVG)
   {
      // Prepare arrays
      ArraySetAsSeries(open, true);
      ArraySetAsSeries(high, true);
      ArraySetAsSeries(low, true);
      ArraySetAsSeries(close, true);
      ArraySetAsSeries(time, true);
      
      // Clear existing FVG objects if recalculating all
      if(prev_calculated == 0)
      {
         ObjectsDeleteAll(0, prefix);
      }
      
      // Determine calculation starting point
      int limit;
      if(prev_calculated == 0)
      {
         // Calculate for all bars within MaxBarsBack
         limit = MathMin(MaxBarsBack, rates_total - 3);
      }
      else
      {
         // Recalculate only for new bars plus a few previous ones
         limit = rates_total - prev_calculated + 3;
         limit = MathMin(limit, MaxBarsBack);
      }
      
      // Ensure we don't exceed available bars
      limit = MathMin(limit, rates_total - 3);
      
      // Scan for Fair Value Gaps
      for(int i = 0; i < limit && !IsStopped(); i++)
      {
         // Check for bullish FVG (gap up)
         // A bullish FVG occurs when low[i] > high[i+2]
         if(low[i] - high[i+2] >= MinFVGSize * Point())
         {
            // Calculate the FVG boundaries
            double upper = MathMin(high[i], low[i]);
            double lower = MathMax(high[i+2], low[i+2]);
            
            // Draw the bullish FVG area
            DrawFVGArea(i, upper, lower, time, BullishFVGColor, 1);
         }
         
         // Check for bearish FVG (gap down)
         // A bearish FVG occurs when low[i+2] > high[i]
         if(low[i+2] - high[i] >= MinFVGSize * Point())
         {
            // Calculate the FVG boundaries
            double upper = MathMin(high[i+2], low[i+2]);
            double lower = MathMax(high[i], low[i]);
            
            // Draw the bearish FVG area
            DrawFVGArea(i, upper, lower, time, BearishFVGColor, 0);
         }
      }
   }
   
   return(rates_total);
}

//+------------------------------------------------------------------+
//| Draw Fair Value Gap area as a rectangle                          |
//+------------------------------------------------------------------+
void DrawFVGArea(const int index, const double price_up, const double price_dn, 
                const datetime &time[], const color color_area, const char dir)
{
   string name = prefix + (dir > 0 ? "up_" : "dn_") + TimeToString(time[index]);
   
   // Create or update the rectangle object
   if(ObjectFind(0, name) < 0)
      ObjectCreate(0, name, OBJ_RECTANGLE, 0, 0, 0, 0);
   
   // Set object properties
   ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
   ObjectSetInteger(0, name, OBJPROP_FILL, true);
   ObjectSetInteger(0, name, OBJPROP_BACK, true);
   ObjectSetString(0, name, OBJPROP_TOOLTIP, "\n");
   
   // Set rectangle coordinates and color
   ObjectSetInteger(0, name, OBJPROP_COLOR, color_area);
   ObjectSetInteger(0, name, OBJPROP_TIME, 0, time[index+2]);
   ObjectSetInteger(0, name, OBJPROP_TIME, 1, time[index]);
   ObjectSetDouble(0, name, OBJPROP_PRICE, 0, price_up);
   ObjectSetDouble(0, name, OBJPROP_PRICE, 1, price_dn);
}

//+------------------------------------------------------------------+
//| Calculate all volume profiles up to MaxDaysBack                  |
//+------------------------------------------------------------------+
void CalculateAllVolumeProfiles()
{
   // Clear existing objects
   ObjectsDeleteAll(0, "VProfile_");
   
   // Get current time
   datetime currentTime = TimeCurrent();
   
   // Create a list of trading days going back MaxDaysBack days
   int calculatedDays = 0;
   datetime tradingDays[];
   ArrayResize(tradingDays, MaxDaysBack);
   
   // Get the current day
   datetime currentDay = currentTime;
   MqlDateTime mdt;
   TimeToStruct(currentDay, mdt);
   mdt.hour = 0;
   mdt.min = 0;
   mdt.sec = 0;
   currentDay = StructToTime(mdt);
   
   // Fill the array with trading days
   for(int i = 0; i < MaxDaysBack * 2; i++) // Check twice as many days to account for weekends
   {
      // Go back one day
      datetime checkDay = currentDay - (i * 86400);
      
      // Skip weekends
      TimeToStruct(checkDay, mdt);
      if(mdt.day_of_week == 0 || mdt.day_of_week == 6) // Sunday or Saturday
         continue;
      
      tradingDays[calculatedDays++] = checkDay;
      
      if(calculatedDays >= MaxDaysBack)
         break;
   }
   
   // Now, calculate volume profiles for each trading day
   for(int i = 0; i < calculatedDays; i++)
   {
      datetime tradingDay = tradingDays[i];
      
      // Store the date
      g_Profiles[i].date = tradingDay;
      
      // Calculate time boundaries
      CalculateTimeBoundaries(i);
      
      // For display purposes, set the display end of the current profile
      // to the display start of the previous profile
      if(i > 0)
      {
         g_Profiles[i].displayEnd = g_Profiles[i-1].displayStart;
      }
      else
      {
         // For the most recent profile, display until far future
         g_Profiles[i].displayEnd = D'2050.01.01 00:00:00';
      }
      
      // Check if we have a valid calculation for this day
      if(!g_Profiles[i].calculated)
      {
         CalculateVolumeProfileForDay(i);
      }
      
      // Draw this profile's time markers and levels
      DrawVolumeProfile(i);
   }
   
   // Update comment with the most recent profile (index 0)
   if(ShowComment && calculatedDays > 0)
   {
      string info = "Volume Profile (TradingView 23:59-23:59 UTC+2)\n" +
                  "Date: " + TimeToString(g_Profiles[0].date, TIME_DATE) + " (" + GetDayOfWeekName(g_Profiles[0].date) + ")\n" +
                  "Value Area: " + DoubleToString(ValueAreaPercent, 0) + "%\n" +
                  "VAL: " + DoubleToString(g_Profiles[0].val, _Digits) + "\n" +
                  "VAH: " + DoubleToString(g_Profiles[0].vah, _Digits) + "\n" +
                  "AbsLow: " + DoubleToString(g_Profiles[0].absLow, _Digits) + "\n" +
                  "AbsHigh: " + DoubleToString(g_Profiles[0].absHigh, _Digits);
                  
      Comment(info);
   }
}

//+------------------------------------------------------------------+
//| Calculate time boundaries for a profile                          |
//+------------------------------------------------------------------+
void CalculateTimeBoundaries(int index)
{
   // Get trading day
   datetime tradingDay = g_Profiles[index].date;
   
   // Get the day before trading day
   datetime dayBeforeTradingDay = tradingDay - 86400;
   
   // Check and adjust for weekends
   MqlDateTime mdt;
   TimeToStruct(dayBeforeTradingDay, mdt);
   int dayOfWeek = mdt.day_of_week;
   
   // For Sunday, go back 2 more days to Friday
   if(dayOfWeek == 0)
   {
      int twoDaysInSeconds = 172800; // 2*86400
      dayBeforeTradingDay = dayBeforeTradingDay - twoDaysInSeconds;
   }
   
   // For Saturday, go back 1 more day to Friday
   if(dayOfWeek == 6)
   {
      int oneDayInSeconds = 86400;
      dayBeforeTradingDay = dayBeforeTradingDay - oneDayInSeconds;
   }
   
   // Format date strings for times
   MqlDateTime tradingDayMdt;
   TimeToStruct(tradingDay, tradingDayMdt);
   string tradingDayStr = StringFormat("%04d.%02d.%02d", tradingDayMdt.year, tradingDayMdt.mon, tradingDayMdt.day);
   
   MqlDateTime beforeMdt;
   TimeToStruct(dayBeforeTradingDay, beforeMdt);
   string dayBeforeTradingDayStr = StringFormat("%04d.%02d.%02d", beforeMdt.year, beforeMdt.mon, beforeMdt.day);
   
   // Calculate start and end times
   g_Profiles[index].startTime = StringToTime(dayBeforeTradingDayStr + " 23:59:00");
   g_Profiles[index].endTime = StringToTime(tradingDayStr + " 23:59:00");
   g_Profiles[index].displayStart = g_Profiles[index].endTime;
}

//+------------------------------------------------------------------+
//| Calculate volume profile for a specific day                      |
//+------------------------------------------------------------------+
void CalculateVolumeProfileForDay(int index)
{
   datetime tradingDay = g_Profiles[index].date;
   datetime startTime = g_Profiles[index].startTime;
   datetime endTime = g_Profiles[index].endTime;
   
   Print("Calculating volume profile for ", TimeToString(tradingDay, TIME_DATE),
         " (", GetDayOfWeekName(tradingDay), ")");
   Print("Time range: ", TimeToString(startTime), " to ", TimeToString(endTime));
   
   // Copy the OHLCV data for this day - using M1 timeframe for precision
   MqlRates rates[];
   int copied = CopyRates(_Symbol, PERIOD_M1, startTime, endTime, rates);
   
   if(copied <= 0)
   {
      Print("Failed to copy rates data for ", TimeToString(tradingDay, TIME_DATE), ". Error: ", GetLastError());
      g_Profiles[index].calculated = false;
      return;
   }
   
   Print("Copied ", copied, " bars for volume profile calculation");
   
   // Find high and low for the day
   double dayHigh = DBL_MIN;
   double dayLow = DBL_MAX;
   
   for(int i = 0; i < copied; i++)
   {
      if(rates[i].high > dayHigh) dayHigh = rates[i].high;
      if(rates[i].low < dayLow) dayLow = rates[i].low;
   }
   
   // Check if we have valid high and low
   if(dayHigh <= dayLow || dayLow == DBL_MAX || dayHigh == DBL_MIN)
   {
      Print("Invalid high/low values. Calculation aborted.");
      g_Profiles[index].calculated = false;
      return;
   }
   
   // EXACTLY MATCH TRADINGVIEW LOGIC: Calculate tick size as in PineScript
   // First get minimum tick size for the instrument
   double minTick = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   
   // Calculate default tick size based on price range and bin count (matches TradingView more closely)
   double priceRange = dayHigh - dayLow;
   // Match the PineScript index_num calculation: math.floor(1000/lb_days)-1
   int index_num = (int)MathFloor(1000.0 / BinsCount) - 1;
   
   // Match TradingView tick_size calculation:
   // tick_size = round_to(math.max(((roof - base)/index_num),syminfo.mintick),(syminfo.mintick/100))
   double tickSize = MathMax((priceRange / index_num), minTick);
   tickSize = RoundToTickSize(tickSize, minTick / 100.0);
   
   Print("Using tick size: ", tickSize, " for volume profile calculation");
   
   // Base and roof price levels (direct from TradingView code)
   double base = dayLow;
   double roof = dayHigh;
   
   // Calculate maximum number of bins needed
   int bins = (int)MathCeil((roof - base) / tickSize) + 1;
   
   // Arrays to store volume at each price level
   double binVolume[];
   ArrayResize(binVolume, bins);
   
   // Initialize to zeros
   for(int i = 0; i < bins; i++)
      binVolume[i] = 0;
   
   // Process candles as in TradingView code
   for(int i = 0; i < copied; i++)
   {
      // Round high and low to the tickSize (match TradingView's c_hi and c_lo)
      double c_hi = RoundToTickSize(rates[i].high, tickSize);
      double c_lo = RoundToTickSize(rates[i].low, tickSize);
      
      // Calculate candle range and index as in TradingView
      double candle_range = c_hi - c_lo;
      int candle_index = (int)(candle_range / tickSize) + 1;
      
      // Calculate tick volume (matching PineScript tick_vol calculation)
      // In TradingView: tick_vol = _mp?1:volume/candle_index
      // We're always using real volume (mp = false), so:
      double tick_vol = rates[i].tick_volume / candle_index;
      
      // Loop through price levels covered by this candle
      for(int priceLevel = 0; priceLevel < bins; priceLevel++)
      {
         double index_price = base + (priceLevel * tickSize);
         
         // Check if this price level is within the candle's range
         if(index_price <= c_hi && index_price >= c_lo)
         {
            binVolume[priceLevel] += tick_vol;
         }
      }
   }
   
   // Store absolute high and low - use the exact values from calculation
   g_Profiles[index].absLow = base; 
   g_Profiles[index].absHigh = roof;
   
   // Calculate total volume
   double totalVolume = 0;
   for(int i = 0; i < bins; i++)
   {
      totalVolume += binVolume[i];
   }
   
   // Safety check for total volume
   if(totalVolume <= 0)
   {
      Print("No volume data for ", TimeToString(tradingDay, TIME_DATE), ". Calculation aborted.");
      g_Profiles[index].calculated = false;
      return;
   }
   
   // Find max volume index - EXACTLY match TradingView's POC calculation
   // In TradingView: max_index = math.round(math.avg(array.indexof(main,array.max(main)), array.lastindexof(main,array.max(main))))
   double maxVolume = 0;
   int firstMaxIdx = 0;
   int lastMaxIdx = 0;
   
   // First find the maximum volume
   for(int i = 0; i < bins; i++)
   {
      if(binVolume[i] > maxVolume)
      {
         maxVolume = binVolume[i];
      }
   }
   
   // Then find first and last indices with this max volume
   for(int i = 0; i < bins; i++)
   {
      if(binVolume[i] == maxVolume)
      {
         firstMaxIdx = i;
         break;
      }
   }
   
   for(int i = bins - 1; i >= 0; i--)
   {
      if(binVolume[i] == maxVolume)
      {
         lastMaxIdx = i;
         break;
      }
   }
   
   // Calculate POC index as average of first and last max volume index (exactly as TradingView)
   int pocIndex = (int)MathRound((firstMaxIdx + lastMaxIdx) / 2.0);
   
   // Calculate POC price
   double poc = base + (pocIndex * tickSize);
   g_Profiles[index].poc = poc;
   
   // EXACTLY match TradingView Value Area calculation
   double valueAreaThreshold = totalVolume * ValueAreaPercent / 100.0;
   double accumulatedVolume = pocIndex >= 0 ? binVolume[pocIndex] : 0;
   
   int upCount = pocIndex;
   int downCount = pocIndex;
   
   // Follow the TradingView algorithm precisely
   while(accumulatedVolume < valueAreaThreshold && (upCount < bins - 1 || downCount > 0))
   {
      // Get upper and lower volumes exactly as in TradingView
      double upperVol = (upCount < bins - 1) ? binVolume[upCount + 1] : 0;
      double lowerVol = (downCount > 0) ? binVolume[downCount - 1] : 0;
      
      // Implement the exact TradingView condition:
      // if ((uppervol >= lowervol) and not na(uppervol)) or na(lowervol)
      if((upperVol >= lowerVol && upperVol > 0) || lowerVol == 0)
      {
         upCount += 1;
         accumulatedVolume += upperVol;
      }
      else
      {
         downCount -= 1;
         accumulatedVolume += lowerVol;
      }
   }
   
   // Calculate VAL and VAH exactly as in TradingView
   double val = base + (downCount * tickSize);
   double vah = base + (upCount * tickSize);
   
   // Store VAL and VAH
   g_Profiles[index].val = val;
   g_Profiles[index].vah = vah;
   
   // Mark as calculated
   g_Profiles[index].calculated = true;
   
   Print("Volume profile levels calculated for ", TimeToString(tradingDay, TIME_DATE), 
         ": POC=", poc,
         ", VAL=", val, 
         ", VAH=", vah, 
         ", AbsLow=", base, 
         ", AbsHigh=", roof);
}

//+------------------------------------------------------------------+
//| Draw volume profile lines and time markers                       |
//+------------------------------------------------------------------+
void DrawVolumeProfile(int index)
{
   // Skip if not calculated
   if(!g_Profiles[index].calculated)
      return;
   
   // Create a unique suffix based on the date
   string dateSuffix = TimeToString(g_Profiles[index].date, TIME_DATE);
   
   // Draw time markers at the boundaries (start and end of calculation)
   DrawTimeLine("StartTime_" + dateSuffix, g_Profiles[index].startTime, TimeLineColor, TimeLineWidth);
   DrawTimeLine("EndTime_" + dateSuffix, g_Profiles[index].endTime, TimeLineColor, TimeLineWidth);
   
   // Draw the volume profile levels between displayStart and displayEnd times
   DrawHorizontalLineWithinRange("VAL_" + dateSuffix, g_Profiles[index].val, 
      VALColor, VALStyle, LineWidth, g_Profiles[index].displayStart, g_Profiles[index].displayEnd);
   
   DrawHorizontalLineWithinRange("VAH_" + dateSuffix, g_Profiles[index].vah, 
      VAHColor, VAHStyle, LineWidth, g_Profiles[index].displayStart, g_Profiles[index].displayEnd);
   
   DrawHorizontalLineWithinRange("AbsLow_" + dateSuffix, g_Profiles[index].absLow, 
      AbsLowColor, AbsLowStyle, LineWidth, g_Profiles[index].displayStart, g_Profiles[index].displayEnd);
   
   DrawHorizontalLineWithinRange("AbsHigh_" + dateSuffix, g_Profiles[index].absHigh, 
      AbsHighColor, AbsHighStyle, LineWidth, g_Profiles[index].displayStart, g_Profiles[index].displayEnd);
}

//+------------------------------------------------------------------+
//| Helper function to get day of week name                          |
//+------------------------------------------------------------------+
string GetDayOfWeekName(datetime date)
{
   MqlDateTime mdt;
   TimeToStruct(date, mdt);
   
   // Use direct if statements instead of arrays
   if(mdt.day_of_week == 0) return "Sunday";
   if(mdt.day_of_week == 1) return "Monday";
   if(mdt.day_of_week == 2) return "Tuesday";
   if(mdt.day_of_week == 3) return "Wednesday";
   if(mdt.day_of_week == 4) return "Thursday";
   if(mdt.day_of_week == 5) return "Friday";
   if(mdt.day_of_week == 6) return "Saturday";
   
   return "Unknown";
}

//+------------------------------------------------------------------+
//| Draw a time marker vertical line                                 |
//+------------------------------------------------------------------+
void DrawTimeLine(string name, datetime time, color clr, int width)
{
   string objName = "VProfile_" + name;
   
   if(ObjectFind(0, objName) >= 0)
      ObjectDelete(0, objName);
      
   ObjectCreate(0, objName, OBJ_VLINE, 0, time, 0);
   ObjectSetInteger(0, objName, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, objName, OBJPROP_STYLE, STYLE_SOLID);
   ObjectSetInteger(0, objName, OBJPROP_WIDTH, width);
   ObjectSetInteger(0, objName, OBJPROP_BACK, false);
}

//+------------------------------------------------------------------+
//| Draw a horizontal line between two time points                   |
//+------------------------------------------------------------------+
void DrawHorizontalLineWithinRange(string name, double price, color clr, ENUM_LINE_STYLE style, int width, datetime startTime, datetime endTime)
{
   string objName = "VProfile_" + name;
   
   if(ObjectFind(0, objName) >= 0)
      ObjectDelete(0, objName);
      
   // Create a trend line instead of a horizontal line to limit its display range
   ObjectCreate(0, objName, OBJ_TREND, 0, startTime, price, endTime, price);
   ObjectSetInteger(0, objName, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, objName, OBJPROP_STYLE, style);
   ObjectSetInteger(0, objName, OBJPROP_WIDTH, width);
   ObjectSetInteger(0, objName, OBJPROP_BACK, false);
   ObjectSetInteger(0, objName, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(0, objName, OBJPROP_RAY_RIGHT, false); // Don't extend line past end point
   
   // Add price label if enabled
   if(ShowLabels)
   {
      string labelName = objName + "_Label";
      if(ObjectFind(0, labelName) >= 0)
         ObjectDelete(0, labelName);
         
      // Place label at the middle of the line
      datetime labelTime = startTime + ((endTime - startTime) / 2);
      
      ObjectCreate(0, labelName, OBJ_TEXT, 0, labelTime, price);
      ObjectSetString(0, labelName, OBJPROP_TEXT, name + ": " + DoubleToString(price, _Digits));
      ObjectSetInteger(0, labelName, OBJPROP_COLOR, clr);
      ObjectSetInteger(0, labelName, OBJPROP_FONTSIZE, 8);
      ObjectSetInteger(0, labelName, OBJPROP_ANCHOR, ANCHOR_LEFT_UPPER);
   }
}