//+------------------------------------------------------------------+
//|                                     CCp_v2-CW-Level_Diff-MTF.mq4 |
//|                                         by LuboLabo 5 nov 2008   |
//|                                  BASED on Common conplex work by |
//|                                              SemSemFX@rambler.ru |
//|              http://onix-trade.net/forum/index.php?showtopic=107 |
//|                        Modifed version by Skyline on 09 Oct 2008 | 
//|                                                                  |
//+------------------------------------------------------------------+
// Rev. v1.0.1 ** Added +/-/= symbols to show strength of last 2 closed candles
//             ** Added IBFX symbols management
// Rev. v1.0.2 ** Fixed symbols paint issue whenever a new candle starts
//
// Rev. CCp-v2 ** Remove +/-/=, 
//             ** Remove displaing ma.
//             ** Added indicator Id change.
//             ** Added displaing on chart window.
//             ** Added x y to change 
//             ** Added TF choise possibility.
//             ** Added change algoritm like version CCp(Common Complex percent).  
//             ** Added 4 value: current bar, diff current - last close, diff last 2 close bar, 
//                               diff (diff current - last close) - (diff last 2 close bar).
//             ** Added chosing currencies with all algoritm calculation.
//             ** Added ma choise for every TF.
//             -- to do list: fixing delete value when chosing some currencies an when delete indicator.  
//                            adding displaing indicator name, value name and TF.
//                            adding chosing value to display.  

#property copyright "SemSemFX@rambler.ru"
#property link      "http://onix-trade.net/forum/index.php?showtopic=107"
//----
int Objs = 0;
//----
#property indicator_chart_window
#property indicator_buffers 8
extern string i_id = "change Indicator_ID for more in the same window";
extern int Indicator_ID = 1;
extern string TF = "TimeF: 1,15,30,60,240,1440,10080,43200";
extern string TF0 = "if TimeF = 0, it changhe on chart TF";
extern int  TimeF = 0;
extern string  m = "--Moving Average Types--";
extern string  m0 = " 0 = SMA";
extern string  m1 = " 1 = EMA";
extern string  m2 = " 2 = SMMA";
extern string  m3 = " 3 = LWMA";
extern string  m4 = " 4 = LSMA";
extern int     MA_Method = 3;
extern string  p = "--Applied Price Types--";
extern string  p0 = " 0 = close";
extern string  p1 = " 1 = open";
extern string  p2 = " 2 = high";
extern string  p3 = " 3 = low";
extern string  p4 = " 4 = median(high+low)/2";
extern string  p5 = " 5 = typical(high+low+close)/3";
extern string  p6 = " 6 = weighted(high+low+close+close)/4";
extern int     Price = 6;//0=close, 1=open, 2=high, 3=low, 4=median(high+low)/2, 5=typical(high+low+close)/3, 6=weighted(high+low+close+close)/4
extern int Fast = 3;
extern int Slow = 5;
extern bool USD = 1;
extern bool EUR = 1;
extern bool GBP = 1;
extern bool CHF = 1;
extern bool JPY = 1;
extern bool AUD = 1;
extern bool CAD = 1;
extern bool NZD = 1;
extern color Color_USD = Green;
extern color Color_EUR = Aqua;
extern color Color_GBP = Red;
extern color Color_CHF = Sienna;
extern color Color_JPY = Maroon;
extern color Color_AUD = Orange;
extern color Color_CAD = Purple;
extern color Color_NZD = Teal;
extern int Line_Thickness = 3;
extern int All_Bars = 15;
extern int Last_Bars = 0;
extern int Y_Top = 14;
extern int Y_Step = 15;
extern int TxtSize = 8;
extern string x_y1 = "change this 2 change indicator position";
extern int x = 0;
extern int y1 = 15;
// for monthly
extern string ma_Parameter = "chose ma for every TF";
extern int mn_slow = 12;
extern int mn_fast = 3;
// for weekly
extern int w_slow = 9;
extern int w_fast = 3;
// for daily
extern int d_slow = 5;
extern int d_fast = 3;
// for H4
extern int h4_slow = 18;
extern int h4_fast = 6;
// for H1
extern int h1_slow = 24;
extern int h1_fast = 8;
// for M30
extern int m30_slow = 16;
extern int m30_fast = 2;
// for M15
extern int m15_slow = 16;
extern int m15_fast = 4;
// for M5
extern int m5_slow = 12;
extern int m5_fast = 3;
// for M1
extern int m1_slow = 30;
extern int m1_fast = 10;
//----
double arrUSD[];
double arrEUR[];
double arrGBP[];
double arrCHF[];
double arrJPY[];
double arrAUD[];
double arrCAD[];
double arrNZD[];

