//+------------------------------------------------------------------+
//|                                        CurrencySlopeStrength.mq4 |
//|                      Copyright 2012, Deltabron - Paul Geirnaerdt |
//|                                          http://www.delon.nl |
//|                    mrtools made TMA Halflength a user controlled |
//|                    feature and added Price to the mix            |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Deltabron - Paul Geirnaerdt"
#property link      "http://www.delon.nl"


#property indicator_separate_window
#property indicator_buffers    8
#property indicator_levelcolor MediumOrchid

//
//
//
//
//

#define version            "v1.0.3.1"
#define EPSILON            0.00000001
#define CURRENCYCOUNT      8

//
//
//
//
//
extern int     BARS                 = 500;
extern string  gen                   = "----General inputs----";
extern bool    autoSymbols           = false;
extern string	symbolsToWeigh        = "GBPNZD,EURNZD,GBPAUD,GBPCAD,GBPJPY,GBPCHF,CADJPY,EURCAD,EURAUD,USDCHF,GBPUSD,EURJPY,NZDJPY,AUDCHF,AUDJPY,USDJPY,EURUSD,NZDCHF,CADCHF,AUDNZD,NZDUSD,CHFJPY,AUDCAD,USDCAD,NZDCAD,AUDUSD,EURCHF,EURGBP";
extern string  nonPropFont           = "Lucida Console";
extern bool    showOnlySymbolOnChart = true;

extern string  ind                   = "----Indicator inputs----";
extern double  HalfLength            = 20;
extern int     Price                 = PRICE_WEIGHTED;
extern bool    autoTimeFrame         = true;
extern string  ind_tf                = "timeFrame M1,M5,M15,M30,H1,H4,D1,W1,MN";
extern string  timeFrame             = "D1";
extern bool    ignoreFuture          = false;
extern bool    showCrossAlerts       = true;
extern double  differenceThreshold   = 0.8;

extern string  cur                   = "----Currency inputs----";
extern bool    USD                   = true;
extern bool    EUR                   = true;
extern bool    GBP                   = true;
extern bool    CHF                   = true;
extern bool    JPY                   = true;
extern bool    AUD                   = true;
extern bool    CAD                   = true;
extern bool    NZD                   = true;

extern string  col                   = "----Color inputs----";
extern color   Color_USD             = Green;
extern color   Color_EUR             = DeepSkyBlue;
extern color   Color_GBP             = Red;
extern color   Color_CHF             = Chocolate;
extern color   Color_JPY             = FireBrick;
extern color   Color_AUD             = DarkOrange;
extern color   Color_CAD             = Purple;
extern color   Color_NZD             = Teal;
extern color   colorWeakCross        = OrangeRed;
extern color   colorNormalCross      = Gold;
extern color   colorStrongCross      = LimeGreen;
extern color   colorDifference       = 0x303000;
extern int     Line_Thickness        = 2;

// 
//
//
//
//

string   indicatorName = "CurrencySlopeStrength";
string   shortName;
int      userTimeFrame;
string   almostUniqueIndex;

//
//
//
//
//

double   arrUSD[];
double   arrEUR[];
double   arrGBP[];
double   arrCHF[];
double   arrJPY[];
double   arrAUD[];
double   arrCAD[];
double   arrNZD[];

//
//
//
//
//

int      symbolCount;
string   symbolNames[];
string   currencyNames[CURRENCYCOUNT]        = { "USD", "EUR", "GBP", "CHF", "JPY", "AUD", "CAD", "NZD" };
double   currencyValues[CURRENCYCOUNT];      // Currency slope strength
double   currencyValuesPrior[CURRENCYCOUNT]; // Currency slope strength prior bar
double   currencyOccurrences[CURRENCYCOUNT]; // Holds the number of occurrences of each currency in symbols
color    currencyColors[CURRENCYCOUNT];

//
//
//
//
//

int      verticalShift    = 14;
int      verticalOffset   = 30;
int      horizontalShift  = 100;
int      horizontalOffset = 10;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
//
//

