how to access indicator two dimensional indicator buffer

New comment
  
   #property indicator_separate_window
   #property indicator_buffers 8
   
   #property indicator_color1 White
   #property indicator_color2 Red
   #property indicator_color3 Gold
   #property indicator_color4 GreenYellow
   #property indicator_color5 DarkOrange
   #property indicator_color6 PaleVioletRed
   #property indicator_color7 DeepSkyBlue
   #property indicator_color8 Olive
   #property indicator_color9 clrMediumSeaGreen
   #property indicator_color10 clrCrimson
   #property indicator_width9 2
   #property indicator_width10 2
   

   
   extern string TimeFrame = "";
   extern bool   showOnlySymbolOnChart = true;
   extern bool   showDoubleGapsOnChart = true;
   extern bool   showOnlyDirectionOfPair = false;
   extern int   doubleCandleDiff = 2;
   extern int    startCandle = 0;
   extern int   endCandle= 1000;
   
   int MaMethod = 3;
   int MaFast = 3;
   int MaSlow = 5;
   int Price = 6;

   double arrUSD[];
   double arrEUR[];
   double arrGBP[];
   double arrCHF[];
   double arrJPY[];
   double arrAUD[];
   double arrCAD[];
   double arrXAU[];
   double arrowUp[];
   double arrowDn[];

   string indicatorFileName;
   bool returnBars;
   bool calculateValue;
   int timeFrame = 0;
   string curr1, curr2;

   string names[8] = {
      "USD",
      "EUR",
      "GBP",
      "CHF",
      "JPY",
      "AUD",
      "CAD",
      "XAU"
   };
   int colors[8] = {
      indicator_color1,
      indicator_color2,
      indicator_color3,
      indicator_color4,
      indicator_color5,
      indicator_color6,
      indicator_color7,
      indicator_color8
   };
   string Indicator_Name = "CCPF ";
   bool Interpolate = true;

   double arrVal(int i, string curr) {
      if (curr == "USD")
         return arrUSD[i];
      if (curr == "EUR")
         return arrEUR[i];
      if (curr == "GBP")
         return arrGBP[i];
      if (curr == "CHF")
         return arrCHF[i];
      if (curr == "JPY")
         return arrJPY[i];
      if (curr == "AUD")
         return arrAUD[i];
      if (curr == "CAD")
         return arrCAD[i];
      if (curr == "XAU")
         return arrXAU[i];
      return -1;
   }

   //+------------------------------------------------------------------
   //|                                                                  
   //+------------------------------------------------------------------
   int init() {
      IndicatorDigits(6);


      SetIndexBuffer(0, arrUSD);
      SetIndexBuffer(1, arrEUR);
      SetIndexBuffer(2, arrGBP);
      SetIndexBuffer(3, arrCHF);
      SetIndexBuffer(4, arrJPY);
      SetIndexBuffer(5, arrAUD);
      SetIndexBuffer(6, arrCAD);
      SetIndexBuffer(7, arrXAU);
      SetIndexBuffer(8, arrowUp);
      SetIndexBuffer(9, arrowDn);
      SetIndexStyle(8, DRAW_ARROW);
      SetIndexStyle(9, DRAW_ARROW);
      SetIndexArrow(8, 233);
      SetIndexArrow(9, 234);
      initLabels();
      indicatorFileName = WindowExpertName();
      returnBars = (TimeFrame == "returnBars");
      if (returnBars) return (0);
      calculateValue = (TimeFrame == "calculateValue");
      if (calculateValue) return (0);
      timeFrame = stringToTimeFrame(TimeFrame);
      switch (timeFrame) {
         case PERIOD_M1:
            MaSlow = 30;
            MaFast = 10;
            break;
         case PERIOD_M5:
            MaSlow = 12;
            MaFast = 3;
            break;
         case PERIOD_M15:
            MaSlow = 16;
            MaFast = 4;
            break;
         case PERIOD_M30:
            MaSlow = 16;
            MaFast = 2;
            break;
         case PERIOD_H1:
            MaSlow = 24;
            MaFast = 8;
            break;
         case PERIOD_H4:
            MaSlow = 18;
            MaFast = 6;
            break;
         case PERIOD_D1:
            MaSlow = 5;
            MaFast = 3;
            break;
         case PERIOD_W1:
            MaSlow = 9;
            MaFast = 3;
            break;
         case PERIOD_MN1:
            MaSlow = 12;
            MaFast = 3;
            break;
      }
      curr1 = StringSubstr(Symbol(), 0, 3);
      curr2 = StringSubstr(Symbol(), 3, 3);
      IndicatorShortName(Indicator_Name);
      return (0);
   }


   //+------------------------------------------------------------------
   //|                                                                  
   //+------------------------------------------------------------------
   string symbols[];
   void addSymbol(string tsymbol) {
      ArrayResize(symbols, ArraySize(symbols) + 1);
      symbols[ArraySize(symbols) - 1] = tsymbol;
   }

   int getLimit(int limit, string tsymbol) {
      if (tsymbol != Symbol())
         limit = MathMax(MathMin(Bars - 1, iCustom(tsymbol, timeFrame, indicatorFileName, "returnBars", 0, 0) * timeFrame / Period()), limit);
      return (limit);
   }


   int deinit() {
      return (0);
   }

   //+------------------------------------------------------------------
   //|                                                                  
   //+------------------------------------------------------------------
   double values[8];
   double valuea[8];
   int start() {
      int i, r, counted_bars = IndicatorCounted();

      if (counted_bars < 0) return (-1);
      if (counted_bars > 0) counted_bars--;
      int limit = MathMin(Bars - counted_bars, Bars - 1);
      if (returnBars) {
         arrUSD[0] = limit;
         return (0);
      }

      for (int t = 0; t < ArraySize(symbols); t++)
         limit = getLimit(limit, symbols[t]);
      ArrayInitialize(values, -1);
      if (calculateValue || timeFrame == Period()) {
         if (!(endCandle > 0 && endCandle > startCandle))
            endCandle = limit;
         for (i = endCandle; i >= startCandle; i--) {
            double EURUSD_Fast = ma("EURUSD", MaFast, MaMethod, Price, i);
            double EURUSD_Slow = ma("EURUSD", MaSlow, MaMethod, Price, i);
            if (!EURUSD_Fast || !EURUSD_Slow)
               break;
            double GBPUSD_Fast = ma("GBPUSD", MaFast, MaMethod, Price, i);
            double GBPUSD_Slow = ma("GBPUSD", MaSlow, MaMethod, Price, i);
            if (!GBPUSD_Fast || !GBPUSD_Slow)
               break;
            double AUDUSD_Fast = ma("AUDUSD", MaFast, MaMethod, Price, i);
            double AUDUSD_Slow = ma("AUDUSD", MaSlow, MaMethod, Price, i);
            if (!AUDUSD_Fast || !AUDUSD_Slow)
               break;
            double XAUUSD_Fast = ma("XAUUSD", MaFast, MaMethod, Price, i);
            double XAUUSD_Slow = ma("XAUUSD", MaSlow, MaMethod, Price, i);
            if (!XAUUSD_Fast || !XAUUSD_Slow)
               break;
            double USDCAD_Fast = ma("USDCAD", MaFast, MaMethod, Price, i);
            double USDCAD_Slow = ma("USDCAD", MaSlow, MaMethod, Price, i);
            if (!USDCAD_Fast || !USDCAD_Slow)
               break;
            double USDCHF_Fast = ma("USDCHF", MaFast, MaMethod, Price, i);
            double USDCHF_Slow = ma("USDCHF", MaSlow, MaMethod, Price, i);
            if (!USDCHF_Fast || !USDCHF_Slow)
               break;
            double USDJPY_Fast = ma("USDJPY", MaFast, MaMethod, Price, i) / 100.0;
            double USDJPY_Slow = ma("USDJPY", MaSlow, MaMethod, Price, i) / 100.0;
            if (!USDJPY_Fast || !USDJPY_Slow) {
               break;
            }

            arrUSD[i] = 0;
            arrUSD[i] += EURUSD_Slow - EURUSD_Fast;
            arrUSD[i] += GBPUSD_Slow - GBPUSD_Fast;
            arrUSD[i] += AUDUSD_Slow - AUDUSD_Fast;
            arrUSD[i] += XAUUSD_Slow - XAUUSD_Fast;
            arrUSD[i] += USDCHF_Fast - USDCHF_Slow;
            arrUSD[i] += USDCAD_Fast - USDCAD_Slow;
            arrUSD[i] += USDJPY_Fast - USDJPY_Slow;
            values[0] = arrUSD[i];
            HideCurrency("USD", arrUSD[i]);

            arrEUR[i] = 0;
            arrEUR[i] += EURUSD_Fast - EURUSD_Slow;
            arrEUR[i] += EURUSD_Fast / GBPUSD_Fast - EURUSD_Slow / GBPUSD_Slow;
            arrEUR[i] += EURUSD_Fast / AUDUSD_Fast - EURUSD_Slow / AUDUSD_Slow;
            arrEUR[i] += EURUSD_Fast / XAUUSD_Fast - EURUSD_Slow / XAUUSD_Slow;
            arrEUR[i] += EURUSD_Fast * USDCHF_Fast - EURUSD_Slow * USDCHF_Slow;
            arrEUR[i] += EURUSD_Fast * USDCAD_Fast - EURUSD_Slow * USDCAD_Slow;
            arrEUR[i] += EURUSD_Fast * USDJPY_Fast - EURUSD_Slow * USDJPY_Slow;
            values[1] = arrEUR[i];
            HideCurrency("EUR", arrEUR[i]);

            arrGBP[i] = 0;
            arrGBP[i] += GBPUSD_Fast - GBPUSD_Slow;
            arrGBP[i] += EURUSD_Slow / GBPUSD_Slow - EURUSD_Fast / GBPUSD_Fast;
            arrGBP[i] += GBPUSD_Fast / AUDUSD_Fast - GBPUSD_Slow / AUDUSD_Slow;
            arrGBP[i] += GBPUSD_Fast / XAUUSD_Fast - GBPUSD_Slow / XAUUSD_Slow;
            arrGBP[i] += GBPUSD_Fast * USDCHF_Fast - GBPUSD_Slow * USDCHF_Slow;
            arrGBP[i] += GBPUSD_Fast * USDCAD_Fast - GBPUSD_Slow * USDCAD_Slow;
            arrGBP[i] += GBPUSD_Fast * USDJPY_Fast - GBPUSD_Slow * USDJPY_Slow;
            values[2] = arrGBP[i];
            HideCurrency("GBP", arrGBP[i]);

            arrAUD[i] = 0;
            arrAUD[i] += AUDUSD_Fast - AUDUSD_Slow;
            arrAUD[i] += EURUSD_Slow / AUDUSD_Slow - EURUSD_Fast / AUDUSD_Fast;
            arrAUD[i] += GBPUSD_Slow / AUDUSD_Slow - GBPUSD_Fast / AUDUSD_Fast;
            arrAUD[i] += AUDUSD_Fast / XAUUSD_Fast - AUDUSD_Slow / XAUUSD_Slow;
            arrAUD[i] += AUDUSD_Fast * USDCHF_Fast - AUDUSD_Slow * USDCHF_Slow;
            arrAUD[i] += AUDUSD_Fast * USDCAD_Fast - AUDUSD_Slow * USDCAD_Slow;
            arrAUD[i] += AUDUSD_Fast * USDJPY_Fast - AUDUSD_Slow * USDJPY_Slow;
            values[5] = arrAUD[i];
            HideCurrency("AUD", arrAUD[i]);

            arrXAU[i] = 0;
            arrXAU[i] += XAUUSD_Fast - XAUUSD_Slow;
            arrXAU[i] += EURUSD_Slow / XAUUSD_Slow - EURUSD_Fast / XAUUSD_Fast;
            arrXAU[i] += GBPUSD_Slow / XAUUSD_Slow - GBPUSD_Fast / XAUUSD_Fast;
            arrXAU[i] += AUDUSD_Slow / XAUUSD_Slow - AUDUSD_Fast / XAUUSD_Fast;
            arrXAU[i] += XAUUSD_Fast * USDCHF_Fast - XAUUSD_Slow * USDCHF_Slow;
            arrXAU[i] += XAUUSD_Fast * USDCAD_Fast - XAUUSD_Slow * USDCAD_Slow;
            arrXAU[i] += XAUUSD_Fast * USDJPY_Fast - XAUUSD_Slow * USDJPY_Slow;
            values[7] = arrXAU[i];
            HideCurrency("XAU", arrXAU[i]);

            arrCAD[i] = 0;
            arrCAD[i] += USDCAD_Slow - USDCAD_Fast;
            arrCAD[i] += EURUSD_Slow * USDCAD_Slow - EURUSD_Fast * USDCAD_Fast;
            arrCAD[i] += GBPUSD_Slow * USDCAD_Slow - GBPUSD_Fast * USDCAD_Fast;
            arrCAD[i] += AUDUSD_Slow * USDCAD_Slow - AUDUSD_Fast * USDCAD_Fast;
            arrCAD[i] += XAUUSD_Slow * USDCAD_Slow - XAUUSD_Fast * USDCAD_Fast;
            arrCAD[i] += USDCHF_Fast / USDCAD_Fast - USDCHF_Slow / USDCAD_Slow;
            arrCAD[i] += USDJPY_Fast / USDCAD_Fast - USDJPY_Slow / USDCAD_Slow;
            values[6] = arrCAD[i];
            HideCurrency("CAD", arrCAD[i]);

            arrCHF[i] = 0;
            arrCHF[i] += USDCHF_Slow - USDCHF_Fast;
            arrCHF[i] += EURUSD_Slow * USDCHF_Slow - EURUSD_Fast * USDCHF_Fast;
            arrCHF[i] += GBPUSD_Slow * USDCHF_Slow - GBPUSD_Fast * USDCHF_Fast;
            arrCHF[i] += AUDUSD_Slow * USDCHF_Slow - AUDUSD_Fast * USDCHF_Fast;
            arrCHF[i] += XAUUSD_Slow * USDCHF_Slow - XAUUSD_Fast * USDCHF_Fast;
            arrCHF[i] += USDCHF_Slow / USDCAD_Slow - USDCHF_Fast / USDCAD_Fast;
            arrCHF[i] += USDJPY_Fast / USDCHF_Fast - USDJPY_Slow / USDCHF_Slow;
            values[3] = arrCHF[i];
            HideCurrency("CHF", arrCHF[i]);

            arrJPY[i] = 0;
            arrJPY[i] += USDJPY_Slow - USDJPY_Fast;
            arrJPY[i] += EURUSD_Slow * USDJPY_Slow - EURUSD_Fast * USDJPY_Fast;
            arrJPY[i] += GBPUSD_Slow * USDJPY_Slow - GBPUSD_Fast * USDJPY_Fast;
            arrJPY[i] += AUDUSD_Slow * USDJPY_Slow - AUDUSD_Fast * USDJPY_Fast;
            arrJPY[i] += XAUUSD_Slow * USDJPY_Slow - XAUUSD_Fast * USDJPY_Fast;
            arrJPY[i] += USDJPY_Slow / USDCAD_Slow - USDJPY_Fast / USDCAD_Fast;
            arrJPY[i] += USDJPY_Slow / USDCHF_Slow - USDJPY_Fast / USDCHF_Fast;
            values[4] = arrJPY[i];
            HideCurrency("JPY", arrJPY[i]);
            if (i == 0) ArrayCopy(valuea, values);
            if (showDoubleGapsOnChart)
               doubleGapsOnChart(i);
         }
         manageDisplay();

         return (0);
      }
      // MTF Handling

      for (i = endCandle, r = Bars - i - 1; i >= 0; i--, r++) {
         int y = iBarShift(NULL, timeFrame, Time[i]);
         arrUSD[i] = iCustom(NULL, timeFrame, indicatorFileName, "calculateValue", showOnlySymbolOnChart, showOnlyDirectionOfPair, startCandle, endCandle, 0, y);
         arrEUR[i] = iCustom(NULL, timeFrame, indicatorFileName, "calculateValue", showOnlySymbolOnChart, showOnlyDirectionOfPair, startCandle, endCandle, 1, y);
         arrGBP[i] = iCustom(NULL, timeFrame, indicatorFileName, "calculateValue", showOnlySymbolOnChart, showOnlyDirectionOfPair, startCandle, endCandle, 2, y);
         arrCHF[i] = iCustom(NULL, timeFrame, indicatorFileName, "calculateValue", showOnlySymbolOnChart, showOnlyDirectionOfPair, startCandle, endCandle, 3, y);
         arrJPY[i] = iCustom(NULL, timeFrame, indicatorFileName, "calculateValue", showOnlySymbolOnChart, showOnlyDirectionOfPair, startCandle, endCandle, 4, y);
         arrAUD[i] = iCustom(NULL, timeFrame, indicatorFileName, "calculateValue", showOnlySymbolOnChart, showOnlyDirectionOfPair, startCandle, endCandle, 5, y);
         arrCAD[i] = iCustom(NULL, timeFrame, indicatorFileName, "calculateValue", showOnlySymbolOnChart, showOnlyDirectionOfPair, startCandle, endCandle, 6, y);
         arrXAU[i] = iCustom(NULL, timeFrame, indicatorFileName, "calculateValue", showOnlySymbolOnChart, showOnlyDirectionOfPair, startCandle, endCandle, 7, y);
         values[0] = arrUSD[i];
         values[1] = arrEUR[i];
         values[2] = arrGBP[i];
         values[3] = arrCHF[i];
         values[4] = arrJPY[i];
         values[5] = arrAUD[i];
         values[6] = arrCAD[i];
         values[7] = arrXAU[i];
         if (i == 0) ArrayCopy(valuea, values);
         if (!Interpolate || y == iBarShift(NULL, timeFrame, Time[i - 1])) continue;
         interpolate(arrUSD, iTime(NULL, timeFrame, y), i);
         interpolate(arrEUR, iTime(NULL, timeFrame, y), i);
         interpolate(arrGBP, iTime(NULL, timeFrame, y), i);
         interpolate(arrJPY, iTime(NULL, timeFrame, y), i);
         interpolate(arrCHF, iTime(NULL, timeFrame, y), i);
         interpolate(arrAUD, iTime(NULL, timeFrame, y), i);
         interpolate(arrCAD, iTime(NULL, timeFrame, y), i);
         interpolate(arrXAU, iTime(NULL, timeFrame, y), i);
         if (showDoubleGapsOnChart)
            doubleGapsOnChart(i);
      }
      manageDisplay();
      return (0);
   }

   void HideCurrency(string actCur, double & ArrEl) {
      if (!showOnlySymbolOnChart)
         return;
      if (StringFind(Symbol(), actCur) == -1)
         ArrEl = EMPTY_VALUE;
   }

   //-------------------------------------------------------------------
   //                                                                  
   //-------------------------------------------------------------------

   void manageDisplay() {
      double tempV[8];
      int i;
      ArrayCopy(tempV, valuea);
      int window = WindowFind(Indicator_Name);

      // Show legend color signs
      int cur = 12;
      int st = 23;
      for (i = 0; i <= 7; i++)
         if (ShowLabelCurrency(names[i])) {
            string ID = Indicator_Name + "lblCur" + string(i);
            ObjectCreate(ID, OBJ_LABEL, window, 0, 0);
            if (TimeFrame == "")
               ObjectSet(ID, OBJPROP_XDISTANCE, cur + 30);
            else
               ObjectSet(ID, OBJPROP_XDISTANCE, cur + 40);
            ObjectSet(ID, OBJPROP_YDISTANCE, 5);
            ObjectSetText(ID, "~", 18, "Arial Black", colors[i]);
            SetIndexLabel(i, names[i]);
            cur += st;
         }


      // Show right pane
      int k = 0;
      int y = 0;
      for (i = 0; i < 8; i++)
         if (ShowLabelCurrency(names[i])) {
            string name = Indicator_Name + ":" + i;
            ObjectCreate(name, OBJ_LABEL, window, 0, 0);
            ObjectSet(name, OBJPROP_XDISTANCE, 70);
            ObjectSet(name, OBJPROP_YDISTANCE, y);
            ObjectSet(name, OBJPROP_BACK, FALSE);
            ObjectSet(name, OBJPROP_CORNER, 1);
            ObjectSetText(name, names[i] + ":  ", 10, "Arial bold", colors[i]);
            name = Indicator_Name + ":n" + i;
            ObjectCreate(name, OBJ_LABEL, window, 0, 0);
            ObjectSet(name, OBJPROP_XDISTANCE, 10);
            ObjectSet(name, OBJPROP_YDISTANCE, y);
            ObjectSet(name, OBJPROP_BACK, FALSE);
            ObjectSet(name, OBJPROP_CORNER, 1);
            ObjectSetText(name, DoubleToStr(tempV[i], 6), 10, "Arial bold", colors[i]);
            ObjectSet(name, OBJPROP_COLOR, colors[i]);
            y += 16;
            k++;
         }
   }

   //-------------------------------------------------------------------
   //                                                                  
   //-------------------------------------------------------------------
   void interpolate(double & buffer[], datetime time, int i) {
      for (int n = 1;
         (i + n) < Bars && Time[i + n] >= time; n++) continue;

      if (buffer[i] == EMPTY_VALUE || buffer[i + n] == EMPTY_VALUE) n = -1;
      double increment = (buffer[i + n] - buffer[i]) / n;
      for (int k = 1; k < n; k++) buffer[i + k] = buffer[i] + k * increment;
   }


   double ma(string sym, int per, int Mode, int tPrice, int i) {
      return (iMA(sym, 0, per, 0, Mode, tPrice, i));
   }

   //+------------------------------------------------------------------
   //|                                                                  
   //+------------------------------------------------------------------

   void sl(int buffNo, string sym, int x, color col, string buffLabel) {
      int window = WindowFind(Indicator_Name);
      string ID = Indicator_Name + buffNo;

      if (ObjectCreate(ID, OBJ_LABEL, window, 0, 0))
         ObjectSet(ID, OBJPROP_XDISTANCE, x + 25);
      ObjectSet(ID, OBJPROP_YDISTANCE, 5);
      ObjectSetText(ID, sym, 18, "Arial Black", col);

      SetIndexStyle(buffNo, DRAW_LINE, STYLE_SOLID, 1, col);
      SetIndexLabel(buffNo, buffLabel);
   }

   //+-------------------------------------------------------------------
   //|                                                                  
   //+-------------------------------------------------------------------


   string sTfTable[] = {
      "M1",
      "M5",
      "M15",
      "M30",
      "H1",
      "H4",
      "D1",
      "W1",
      "MN"
   };
   int iTfTable[] = {
      1,
      5,
      15,
      30,
      60,
      240,
      1440,
      10080,
      43200
   };


   int stringToTimeFrame(string tfs) {
      StringToUpper(tfs);
      for (int i = ArraySize(iTfTable) - 1; i >= 0; i--)
         if (tfs == sTfTable[i] || tfs == "" + iTfTable[i]) return (MathMax(iTfTable[i], Period()));
      return (Period());
   }
   string timeFrameToString(int tf) {
      for (int i = ArraySize(iTfTable) - 1; i >= 0; i--)
         if (tf == iTfTable[i]) return (sTfTable[i]);
      return ("");
   }

   bool ShowLabelCurrency(string actCur) {
      if (!showOnlySymbolOnChart)
         return true;
      return (StringFind(Symbol(), actCur) >= 0);
   }

   void initLabels() {

      Indicator_Name = StringConcatenate(Indicator_Name, TimeFrame + "   ");
      for (int i = 0; i <= 7; i++)
         if (ShowLabelCurrency(names[i]))
            Indicator_Name = StringConcatenate(Indicator_Name, names[i] + " ");
      Indicator_Name = StringConcatenate(Indicator_Name, "   ");
   }


   void doubleGapsOnChart(int i) {
      if (showDoubleGapsOnChart) {
         if (arrVal(i + doubleCandleDiff, curr1) < arrVal(i, curr1) && arrVal(i + doubleCandleDiff, curr2) > arrVal(i, curr2)) {
            arrowUp[i] = arrVal(i, curr1);
            if (!showOnlyDirectionOfPair)
               arrowDn[i] = arrVal(i, curr2);
         } else if (arrVal(i + doubleCandleDiff, curr1) > arrVal(i, curr1) && arrVal(i + doubleCandleDiff, curr2) < arrVal(i, curr2)) {
            arrowDn[i] = arrVal(i, curr1);
            if (!showOnlyDirectionOfPair)
               arrowUp[i] = arrVal(i, curr2);
         } else {
            arrowUp[i] = EMPTY_VALUE;
            arrowDn[i] = EMPTY_VALUE;
         }
      }
   }