double   myPoint;
string Indicator_Name;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators

   Indicator_Name = Indicator_ID;

   IndicatorShortName(Indicator_Name);

   cleanup();
   SetIndexBuffer(0, arrUSD);
   SetIndexLabel(0, "USD"); 
 
   SetIndexBuffer(1, arrEUR);
   SetIndexLabel(1, "EUR"); 
  
   SetIndexBuffer(2, arrGBP);
   SetIndexLabel(2, "GBP"); 
 
   SetIndexBuffer(3, arrCHF);
   SetIndexLabel(3, "CHF"); 
 
   SetIndexBuffer(4, arrJPY);
   SetIndexLabel(4, "JPY"); 
   
   SetIndexBuffer(5, arrAUD);
   SetIndexLabel(5, "AUD"); 
   
   SetIndexBuffer(6, arrCAD);
   SetIndexLabel(6, "CAD"); 
  
   SetIndexBuffer(7, arrNZD);
   SetIndexLabel(7, "NZD"); 
//----

   return(0);
  }
  
  
    
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   for(int i = 0; i < Objs; i++)
     {
      if(!ObjectDelete(Indicator_Name + i))
          Print("error: code #", GetLastError());
     }
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   string sAUDUSD,sEURUSD,sUSDCHF,sNZDUSD,sGBPUSD,sUSDJPY,sUSDCAD;
   string AddChar;
   int limit;
   int counted_bars = IndicatorCounted();
//---- checking for possible errors
   if(counted_bars < 0) 
       return(-1);
//---- the last bar will be recounted
   if(All_Bars < 1)
       All_Bars = Bars;
   if(counted_bars > 0 && Last_Bars > 0) 
       counted_bars -= Last_Bars;
   limit = All_Bars;
int Slow, Fast;
    switch(TimeF)
     {
       case 1:     Slow = m1_slow; Fast = m1_fast;  break;
       case 5:     Slow = m5_slow; Fast = m5_fast;  break;
       case 15:    Slow = m15_slow;Fast = m15_fast; break;
       case 30:    Slow = m30_slow;Fast = m30_fast; break;
       case 60:    Slow = h1_slow; Fast = h1_fast;  break;
       case 240:   Slow = h4_slow; Fast = h4_fast;  break;
       case 1440:  Slow = d_slow;  Fast = d_fast;   break;
       case 10080: Slow = w_slow;  Fast = w_fast;   break;
       case 43200: Slow = mn_slow; Fast = mn_fast;  break;
     }   

//---- IBFX Changes 
   if (StringLen(Symbol()) == 7)
   {
     AddChar = StringSubstr(Symbol(), 6, 1);
     sAUDUSD  = "AUDUSD" + AddChar;
     sEURUSD  = "EURUSD" + AddChar;
     sUSDCHF  = "USDCHF" + AddChar;
     sNZDUSD  = "NZDUSD" + AddChar;
     sGBPUSD  = "GBPUSD" + AddChar;
     sUSDJPY  = "USDJPY" + AddChar;
     sUSDCAD  = "USDCAD" + AddChar;
   } 
   else 
   {
     sAUDUSD  = "AUDUSD";
     sEURUSD  = "EURUSD";
     sUSDCHF  = "USDCHF";
     sNZDUSD  = "NZDUSD";
     sGBPUSD  = "GBPUSD";
     sUSDJPY  = "USDJPY";
     sUSDCAD  = "USDCAD";    
   }  
   