int init()
{
   HalfLength = MathMax(HalfLength,1);
   initSymbols();
   
   SetIndexBuffer(0,arrUSD); SetIndexLabel(0,"USD"); currencyColors[0] = Color_USD; 
   SetIndexBuffer(1,arrEUR); SetIndexLabel(1,"EUR"); currencyColors[1] = Color_EUR;
   SetIndexBuffer(2,arrGBP); SetIndexLabel(2,"GBP"); currencyColors[2] = Color_GBP; 
   SetIndexBuffer(3,arrCHF); SetIndexLabel(3,"CHF"); currencyColors[3] = Color_CHF;
   SetIndexBuffer(4,arrJPY); SetIndexLabel(4,"JPY"); currencyColors[4] = Color_JPY;
   SetIndexBuffer(5,arrAUD); SetIndexLabel(5,"AUD"); currencyColors[5] = Color_AUD; 
   SetIndexBuffer(6,arrCAD); SetIndexLabel(6,"CAD"); currencyColors[6] = Color_CAD;
   SetIndexBuffer(7,arrNZD); SetIndexLabel(7,"NZD"); currencyColors[7] = Color_NZD; 
   SetLevelValue(0,0);

   string now = TimeCurrent();
   almostUniqueIndex = StringSubstr(now, StringLen(now) - 3);
   
   shortName = indicatorName + " - " + version;
   IndicatorShortName(shortName);
   return(0);
}

//+------------------------------------------------------------------+
//| Initialize Symbols Array                                         |
//+------------------------------------------------------------------+
//
//

int initSymbols()
{
   int i;
   string symbolExtraChars = StringSubstr(Symbol(),6,4);

   // 
   //
   //
   //
   //
   
   symbolsToWeigh = StringTrimLeft(symbolsToWeigh);
   symbolsToWeigh = StringTrimRight(symbolsToWeigh);

   // 
   //
   //
   //
   //
   
   if (StringSubstr(symbolsToWeigh, StringLen(symbolsToWeigh)-1) != ",")
   {
      symbolsToWeigh = StringConcatenate(symbolsToWeigh, ",");   
   }   

   //
   //
   //
   //
   //
   
   if (autoSymbols)
   {
      createSymbolNamesArray();
   }
   else
   {
    
      i = StringFind(symbolsToWeigh, ","); 
      while (i != -1)
      {
         int size = ArraySize(symbolNames);
        
         ArrayResize(symbolNames, size + 1);
    
         symbolNames[size] = StringConcatenate(StringSubstr(symbolsToWeigh, 0, i),symbolExtraChars);
         
         symbolsToWeigh = StringSubstr(symbolsToWeigh, i + 1);
         i = StringFind(symbolsToWeigh, ","); 
      }
   }
   
   // 
   //
   //
   //
   //
   
   if (showOnlySymbolOnChart)
   {
      symbolCount = ArraySize(symbolNames);
      string tempNames[];
      for (i = 0; i < symbolCount; i++)
      {
         for (int j = 0; j < CURRENCYCOUNT; j++)
         {
            if (StringFind( Symbol(), currencyNames[j] ) == -1)
            {
               break;
            }
            if (StringFind(symbolNames[i], currencyNames[j] ) != -1)
            {  
               size = ArraySize(tempNames);
               ArrayResize(tempNames, size + 1);
               tempNames[size] = symbolNames[i];
               break;
            }
         }
      }
      for (i = 0; i < ArraySize(tempNames); i++)
      {
         ArrayResize(symbolNames, i+1);
         symbolNames[i] = tempNames[i];
      }
   }
   
   symbolCount = ArraySize(symbolNames);

   for (i = 0; i < symbolCount; i++)
   {
      int currencyIndex = GetCurrencyIndex(StringSubstr(symbolNames[i],0,3));
          currencyOccurrences[currencyIndex]++;
          
          currencyIndex = GetCurrencyIndex(StringSubstr(symbolNames[i],3,3));
          currencyOccurrences[currencyIndex]++;
   }   
   
   //
   //
   //
   //
   //
   
   userTimeFrame = PERIOD_D1;
   if (autoTimeFrame)   {  userTimeFrame = Period();   }   
	else 
	{ 
	          if (timeFrame == "M1" ) userTimeFrame = PERIOD_M1;
		else   if (timeFrame == "M5" ) userTimeFrame = PERIOD_M5;
		else   if (timeFrame == "M15") userTimeFrame = PERIOD_M15;
		else   if (timeFrame == "M30") userTimeFrame = PERIOD_M30;
		else   if (timeFrame == "H1" ) userTimeFrame = PERIOD_H1;
		else   if (timeFrame == "H4" ) userTimeFrame = PERIOD_H4;
		else   if (timeFrame == "D1" ) userTimeFrame = PERIOD_D1;
		else   if (timeFrame == "W1" ) userTimeFrame = PERIOD_W1;
		else   if (timeFrame == "MN" ) userTimeFrame = PERIOD_MN1;
   } 
		
}