I got an indicator that is two dimensional buffer. My question is how to access buffer to see whether I got up arrow or down arrow for XAU?  see screen print below  

I use icustom call as below and what I got is empty value>


       double BuyArrow8 = iCustom(Symbol(),0,"CCFp mtf 2.10- Simplied by HT",  8, 1); //buy 

       double SellArrow9 = iCustom(Symbol(),0,"CCFp mtf 2.10- Simplied by HT",  9, 1); //Sell 



 

Forum on trading, automated trading systems and testing trading strategies


When you post code please use the CODE button (Alt-S)!

Use the CODE button


 
XIn Li: I got an indicator that is two dimensional buffer. My question is how to access buffer to see whether I got up arrow or down arrow for XAU? 
  1. Please edit your (original) post and use the CODE button (Alt-S)! (For large amounts of code, attach it.)
              General rules and best pratices of the Forum. - General - MQL5 programming forum
              Messages Editor

  2. There are no "two dimensional buffer" There are only multiple 1D buffers. You should encapsulate your iCustom calls to make your code self-documenting.
              Detailed explanation of iCustom - MQL4 programming forum 

  3. SetIndexBuffer(0, arrUSD);
SetIndexBuffer(1, arrEUR);
SetIndexBuffer(2, arrGBP);
SetIndexBuffer(3, arrCHF);
SetIndexBuffer(4, arrJPY);
SetIndexBuffer(5, arrAUD);
SetIndexBuffer(6, arrCAD);
SetIndexBuffer(7, arrXAU);
SetIndexBuffer(8, arrowUp);
SetIndexBuffer(9, arrowDn);
    Second from the last parameter in iCustom is the buffer index.
 
William Roeder:
  1. Please edit your (original) post and use the CODE button (Alt-S)! (For large amounts of code, attach it.)
              General rules and best pratices of the Forum. - General - MQL5 programming forum
              Messages Editor

  2. There are no "two dimensional buffer" There are only multiple 1D buffers. You should encapsulate your iCustom calls to make your code self-documenting.
              Detailed explanation of iCustom - MQL4 programming forum

  3. Second from the last parameter in iCustom is the buffer index.

Thanks Williams. 

I edited the first post. I used icustom call as below and what I got from the call is empty value.         Please advice. 

       double BuyArrow8 = iCustom(Symbol(),0,"CCFp mtf 2.10- Simplied by HT",  8, 1); //buy 
       double SellArrow9 = iCustom(Symbol(),0,"CCFp mtf 2.10- Simplied by HT",  9, 1); //Sell
 
Either your indicator is broken or your iCustom is. Verify the indicator file name is exactly what you have in the iCustom. A hyphen followed by a space?
 
William Roeder:
Either your indicator is broken or your iCustom is. Verify the indicator file name is exactly what you have in the iCustom. A hyphen followed by a space?

Thanks again. Strange, in back tester the indicator windows is blank. However, in a normal chart it works.




New comment