//---- main cycle
   for(int i = 0; i < limit; i++)
     {
       // Preliminary calculation
      
         { 
           double EURUSD_Fast = ma(sEURUSD, Fast, MA_Method, Price, i);
           double EURUSD_Slow = ma(sEURUSD, Slow, MA_Method, Price, i);
           if(!EURUSD_Fast || !EURUSD_Slow)
               break;
         }
      
         {
           double GBPUSD_Fast = ma(sGBPUSD, Fast, MA_Method, Price, i);
           double GBPUSD_Slow = ma(sGBPUSD, Slow, MA_Method, Price, i);
           if(!GBPUSD_Fast || !GBPUSD_Slow)
               break;
         }
     
         {
           double AUDUSD_Fast = ma(sAUDUSD, Fast, MA_Method, Price, i);
           double AUDUSD_Slow = ma(sAUDUSD, Slow, MA_Method, Price, i);
           if(!AUDUSD_Fast || !AUDUSD_Slow)
               break;
         }
     
         {
           double NZDUSD_Fast = ma(sNZDUSD, Fast, MA_Method, Price, i);
           double NZDUSD_Slow = ma(sNZDUSD, Slow, MA_Method, Price, i);
           if(!NZDUSD_Fast || !NZDUSD_Slow)
               break;
         }
      
         {
           double USDCAD_Fast = ma(sUSDCAD, Fast, MA_Method, Price, i);
           double USDCAD_Slow = ma(sUSDCAD, Slow, MA_Method, Price, i);
           if(!USDCAD_Fast || !USDCAD_Slow)
               break;
         }
      
         {
           double USDCHF_Fast = ma(sUSDCHF, Fast, MA_Method, Price, i);
           double USDCHF_Slow = ma(sUSDCHF, Slow, MA_Method, Price, i);
           if(!USDCHF_Fast || !USDCHF_Slow)
               break;
         }
      
         {
           double USDJPY_Fast = ma(sUSDJPY, Fast, MA_Method, Price, i);
           double USDJPY_Slow = ma(sUSDJPY, Slow, MA_Method, Price, i);
           if(!USDJPY_Fast || !USDJPY_Slow)
               break;
         }
       // calculation of currencies 
       if(USD)
         {
           arrUSD[i] = 0;
          
               arrUSD[i] += EURUSD_Slow / EURUSD_Fast - 1;
         
               arrUSD[i] += GBPUSD_Slow / GBPUSD_Fast - 1;
         
               arrUSD[i] += AUDUSD_Slow / AUDUSD_Fast - 1;
         
               arrUSD[i] += NZDUSD_Slow / NZDUSD_Fast - 1;
           
               arrUSD[i] += USDCHF_Fast / USDCHF_Slow - 1;
         
               arrUSD[i] += USDCAD_Fast / USDCAD_Slow - 1;
         
               arrUSD[i] += USDJPY_Fast / USDJPY_Slow - 1;
         }
       if(EUR)
         {
           arrEUR[i] = 0;
          
               arrEUR[i] += EURUSD_Fast / EURUSD_Slow - 1;
       
               arrEUR[i] += (EURUSD_Fast / GBPUSD_Fast) / 
                            (EURUSD_Slow/GBPUSD_Slow) - 1;
         
               arrEUR[i] += (EURUSD_Fast / AUDUSD_Fast) / 
                            (EURUSD_Slow/AUDUSD_Slow) - 1;
        
               arrEUR[i] += (EURUSD_Fast / NZDUSD_Fast) / 
                            (EURUSD_Slow/NZDUSD_Slow) - 1;
        
               arrEUR[i] += (EURUSD_Fast*USDCHF_Fast) / 
                            (EURUSD_Slow*USDCHF_Slow) - 1;
       
               arrEUR[i] += (EURUSD_Fast*USDCAD_Fast) / 
                            (EURUSD_Slow*USDCAD_Slow) - 1;
         
               arrEUR[i] += (EURUSD_Fast*USDJPY_Fast) / 
                            (EURUSD_Slow*USDJPY_Slow) - 1;
         }
       if(GBP)
         {
           arrGBP[i] = 0;
         
               arrGBP[i] += GBPUSD_Fast / GBPUSD_Slow - 1;
        
               arrGBP[i] += (EURUSD_Slow / GBPUSD_Slow) / 
                            (EURUSD_Fast / GBPUSD_Fast) - 1;
         
               arrGBP[i] += (GBPUSD_Fast / AUDUSD_Fast) / 
                            (GBPUSD_Slow / AUDUSD_Slow) - 1;
         
               arrGBP[i] += (GBPUSD_Fast / NZDUSD_Fast) / 
                            (GBPUSD_Slow / NZDUSD_Slow) - 1;
        
               arrGBP[i] += (GBPUSD_Fast*USDCHF_Fast) / 
                            (GBPUSD_Slow*USDCHF_Slow) - 1;
        
               arrGBP[i] += (GBPUSD_Fast*USDCAD_Fast) / 
                            (GBPUSD_Slow*USDCAD_Slow) - 1;
        
               arrGBP[i] += (GBPUSD_Fast*USDJPY_Fast) / 
                            (GBPUSD_Slow*USDJPY_Slow) - 1;
          }
       if(AUD)
         {
           arrAUD[i] = 0;
         
               arrAUD[i] += AUDUSD_Fast / AUDUSD_Slow - 1;
        
               arrAUD[i] += (EURUSD_Slow / AUDUSD_Slow) / 
                            (EURUSD_Fast / AUDUSD_Fast) - 1;
         
               arrAUD[i] += (GBPUSD_Slow / AUDUSD_Slow) / 
                            (GBPUSD_Fast / AUDUSD_Fast) - 1;
         
               arrAUD[i] += (AUDUSD_Fast/NZDUSD_Fast) / 
                            (AUDUSD_Slow / NZDUSD_Slow) - 1;
        
               arrAUD[i] += (AUDUSD_Fast*USDCHF_Fast) / 
                            (AUDUSD_Slow*USDCHF_Slow) - 1;
        
               arrAUD[i] += (AUDUSD_Fast*USDCAD_Fast) / 
                            (AUDUSD_Slow*USDCAD_Slow) - 1;
         
               arrAUD[i] += (AUDUSD_Fast*USDJPY_Fast) / 
                            (AUDUSD_Slow*USDJPY_Slow) - 1;
         }
       if(NZD)
         {
           arrNZD[i] = 0;
        
               arrNZD[i] += NZDUSD_Fast / NZDUSD_Slow - 1;
      
               arrNZD[i] += (EURUSD_Slow / NZDUSD_Slow) / 
                            (EURUSD_Fast/NZDUSD_Fast) - 1;
       
               arrNZD[i] += (GBPUSD_Slow / NZDUSD_Slow) / 
                            (GBPUSD_Fast / NZDUSD_Fast) - 1;
       
               arrNZD[i] += (AUDUSD_Slow / NZDUSD_Slow) / 
                            (AUDUSD_Fast / NZDUSD_Fast) - 1;
         
               arrNZD[i] += (NZDUSD_Fast*USDCHF_Fast) / 
                            (NZDUSD_Slow*USDCHF_Slow) - 1;
         
               arrNZD[i] += (NZDUSD_Fast*USDCAD_Fast) / 
                            (NZDUSD_Slow*USDCAD_Slow) - 1;
            
               arrNZD[i] += (NZDUSD_Fast*USDJPY_Fast) / 
                            (NZDUSD_Slow*USDJPY_Slow) - 1;
         }
       if(CAD)
         {
           arrCAD[i] = 0;
          
               arrCAD[i] += USDCAD_Slow / USDCAD_Fast - 1;
      
               arrCAD[i] += (EURUSD_Slow*USDCAD_Slow) / 
                            (EURUSD_Fast*USDCAD_Fast) - 1;
        
               arrCAD[i] += (GBPUSD_Slow*USDCAD_Slow) / 
                            (GBPUSD_Fast*USDCAD_Fast) - 1;
        
               arrCAD[i] += (AUDUSD_Slow*USDCAD_Slow) / 
                            (AUDUSD_Fast*USDCAD_Fast) - 1;
        
               arrCAD[i] += (NZDUSD_Slow*USDCAD_Slow) / 
                            (NZDUSD_Fast*USDCAD_Fast) - 1;
        
               arrCAD[i] += (USDCHF_Fast / USDCAD_Fast) / 
                            (USDCHF_Slow / USDCAD_Slow) - 1;
         
               arrCAD[i] += (USDJPY_Fast / USDCAD_Fast) / 
                            (USDJPY_Slow / USDCAD_Slow) - 1;
         }
       if(CHF)
         {
           arrCHF[i] = 0;
       
               arrCHF[i] += USDCHF_Slow / USDCHF_Fast - 1;
       
               arrCHF[i] += (EURUSD_Slow*USDCHF_Slow) / 
                            (EURUSD_Fast*USDCHF_Fast) - 1;
       
               arrCHF[i] += (GBPUSD_Slow*USDCHF_Slow) / 
                            (GBPUSD_Fast*USDCHF_Fast) - 1;
        
               arrCHF[i] += (AUDUSD_Slow*USDCHF_Slow) / 
                            (AUDUSD_Fast*USDCHF_Fast) - 1;
       
               arrCHF[i] += (NZDUSD_Slow*USDCHF_Slow) / 
                            (NZDUSD_Fast*USDCHF_Fast) - 1;
          
               arrCHF[i] += (USDCHF_Slow / USDCAD_Slow) / 
                            (USDCHF_Fast / USDCAD_Fast) - 1;
        
               arrCHF[i] += (USDJPY_Fast / USDCHF_Fast) / 
                            (USDJPY_Slow / USDCHF_Slow) - 1;
         }
       if(JPY)
         {
           arrJPY[i] = 0;
         
               arrJPY[i] += USDJPY_Slow / USDJPY_Fast - 1;
        
               arrJPY[i] += (EURUSD_Slow*USDJPY_Slow) / 
                            (EURUSD_Fast*USDJPY_Fast) - 1;
        
               arrJPY[i] += (GBPUSD_Slow*USDJPY_Slow) / 
                            (GBPUSD_Fast*USDJPY_Fast) - 1;
        
               arrJPY[i] += (AUDUSD_Slow*USDJPY_Slow) / 
                            (AUDUSD_Fast*USDJPY_Fast) - 1;
       
               arrJPY[i] += (NZDUSD_Slow*USDJPY_Slow) / 
                            (NZDUSD_Fast*USDJPY_Fast) - 1;
        
               arrJPY[i] += (USDJPY_Slow/USDCAD_Slow) / 
                            (USDJPY_Fast/USDCAD_Fast) - 1;
        
               arrJPY[i] += (USDJPY_Slow/USDCHF_Slow) / 
                            (USDJPY_Fast/USDCHF_Fast) - 1;
         }// end if JPY
     }//end block for(int i=0; i<limit; i++)
   int cur = Y_Top; 
   int st = Y_Step;      
  if (USD)
   {     
         sl("USD",arrUSD[0], arrUSD[0]-arrUSD[1], arrUSD[1]-arrUSD[2],(arrUSD[0]-arrUSD[1])-(arrUSD[1]-arrUSD[2]),"SymbUSD", cur, Color_USD);
             
       cur += st;
      
     }
  if(EUR)
     {
         sl("EUR",arrEUR[0], arrEUR[0]-arrEUR[1],arrEUR[1]-arrEUR[2],(arrEUR[0]-arrEUR[1])-(arrEUR[1]-arrEUR[2]),"SymbEUR", cur, Color_EUR);
            
       cur += st;      
       
     }
   if(GBP)
     {
         sl("GBP",arrGBP[0], arrGBP[0]-arrGBP[1], arrGBP[1]-arrGBP[2], (arrGBP[0]-arrGBP[1])-(arrGBP[1]-arrGBP[2]),"SymbGBP", cur, Color_GBP);
       
       cur += st;
     }
  if(CHF)
     {
         sl("CHF",arrCHF[0], arrCHF[0]-arrCHF[1], arrCHF[1]-arrCHF[2],(arrCHF[0]-arrCHF[1])-(arrCHF[1]-arrCHF[2]),"SymbCHF", cur, Color_CHF);
        
       cur += st;
     }
  if(AUD)
     {
          sl("AUD",arrAUD[0],arrAUD[0]-arrAUD[1], arrAUD[1]-arrAUD[2],(arrAUD[0]-arrAUD[1])-(arrAUD[1]-arrAUD[2]),"SymbAUD", cur, Color_AUD);
        
       cur += st;
     }
  if(CAD)
     {
          sl("CAD",arrCAD[0], arrCAD[0]-arrCAD[1], arrCAD[1]-arrCAD[2],(arrCAD[0]-arrCAD[1])-(arrCAD[1]-arrCAD[2]),"SymbCAD", cur, Color_CAD);
        
       cur += st;
     }
  if(JPY)
     {
          sl("JPY",arrJPY[0], arrJPY[0]-arrJPY[1], arrJPY[1]-arrJPY[2],(arrJPY[0]-arrJPY[1])-(arrJPY[1]-arrJPY[2]),"SymbJPY", cur, Color_JPY);
          
       cur += st;
     }
   if(NZD)
     {
          sl("NZD",arrNZD[0], arrNZD[0]-arrNZD[1], arrNZD[1]-arrNZD[2],(arrNZD[0]-arrNZD[1])-(arrNZD[1]-arrNZD[2]),"SymbNZD", cur, Color_NZD);
              
       cur += st;
    
     } 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|  Subroutines                                                     |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| LSMA with PriceMode                                              |