//+------------------------------------------------------------------+
//| GetCurrencyIndex(string currency)                                |
//+------------------------------------------------------------------+
//
//

int GetCurrencyIndex(string currency)
{
   for (int i = 0; i < CURRENCYCOUNT; i++)
   {
      if (currencyNames[i] == currency)
      {
         return(i);
      }   
   }   
   return (-1);
}

//+------------------------------------------------------------------+
//| createSymbolNamesArray()                                         |
//+------------------------------------------------------------------+
//
//

void createSymbolNamesArray()
{
   int hFileName   = FileOpenHistory ("symbols.raw", FILE_BIN|FILE_READ);
   int recordCount = FileSize (hFileName) / 1936;
   int counter = 0;
   
   //
   //
   //
   //
   //
   
   for (int i = 0; i < recordCount; i++)
   {
      string tempSymbol = StringTrimLeft (StringTrimRight (FileReadString (hFileName, 12)));
      if (MarketInfo (tempSymbol, MODE_BID) > 0 && MarketInfo (tempSymbol, MODE_TRADEALLOWED))
      {
         ArrayResize(symbolNames, counter + 1);
         symbolNames[counter] = tempSymbol;
         counter++;
      }
      FileSeek(hFileName, 1924, SEEK_CUR);
   }
   FileClose(hFileName);
return (0);
}

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
//
//

int deinit()
{

   int windex = WindowFind (shortName);
   if (windex > 0)
   {
      ObjectsDeleteAll (windex);
   }   

   return(0);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
//
//

int start()
{
   int counted_bars=IndicatorCounted();
   int i,j,limit;

   if(counted_bars<0) return(-1);
   if(counted_bars>0) counted_bars--;
           limit=MathMin(Bars-1,Bars-counted_bars+HalfLength);
    if(limit>BARS)limit=BARS;
   //
   //
   //
   //
   //
   
   for ( i = limit; i >= 0; i-- )
   { 
   
      for (j = 0; j < CURRENCYCOUNT; j++) { SetIndexStyle(j,DRAW_LINE,STYLE_SOLID,Line_Thickness,currencyColors[j]); }   

      int    index;
      double diff = 0.0;
      
      ArrayInitialize(currencyValues, 0.0); 
      CalculateCurrencySlopeStrength(userTimeFrame,i);
      
      //
      //
      //
      //
      //
      
      if ((showOnlySymbolOnChart && (StringFind(Symbol(),"USD") != -1)) || (!showOnlySymbolOnChart && USD))        
      {
         arrUSD[i]           = currencyValues[0];
         if (diff ==0) diff += currencyValues[0]; 
         else          diff -= currencyValues[0];
      }
      
      //
      //
      //
      //
      //
      
      if ((showOnlySymbolOnChart && (StringFind(Symbol(),"EUR") != -1)) || (!showOnlySymbolOnChart && EUR))        
      {
         arrEUR[i]            = currencyValues[1];
         if (diff == 0) diff += currencyValues[1]; 
         else           diff -= currencyValues[1];
      }
      
      //
      //
      //
      //
      //
      
      if ((showOnlySymbolOnChart && (StringFind(Symbol(),"GBP") != -1)) || (!showOnlySymbolOnChart && GBP))        
      {
         arrGBP[i]            = currencyValues[2];
         if (diff == 0) diff += currencyValues[2]; 
         else           diff -= currencyValues[2];
      }
      
      //
      //
      //
      //
      //
      
      if ((showOnlySymbolOnChart && (StringFind(Symbol(),"CHF")!= -1)) || (!showOnlySymbolOnChart && CHF))        
      {
         arrCHF[i]            = currencyValues[3];
         if (diff == 0) diff += currencyValues[3];
         else           diff -= currencyValues[3];
      }
      
      //
      //
      //
      //
      //
      
      if ((showOnlySymbolOnChart && (StringFind(Symbol(),"JPY")!= -1)) || (!showOnlySymbolOnChart && JPY))        
      {
         arrJPY[i]            = currencyValues[4];
         if (diff == 0) diff += currencyValues[4]; 
         else           diff -= currencyValues[4];
      }
      
      //
      //
      //
      //
      //
      
      if ((showOnlySymbolOnChart && (StringFind(Symbol(),"AUD" )!= -1)) || ( !showOnlySymbolOnChart && AUD ) )        
      {
         arrAUD[i]            = currencyValues[5];
         if (diff == 0) diff += currencyValues[5]; 
         else           diff -= currencyValues[5];
      }
      
      //
      //
      //
      //
      //
      
      if ((showOnlySymbolOnChart && (StringFind(Symbol(),"CAD")!= -1)) || (!showOnlySymbolOnChart && CAD))        
      {
         arrCAD[i]            = currencyValues[6];
         if (diff == 0) diff += currencyValues[6]; 
         else           diff -= currencyValues[6];
      }
      
      //
      //
      //
      //
      //
      
      if ((showOnlySymbolOnChart && (StringFind(Symbol(),"NZD")!= -1)) || (!showOnlySymbolOnChart && NZD))        
      {
         arrNZD[i]            = currencyValues[7];
         if (diff == 0) diff += currencyValues[7]; 
         else           diff -= currencyValues[7];
      }
      
      //
      //
      //
      //
      //
      
      if ( i == 1 )
      {
         ArrayCopy(currencyValuesPrior,currencyValues);
      }
      if ( i == 0 )
      {
       
         ShowCurrencyTable();
      }
      
      //
      //
      //
      //
      //
      
      if (showOnlySymbolOnChart && MathAbs(diff) > differenceThreshold)
      {
         int windex = WindowFind (shortName);
         string objectName = almostUniqueIndex + "_diff_" + i;
         if ( ObjectFind (objectName) == -1)
         {
            if (ObjectCreate (objectName, OBJ_VLINE, windex, Time[i], 0))
            {
               ObjectSet (objectName, OBJPROP_COLOR, colorDifference);
               ObjectSet (objectName, OBJPROP_BACK, true);
               ObjectSet (objectName, OBJPROP_WIDTH, 8);
               
            }
         }
       
      }

   }
   
   return(0);
}

//+------------------------------------------------------------------+
//| GetSlope()                                                       |
//+------------------------------------------------------------------+
//
//

double GetSlope(string symbol, int tf, int shift)
{
   double dblTma, dblPrev;
   double gadblSlope = 0.0;
   
   //
   //
   //
   //
   //
   
   double atr = iATR(symbol,tf,100,shift+10) / 10;
   
   if (atr != 0)
   {
      if (ignoreFuture)
      {
         dblTma     = calcTmaTrue( symbol, tf, shift);
         dblPrev    = calcPrevTrue(symbol, tf, shift);
      }
      else
      {   
         dblTma     = calcTma(symbol,tf,shift);
         dblPrev    = calcTma(symbol,tf,shift+1);
      }   
         gadblSlope = (dblTma - dblPrev) / atr;
   }
   
return (gadblSlope);

}

//+------------------------------------------------------------------+
//| calcTma()                                                        |
//+------------------------------------------------------------------+
//
//

double calcTma(string symbol, int tf,  int shift)
{
   int jnx, knx;
   
   //
   //
   //
   //
   //
   
   double dblSum  = (HalfLength+1) * iMA(symbol,tf,1,0,MODE_SMA,Price,shift);
   double dblSumw = (HalfLength+1);
   
         
   for (jnx = 1, knx = HalfLength; jnx <= HalfLength; jnx++, knx--)
   {
      dblSum  += iMA(symbol,tf,1,0,MODE_SMA,Price,shift+jnx)*knx;
      dblSumw += knx;

      if (jnx <= shift)
      {
         dblSum  += iMA(symbol,tf,1,0,MODE_SMA,Price,shift-jnx)*knx;
         dblSumw += knx;
      }
   }
   
return (dblSum/dblSumw);
}


//+------------------------------------------------------------------+
//| calcTmaTrue()                                                    |
//+------------------------------------------------------------------+
//
//

double calcTmaTrue(string symbol, int tf, int inx )
{
   return (iMA(symbol,tf,HalfLength,0, MODE_LWMA, PRICE_CLOSE,inx));
}

//+------------------------------------------------------------------+
//| calcPrevTrue()                                                   |
//+------------------------------------------------------------------+
//
//

double calcPrevTrue( string symbol, int tf, int inx )
{
   double dblSum  = (HalfLength+1) * iMA(symbol,tf,1,0,MODE_SMA,Price,inx+1);
   double dblSumw = (HalfLength+1);
   int jnx, knx;
   
   dblSum  += HalfLength * iMA(symbol,tf,1,0,MODE_SMA,Price,inx);
   dblSumw += HalfLength;
         
   for ( jnx = 1, knx = HalfLength; jnx <= HalfLength; jnx++, knx-- )
   {
      dblSum  += iMA(symbol,tf,1,0,MODE_SMA,Price,inx+1+jnx ) * knx;
      dblSumw += knx;
   }
   
return (dblSum/dblSumw);
}
 
//+------------------------------------------------------------------+
//| CalculateCurrencySlopeStrength(int tf, int shift                 |
//+------------------------------------------------------------------+
//
//

void CalculateCurrencySlopeStrength(int tf, int shift)
{
   int i;
   
   //
   //
   //
   //
   //
   
   for ( i = 0; i < symbolCount; i++)
   {
      double slope = GetSlope(symbolNames[i], tf, shift);
      currencyValues[GetCurrencyIndex(StringSubstr(symbolNames[i],0,3))] += slope;
      currencyValues[GetCurrencyIndex(StringSubstr(symbolNames[i],3,3))] -= slope;
   }
   for (i = 0; i < CURRENCYCOUNT; i++) {  currencyValues[i] /= currencyOccurrences[i]; }
}

//+------------------------------------------------------------------+
//| ShowCurrencyTable()                                              |
//+------------------------------------------------------------------+
//
//

void ShowCurrencyTable()
{
   int    i;
   int    tempValue;
   string objectName;
   string showText;
   color  showColor;
   int    windex = WindowFind (shortName);
   
   //
   //
   //
   //
   //
   
   if (showOnlySymbolOnChart)
   {
      for (i = 0; i < 2; i++)
      {
         int index  = GetCurrencyIndex(StringSubstr(Symbol(),3*i,3));
         objectName = almostUniqueIndex + "_css_obj_column_currency_" + i;
         
         if (ObjectFind (objectName) == -1)
         {
            if (ObjectCreate (objectName, OBJ_LABEL, windex, 0, 0))
            {
               ObjectSet (objectName, OBJPROP_CORNER,1);
               ObjectSet (objectName, OBJPROP_XDISTANCE,  horizontalShift * 0 + horizontalOffset + 70);
               ObjectSet (objectName, OBJPROP_YDISTANCE, (verticalShift + 6) * i + verticalOffset - 18);
            }
         }
         ObjectSetText (objectName, currencyNames[index], 14, nonPropFont, currencyColors[index]);

         objectName = almostUniqueIndex + "_css_obj_column_value_" + i;
         if (ObjectFind (objectName ) == -1)
         {
            if (ObjectCreate (objectName, OBJ_LABEL, windex, 0, 0))
            {
               ObjectSet (objectName, OBJPROP_CORNER, 1);
               ObjectSet (objectName, OBJPROP_XDISTANCE, horizontalShift * 0 + horizontalOffset - 65 + 70);
               ObjectSet (objectName, OBJPROP_YDISTANCE, (verticalShift + 6) * i + verticalOffset - 18);
            }
         }
         showText = RightAlign(DoubleToStr(currencyValues[index], 2), 5);
         ObjectSetText (objectName, showText, 14, nonPropFont, currencyColors[index]);
      }
      objectName = almostUniqueIndex + "_css_obj_column_currency_3";
      if (ObjectFind ( objectName ) == -1)
      {
         if (ObjectCreate (objectName, OBJ_LABEL, windex, 0, 0))
         {
            ObjectSet (objectName, OBJPROP_CORNER, 1);
            ObjectSet (objectName, OBJPROP_XDISTANCE, horizontalShift * 0 + horizontalOffset + 5);
            ObjectSet (objectName, OBJPROP_YDISTANCE, (verticalShift + 6) * 2 + verticalOffset - 10);
         }
      }
      showText = "threshold = " + DoubleToStr(differenceThreshold, 1);
      ObjectSetText (objectName, showText, 8, nonPropFont, Yellow);
   }
   else
   {
     
      double tempCurrencyValues[CURRENCYCOUNT][3];
   
      for (i = 0; i < CURRENCYCOUNT; i++)
      {
         tempCurrencyValues[i][0] = currencyValues[i];
         tempCurrencyValues[i][1] = NormalizeDouble(currencyValuesPrior[i], 2);
         tempCurrencyValues[i][2] = i;
      }
   
      ArraySort(tempCurrencyValues, WHOLE_ARRAY, 0, MODE_DESCEND);

      int horizontalOffsetCross = 0;
      for (i = 0; i < CURRENCYCOUNT; i++)
      {
         objectName = almostUniqueIndex + "_css_obj_column_currency_" + i;
         if (ObjectFind (objectName ) == -1)
         {
            if (ObjectCreate (objectName, OBJ_LABEL, windex, 0, 0))
            {
               ObjectSet (objectName, OBJPROP_CORNER, 1);
               ObjectSet (objectName, OBJPROP_XDISTANCE, horizontalShift * 0 + horizontalOffset + 150);
               ObjectSet (objectName, OBJPROP_YDISTANCE, (verticalShift + 2) * i + verticalOffset - 18);
            }
         }
         tempValue = tempCurrencyValues[i][2];
         showText = currencyNames[tempValue];
         ObjectSetText (objectName, showText, 12, nonPropFont, currencyColors[tempValue]);

         objectName = almostUniqueIndex + "_css_obj_column_value_" + i;
         if (ObjectFind ( objectName ) == -1)
         {
            if (ObjectCreate (objectName, OBJ_LABEL, windex, 0, 0))
            {
               ObjectSet (objectName, OBJPROP_CORNER, 1 );
               ObjectSet (objectName, OBJPROP_XDISTANCE, horizontalShift * 0 + horizontalOffset - 55 + 150);
               ObjectSet (objectName, OBJPROP_YDISTANCE, (verticalShift + 2) * i + verticalOffset - 18);
            }
         }
         showText = RightAlign(DoubleToStr(tempCurrencyValues[i][0], 2), 5);
         ObjectSetText (objectName, showText, 12, nonPropFont, currencyColors[tempValue]);
      
         // 
         //
         //
         //
         //
         
         objectName = almostUniqueIndex + "_css_obj_column_cross_" + i;
         if (showCrossAlerts && i < CURRENCYCOUNT-1 && NormalizeDouble(tempCurrencyValues[i][0],2) > NormalizeDouble(tempCurrencyValues[i+1][0],2)
              && tempCurrencyValues[i][1] < tempCurrencyValues[i+1][1])
         {
            showColor = colorStrongCross;
              if (tempCurrencyValues[i][0] > 0.8 || tempCurrencyValues[i+1][0] < -0.8 ) { showColor = colorWeakCross;   }
         else if (tempCurrencyValues[i][0] > 0.4 || tempCurrencyValues[i+1][0] < -0.4 ) { showColor = colorNormalCross; }
      
            //
            //
            //
            //
            //
            
            DrawCell(windex,objectName,horizontalShift*0 + horizontalOffset + 88 + horizontalOffsetCross, (verticalShift + 2) * i + verticalOffset - 20, 1, 27, showColor );
      
            if (horizontalOffsetCross == 0) { horizontalOffsetCross = -4; }
            else                            { horizontalOffsetCross = 0;  }
            }
            else                            { DeleteCell(objectName);
                                              horizontalOffsetCross = 0;  }
            }
      }
}

//+------------------------------------------------------------------+
//| Right Align Text                                                 |
//+------------------------------------------------------------------+
//
//

string RightAlign (string text, int length = 10, int trailing_spaces = 0)
{
   string text_aligned = text;
   for (int i = 0; i < length - StringLen (text) - trailing_spaces; i++)
   {
      text_aligned = " " + text_aligned;
   }
   return (text_aligned);
}

//+------------------------------------------------------------------+
//| DrawCell(), credits go to Alexandre A. B. Borela                 |
//+------------------------------------------------------------------+
//
//

void DrawCell (int nWindow, string nCellName, double nX, double nY, double nWidth, double nHeight, color nColor)
{
   double   iHeight, iWidth, iXSpace;
   int      iSquares, i;

   if (nWidth > nHeight)
   {
      iSquares = MathCeil (nWidth / nHeight); 
      iHeight  = MathRound((nHeight *100) / 77);
      iWidth   = MathRound((nWidth * 100) / 77); 
      iXSpace  = iWidth / iSquares - ((iHeight / (9 - (nHeight / 100))) * 2);

      for (i = 0; i < iSquares; i++)
      {
         ObjectCreate   (nCellName + i, OBJ_LABEL, nWindow, 0, 0);
         ObjectSetText  (nCellName + i, CharToStr ( 110 ), iHeight, "Wingdings", nColor);
         ObjectSet      (nCellName + i, OBJPROP_CORNER, 1);
         ObjectSet      (nCellName + i, OBJPROP_XDISTANCE, nX + iXSpace * i);
         ObjectSet      (nCellName + i, OBJPROP_YDISTANCE, nY);
         ObjectSet      (nCellName + i, OBJPROP_BACK, true);
      }
   }
   else
   {
      iSquares = MathCeil (nHeight / nWidth); 
      iHeight  = MathRound ((nHeight* 100) / 77); 
      iWidth   = MathRound ((nWidth * 100) / 77); 
      iXSpace  = iHeight / iSquares - ((iWidth / (9 - (nWidth / 100))) * 2);

      for ( i = 0; i < iSquares; i++ )
      {
         ObjectCreate   (nCellName + i, OBJ_LABEL, nWindow, 0, 0);
         ObjectSetText  (nCellName + i, CharToStr (110), iWidth, "Wingdings", nColor);
         ObjectSet      (nCellName + i, OBJPROP_CORNER, 1);
         ObjectSet      (nCellName + i, OBJPROP_XDISTANCE, nX);
         ObjectSet      (nCellName + i, OBJPROP_YDISTANCE, nY + iXSpace * i);
         ObjectSet      (nCellName + i, OBJPROP_BACK, true);
      }
   }
}

//+------------------------------------------------------------------+
//| DeleteCell()                                                     |
//+------------------------------------------------------------------+
//
//

void DeleteCell(string name)
{
   int square = 0;
   while (ObjectFind(name + square) > -1)
   {
      ObjectDelete(name + square);
      square++;
   }   
}