//| PrMode  0=close, 1=open, 2=high, 3=low, 4=median(high+low)/2,    |
//| 5=typical(high+low+close)/3, 6=weighted(high+low+close+close)/4  |
//+------------------------------------------------------------------+

double LSMA(string symb, int TimeFrame, int Rperiod, int prMode, int shift)
{
   int i, myShift;
   double sum, pr;
   int length;
   double lengthvar;
   double tmp;
   double wt;

   length = Rperiod;
   myPoint = SetPoint(symb);
 
   sum = 0;
   for(i = length; i >= 1  ; i--)
   {
     lengthvar = length + 1;
     lengthvar /= 3;
     tmp = 0;
     myShift = length - i + shift;
     switch (prMode)
     {
     case 0: pr = iClose(symb,TimeFrame,myShift);break;
     case 1: pr = iOpen(symb,TimeFrame,myShift);break;
     case 2: pr = iHigh(symb,TimeFrame,myShift);break;
     case 3: pr = iLow(symb,TimeFrame,myShift);break;
     case 4: pr = (iHigh(symb,TimeFrame,myShift) + iLow(symb,TimeFrame,myShift))/2;break;
     case 5: pr = (iHigh(symb,TimeFrame,myShift) + iLow(symb,TimeFrame,myShift) + iClose(symb,TimeFrame,myShift))/3;break;
     case 6: pr = (iHigh(symb,TimeFrame,myShift) + iLow(symb,TimeFrame,myShift) + iClose(symb,TimeFrame,myShift) + iClose(symb,TimeFrame,myShift))/4;break;
     }
     tmp = ( i - lengthvar)*pr;
     sum+=tmp;
    }
    wt = sum*6/(length*(length+1));
    wt = MathFloor(wt/myPoint)*myPoint;
    
    return(wt);
}

double ma(string sym, int per, int Mode, int Price, int i)
  {
   double res = 0;
   int k = 1;
   int ma_shift = 0;
   int tf = 0;
   if (TimeF ==0 ) TimeF=Period();
   if (Mode == 4)
   {
   switch(TimeF)
     {
       case 1:     res += LSMA(sym, TimeF, per*k, Price,i); 
                   k += 5;
                   break;
       case 5:     res += LSMA(sym, TimeF, per*k, Price,i); 
                   k += 3;
                   break;
       case 15:    res += LSMA(sym, TimeF, per*k, Price,i); 
                   k += 2;
                   break;
       case 30:    res += LSMA(sym, TimeF, per*k, Price,i); 
                   k += 2;
                   break;
       case 60:    res += LSMA(sym, TimeF, per*k, Price,i); 
                   k += 4;
                   break;
       case 240:   res += LSMA(sym, TimeF, per*k, Price,i); 
                   k += 6;
                   break;
       case 1440:  res += LSMA(sym, TimeF, per*k, Price,i); 
                   k += 4;
                   break;
       case 10080: res += LSMA(sym, TimeF, per*k, Price,i); 
                   k +=4;
                   break; 
       case 43200: res += LSMA(sym, TimeF, per*k, Price,i); 
                   break;
     } 
   }
   else
   {
       
   switch(TimeF)
     {
       case 1:     res += iMA(sym, TimeF, per*k, ma_shift, Mode, Price, i); 
                   k += 5;
                   break; 
       case 5:     res += iMA(sym, TimeF, per*k, ma_shift, Mode, Price, i); 
                   k += 3;
                   break; 
       case 15:    res += iMA(sym, TimeF, per*k, ma_shift, Mode, Price, i); 
                   k += 2;
                   break; 
       case 30:    res += iMA(sym, TimeF, per*k, ma_shift, Mode, Price, i); 
                   k += 2;
                   break; 
       case 60:    res += iMA(sym, TimeF, per*k, ma_shift, Mode, Price, i); 
                   k += 4;
                   break; 
       case 240:   res += iMA(sym, TimeF, per*k, ma_shift, Mode, Price, i); 
                   k += 6;
                   break; 
       case 1440:  res += iMA(sym, TimeF, per*k, ma_shift, Mode, Price, i); 
                   k += 4;
                   break; 
       case 10080: res += iMA(sym, TimeF, per*k, ma_shift, Mode, Price, i); 
                   k +=4;
                   break; 
       case 43200: res += iMA(sym, TimeF, per*k, ma_shift, Mode, Price, i); 
                   break; 
     } 
   }
   return(res);
  }   
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void sl(string currency, double diff,double diff1, double diff2,double diff3, string IndicatoreName, int y, color col)
  {
   int window = WindowFind(Indicator_Name);
   string ID = Indicator_Name+Objs;
   string mIndicatoreName, disp;
   mIndicatoreName =  Indicator_ID + IndicatoreName;
   int tmp = 10 + y;
   Objs++;
   disp = currency + "    " + DoubleToStr(diff*10000.0, 2)+ "      " + DoubleToStr(diff1*10000.0, 2)+ "      " + DoubleToStr(diff2*10000.0, 2)+ "      " + DoubleToStr(diff3*10000.0, 2);
   if (ObjectFind(mIndicatoreName)==-1)
   {
    if(ObjectCreate(mIndicatoreName, OBJ_LABEL, 0, 0 ,0))
     {
      
       ObjectSet(mIndicatoreName, OBJPROP_XDISTANCE, x+10);
       ObjectSet(mIndicatoreName, OBJPROP_YDISTANCE, y1+y);
       ObjectSetText(mIndicatoreName, disp, TxtSize, "Arial Black", col);
     }   
   }
   else
   {
     ObjectSet(mIndicatoreName, OBJPROP_XDISTANCE, x+10);
     ObjectSet(mIndicatoreName, OBJPROP_YDISTANCE, y1+y);
     ObjectSetText(mIndicatoreName, disp, TxtSize, "Arial Black", col);        
   }
      
  }   


double SetPoint(string mySymbol)
{
   double mPoint, myDigits;
   
   myDigits = MarketInfo (mySymbol, MODE_DIGITS);
   if (myDigits < 4)
      mPoint = 0.01;
   else
      mPoint = 0.0001;
   
   return(mPoint);
}

void cleanup() {
   string l_name_0;
   int l_objs_total_8 = ObjectsTotal();
   for (int li_12 = l_objs_total_8 - 1; li_12 >= 0; li_12--) {
      l_name_0 = ObjectName(li_12);
      if (StringFind(l_name_0,Indicator_Name+Objs ) == 0) ObjectDelete(l_name_0);
      
   }
}
//+------------------------------------------------------------------+