/*------------------------------------------------------------------------------------
   Name: 4inOne Indicators
   Derived from: Genesis Matrix 2.22
Origenal:Note:
	            Requires that the following indicators are installed and working:
	            TVI_mq4, GannHiLo-Histo.mq4, T3MA-Basic.mq4 	   

Note:
	   Requires that the following indicators are installed and working:
	   MACD_histoBar_mq4, Bear_Bulls_Power.mq4, fisher_yur4ik_2bars.mq4 
	   
	     2014-02-10. Xaphod, v1.600
	     .
	     .
	     .
        2016-12-20. modified by 
           - First Release 
-------------------------------------------------------------------------------------*/
//#property copyright "Copyright 2012, Xaphod"
//#property link      "http://www.xaphod.com"
// Indicator properties
//#property copyright "Copyright 2016,"
#property link      " "

#property indicator_separate_window
#property indicator_buffers 8
#property indicator_color1 Red                 //C'0,90,255'
#property indicator_color2 Lime                //Red
#property indicator_color3 Red                 //C'0,90,255'
#property indicator_color4 Lime                //Red
#property indicator_color5 Red                 //C'0,90,255'
#property indicator_color6 Lime                //Red
#property indicator_color7 Red                 //C'0,90,255'
#property indicator_color8 Lime                //Red
#property indicator_minimum 0
#property indicator_maximum 2.3

// Constant definitions
#define INDICATOR_NAME "4in1"                    //#define INDICATOR_NAME "Genesis"
#define INDICATOR_VERSION "1.00"                   //#define INDICATOR_VERSION "2.22"
#define BAR_CHAR 110                               //#define BAR_CHAR 110
#define IND_MACD       "MACD_histoBar"             //#define IND_TVI        "TVI"
#define IND_BB         "Bear_Bulls_Power"  //#define IND_GANNHILO   "GannHiLo-Histo"
#define IND_EFT        "fisher_yur4ik_2bars"
#define IND_CCI        "CCI"                       //#define IND_T3_8       "T3_2ColorHisto"

#define IDX_MACD       0                            //#define IDX_TVI       0
#define IDX_BB         1                            //#define IDX_CCI       1
#define IDX_EFT        2                            //#define IDX_T3_8      2
#define IDX_CCI        3

// Indicator parameters
// Timeframe: 0,1,5,15,30,60,240,1440 etc. Current Timeframe=0. 
// Automatically select higher TF. M15 and M30 -> H1. Off=0, 1st HTF=1, 2nd HTF=2
extern string    TimeFrame_Settings="0,1,5,15,30,60,240,1440 etc. Current Timeframe=0.";
extern int       TimeFrame_Period=0;        
extern int       TimeFrame_Auto=0;
/////////////////MACD/////////////////////////////////////          
extern string    MACD_Settings="MACD設定";            //extern string    TVI_Settings="???????????????";
extern int    FastEma            = 12;                       //extern int       TVI_r=12;
extern int    SlowEma            = 26;                       //extern int       TVI_s=12;
extern int    SignalSMMA         = 9;                        //extern int       TVI_u=5;
extern int    PriceField         = 0;
extern string  MACD_Label="MACD";                            //extern string    TVI_Label="TVI";
//
//////////// Bull_Bear power settings/////////
extern string    Bullish_Bearish_Settings="多空動能設定";    //extern string    T3_Settings="???????????????";
extern int       BB_Period=1;                                //extern int       T3_Period=8;
//extern int     T3_BarCount=1500;                           //extern int       T3_BarCount=1500;
extern string    BB_Label="BBP";                            //extern string    T3_Label="T3..";
//
//
////////////// Ehlers Fisher transform histo mtf alerts lines 2 /////////////////
enum enPrices
{
   pr_close,      // Close
   pr_open,       // Open
   pr_high,       // High
   pr_low,        // Low
   pr_median,     // Median
   pr_typical,    // Typical
   pr_weighted,   // Weighted
   pr_average,    // Average (high+low+open+close)/4
   pr_medianb,    // Average median body (open+close)/2
   pr_tbiased,    // Trend biased price
   pr_haclose,    // Heiken ashi close
   pr_haopen ,    // Heiken ashi open
   pr_hahigh,     // Heiken ashi high
   pr_halow,      // Heiken ashi low
   pr_hamedian,   // Heiken ashi median
   pr_hatypical,  // Heiken ashi typical
   pr_haweighted, // Heiken ashi weighted
   pr_haaverage,  // Heiken ashi average
   pr_hamedianb,  // Heiken ashi median body
   pr_hatbiased   // Heiken ashi trend biased price
};
 
extern string    Fisher_Settings="FISHER參數設定";   //extern string    GannHiLo_Settings="???????????????";
extern int       Fisher_Period=30;                   //extern int       GannHiLo_Period=10;
extern enPrices  PriceType    = pr_median;           // Price to use
extern string    EFT_Label ="FISH";                   //extern string    GannHiLo_Label="GHL";
//
///////////// CCI //////////////////////
extern string    CCI_Settings="CCI參數設定";
extern int       CCI_Period=20;
extern double    CCI_Threshold=60;
extern string    CCI_Label="CCI";
//
extern string    Alert_Settings="???????????????";
extern bool      Alert_OnBarClose=True;     // Alert only when an open bar closes
extern bool      Alert_Popup=False;         // Enable popup window & sound on alert
extern bool      Alert_Email=False;         // Enable send email on alert
extern string    Alert_Subject="";          // Email Subject. Null string ("") will result in a preconfigured subject.
extern string    Display_Settings="???????????????";
extern color     Display_LabelColor=White;  // Color of Histogram Id labels

// Global module varables
// Histogram
double gadMACDUp[];                 //double gadTVIUp[];
double gadMACDDn[];                 //double gadTVIDn[];
double gadBBUp[];                   //double gadT3Up[];
double gadBBDn[];                   //double gadT3Dn[];
double gadEFTUp[];                   //double gadGHLUp[];
double gadEFTDn[];                   //double gadGHLDn[];
double gadCCIUp[];                  //double gadCCIUp[];
double gadCCIDn[];                  //double gadCCIDn[];

// Labels
double gadGap[4];

// Globals
int giRepaintBars;
string gsIndicatorName;
bool gbInit;

//-----------------------------------------------------------------------------
// function: init()
// Description: Custom indicator initialization function.
//-----------------------------------------------------------------------------
int init() {
  // Init indicator buffers
  IndicatorBuffers(8);
  SetIndexStyle(0,DRAW_ARROW);
  SetIndexBuffer(0,gadMACDUp);      //SetIndexBuffer(0,gadTVIUp);
  SetIndexStyle(1,DRAW_ARROW);
  SetIndexBuffer(1,gadMACDDn);      //SetIndexBuffer(1,gadTVIDn); 
  SetIndexStyle(2,DRAW_ARROW);
  SetIndexBuffer(2,gadBBUp);        //SetIndexBuffer(4,gadT3Up);
  SetIndexStyle(3,DRAW_ARROW);
  SetIndexBuffer(3,gadBBDn);        //SetIndexBuffer(5,gadT3Dn);
  SetIndexStyle(4,DRAW_ARROW);
  SetIndexBuffer(4,gadEFTUp);        //SetIndexBuffer(6,gadGHLUp);
  SetIndexStyle(5,DRAW_ARROW);
  SetIndexBuffer(5,gadEFTDn);        //SetIndexBuffer(7,gadGHLDn);
  SetIndexStyle(6,DRAW_ARROW);
  SetIndexBuffer(6,gadCCIUp);
  SetIndexStyle(7,DRAW_ARROW);
  SetIndexBuffer(7,gadCCIDn);   
  
  for (int i = 0; i < 8; i++) {
    SetIndexLabel(i,NULL);
    SetIndexEmptyValue(i,0.0);
    SetIndexArrow(i,BAR_CHAR);
  }
  
  // Set Timeframe
  switch(TimeFrame_Auto) {
    case 1: 
      TimeFrame_Period=NextHigherTF(TimeFrame_Period); 
      giRepaintBars=TimeFrame_Period/Period()+2;
    break;
    case 2: 
      TimeFrame_Period=NextHigherTF(NextHigherTF(TimeFrame_Period));
      giRepaintBars=TimeFrame_Period/Period()+2;
    break;
    default: 
      if (TimeFrame_Period<1 || TimeFrame_Period==Period()) {
        TimeFrame_Period=Period();
        giRepaintBars=0;
      }
      else {
        giRepaintBars=TimeFrame_Period/Period()+2;
      }
    break;
  }
  
  // Set histogram positions
  gadGap[IDX_MACD]=1.9;             //gadGap[IDX_TVI]=1.9;
  gadGap[IDX_BB]=1.4;               //gadGap[IDX_CCI]=1.4;
  gadGap[IDX_EFT]=0.9;               //gadGap[IDX_T3_8]=0.9;
  gadGap[IDX_CCI]=0.4;              //gadGap[IDX_GHL]=0.4;
  
  // Misc
  gsIndicatorName=INDICATOR_NAME+" "+INDICATOR_VERSION+"("+TF2Str(TimeFrame_Period)+")";
  IndicatorShortName(gsIndicatorName);
  gbInit=True;
  return(0);
}


//-----------------------------------------------------------------------------
// function: deinit()
// Description: Custom indicator deinitialization function.
//-----------------------------------------------------------------------------
int deinit() {
  // Clear text objects
  for(int i=ObjectsTotal()-1; i>-1; i--)
    if (StringFind(ObjectName(i),gsIndicatorName)>=0)  ObjectDelete(ObjectName(i));
  return (0);
}


//-----------------------------------------------------------------------------
// function: start()
// Description: Custom indicator iteration function.
//-----------------------------------------------------------------------------
int start() {
  int iNewBars;
  int iCountedBars; 
  static datetime tCurBar;
  
  // Get unprocessed bars
  iCountedBars=IndicatorCounted();
  if(iCountedBars < 0) return (-1); 
  if(iCountedBars>0) iCountedBars--;
  
  // Set bars to redraw
  if (NewBars(TimeFrame_Period)>3)
    iNewBars=Bars-1;
    //iNewBars=MaxBars-1;
  else
    iNewBars=Bars-iCountedBars;
    //iNewBars=MaxBars-iCountedBars;
  if (iNewBars<giRepaintBars)
    iNewBars=giRepaintBars;

  // Calc indicator data and update
  ProcessMACD(iNewBars, gadMACDUp, gadMACDDn);          //ProcessTVI(iNewBars, TVI_r, TVI_s, TVI_u, gadTVIUp, gadTVIDn);
  ProcessBB(iNewBars, BB_Period, gadBBUp, gadBBDn);     //ProcessT3_8(iNewBars,T3_Period, gadT3Up, gadT3Dn);
  ProcessEFT(iNewBars, gadEFTUp, gadEFTDn);             //ProcessGannHiLo(iNewBars,GannHiLo_Period, gadGHLUp, gadGHLDn);
  ProcessCCI(iNewBars,CCI_Period, CCI_Threshold, gadCCIUp, gadCCIDn);        //ProcessCCI(iNewBars,CCI_Period, CCI_Threshold, gadCCIUp, gadCCIDn);
  
  // Alerts
  CheckAlert();
    
  // Tasks to execute on bar close
  if (tCurBar<Time[0]) {
    tCurBar=Time[0];
    
    // Write/Update bar labels
    Writelabel(MACD_Label,gadGap[IDX_MACD]+0.2);          //Writelabel(TVI_Label,gadGap[IDX_TVI]+0.2);
    Writelabel(BB_Label,gadGap[IDX_BB]+0.2);              //Writelabel(T3_Label,gadGap[IDX_T3_8]+0.2);
    Writelabel(EFT_Label,gadGap[IDX_EFT]+0.2);              //Writelabel(GannHiLo_Label,gadGap[IDX_GHL]+0.2);
    Writelabel(CCI_Label,gadGap[IDX_CCI]+0.2);            //Writelabel(CCI_Label,gadGap[IDX_CCI]+0.2);
    
    // Clear the init flag   
    if (gbInit) 
      gbInit=False;
  }
  
  return(0);
}


//-----------------------------------------------------------------------------
// function: NewBars()
// Description: Return nr of new bars on a TF
//-----------------------------------------------------------------------------
int NewBars(int iPeriod) {
  static int iPrevSize=0;
  int iNewSize;
  int iNewBars;
  datetime tTimeArray[];
  
  ArrayCopySeries(tTimeArray,MODE_TIME,Symbol(),iPeriod);
  iNewSize=ArraySize(tTimeArray);
  iNewBars=iNewSize-iPrevSize;
  iPrevSize=iNewSize;
  return(iNewBars);
}


//-----------------------------------------------------------------------------
// function: ProcessMACD()
// Description: Calc MACD data 
//-----------------------------------------------------------------------------
int ProcessMACD(int iNewBars, double& vdUp[], double& vdDn[]) {
//int ProcessTVI(int iNewBars, int r, int s, int u, double& vdUp[], double& vdDn[]) {
  int i,j,iUp=0;
  double dMACD0=0, dMACD1=0;               //double dTVI0=0, dTVI1=0;
//  double dSig=0;   
  int iHTFBar=-1;
  
  for (i=iNewBars;i>=0;i--) {
    if (i>MathMax(Bars-2,Bars-FastEma))           //if (i>MathMax(Bars-2,Bars-r))  
      continue;
    // Get index for higher timeframe bar
    if (TimeFrame_Period>Period())
      j=iBarShift(Symbol(), TimeFrame_Period, Time[i]);
    else
      j=i;
//     Calc MACD // Calc TVI  
    if (iHTFBar!=j) {
      iHTFBar=j;
dMACD0=iCustom(NULL,Symbol(), TimeFrame_Period,IND_MACD,FastEma,SlowEma, PriceField,0,j) - iCustom(NULL,0,SlowEma,0,PriceField,j);
 //     ind_buffer1[i]=iMA(NULL,0,FastEMA,0,MODE_EMA,PRICE_CLOSE,i)-iMA(NULL,0,SlowEMA,0,MODE_EMA,PRICE_CLOSE,i);
//       iUp=iCustom(Symbol(),TimeFrame_Period,IND_MACD,FastEma, SlowEma, SignalSMMA, PriceField,0,j+1);      
        //dTVI1=iCustom(Symbol(),TimeFrame_Period,IND_TVI,r,s,u,0,j+1);
dMACD1=iCustom(NULL,Symbol(), TimeFrame_Period,IND_MACD,SlowEma,SignalSMMA,PriceField,j);
//      ind_buffer2[i]=iMAOnArray(ind_buffer1,Bars,SignalSMA,0,MODE_SMA,i);
//      dSig =iCustom(Symbol(),TimeFrame_Period,IND_MACD,FastEma, SlowEma, SignalSMMA,PriceField,0,j);      
              //dTVI0=iCustom(Symbol(),TimeFrame_Period,IND_TVI,r,s,u,0,j);
    }

    // No data
    if (dMACD0==EMPTY_VALUE) {          //if (dTVI0==EMPTY_VALUE) {
      vdUp[i]=0;                        //vdUp[i]=0;
      vdDn[i]=0;
    }
    // Bull signal
    if (dMACD0>=dMACD1) {                  //if (dTVI0>=dTVI1) {
      vdUp[i]=gadGap[IDX_MACD];          //vdUp[i]=gadGap[IDX_TVI];
      vdDn[i]=0;
    }
    // Bear signal
    else {
      vdDn[i]=gadGap[IDX_MACD];          //vdDn[i]=gadGap[IDX_TVI];
      vdUp[i]=0;
    }    
  }
  return(0);
}



//-----------------------------------------------------------------------------
// function: ProcessBB()
// Description: Calc BB data 
//-----------------------------------------------------------------------------
int ProcessBB(int iNewBars, int BB_period, double& vdUp[], double& vdDn[]) {      //int ProcessT3_8(int iNewBars, int iPeriod, double& vdUp[], double& vdDn[]) {
  int i,j,iUp=0;
//  double dSig=0;
  int iHTFBar=-1;
    
  // Draw tape chart
  for(i=iNewBars+TimeFrame_Period/Period(); i>=0; i--) {
    if (i>MathMax(Bars-2,Bars-BB_Period))                           //if (i>MathMax(Bars-2,Bars-iPeriod))
      continue;
    // Shift index for higher time-frame
    if (TimeFrame_Period>Period())
      j=iBarShift(Symbol(), TimeFrame_Period, Time[i]);
    else
      j=i;
      //Calc BB data     // Calc T3_8 data
    if (iHTFBar!=j) {
      iHTFBar=j;
      iUp = (int)iCustom(NULL,TimeFrame_Period,IND_BB,BB_Period,1,j);      //iUp = (int)iCustom(NULL,TimeFrame_Period,IND_T3_8,T3_Period,PRICE_CLOSE, T3_BarCount, 1,j);
      //iUp = iCustom(NULL,TimeFrame_Period,IND_T3_8,T3_Period,1,j);
    }
    // Bear signal
    if (iUp==1) {
      vdDn[i]=gadGap[IDX_BB];      //vdDn[i]=gadGap[IDX_T3_8];
      vdUp[i]=0;
    }
    // Bull signal
    else {
      vdUp[i]=gadGap[IDX_BB];      //vdUp[i]=gadGap[IDX_T3_8];
      vdDn[i]=0;
    }
  }
  return(0);
}  

//-----------------------------------------------------------------------------
// function: ProcessFISHER()
// Description: Calc FISHER data
//-----------------------------------------------------------------------------
int ProcessEFT(int iNewBars,double& vdUp[], double& vdDn[]) {      //int ProcessFY(int iNewBars, int Fisher_Period, double& vdUp[], double& vdDn[]) {
  int i,j,iUp=0;
  int iHTFBar=-1;
    
  // Draw tape chart
  for(i=iNewBars+TimeFrame_Period/Period(); i>=0; i--) {
    if (i>MathMax(Bars-3,Bars-Fisher_Period))           //if (i>MathMax(Bars-3,Bars-iPeriod))
      continue;
    // Shift index for higher time-frame
    if (TimeFrame_Period>Period())
      j=iBarShift(Symbol(), TimeFrame_Period, Time[i]);
    else
      j=i;
    // Calc GannHiLo data
    if (iHTFBar!=j) {
      iHTFBar=j;
      iUp = (int)iCustom(NULL,TimeFrame_Period,IND_EFT,Fisher_Period,PriceType,0,j);
    }
    // No Data
    if (iUp==EMPTY_VALUE) {
      vdUp[i]=0;
      vdDn[i]=0;
    }
    // Bull signal
    else if (iUp==1) {
      vdUp[i]=gadGap[IDX_EFT];
      vdDn[i]=0;
    }
    // Bear signal
    else {
      vdDn[i]=gadGap[IDX_EFT];
      vdUp[i]=0;
    }
  }
  return(0);
}  


//-----------------------------------------------------------------------------
// function: ProcessCCI()
// Description: Calc CCI data and update matrix
//-----------------------------------------------------------------------------
int ProcessCCI(int iNewBars, int iPeriod, double iThreshold, double& vdUp[], double& vdDn[]) {
  int i,j;
  double dSig=0;
  int iHTFBar=-1;
  
  for(i=iNewBars; i>=0; i--) {
    if (i>MathMax(Bars-2,Bars-iPeriod))
      continue;
    // Shift index for higher time-frame
    if (TimeFrame_Period>Period() )
      j=iBarShift(Symbol(), TimeFrame_Period, Time[i]);
    else
      j=i;
    // Calc CCI
    if (iHTFBar!=j) {
      iHTFBar=j;
      dSig=iCCI(NULL, TimeFrame_Period, iPeriod, PRICE_TYPICAL, j);
    }
    // No Data
    if (iClose(NULL,TimeFrame_Period,j)==0) {
      vdUp[i]=EMPTY_VALUE;
      vdDn[i]=EMPTY_VALUE;
    }
    // Bull signal
    //else if (dSig>0 && dSig > iThreshold ) {
    else if (dSig>0 ) {
      vdUp[i]=gadGap[IDX_CCI];
      vdDn[i] = 0;
    }
    // Bwar signal
    //else if (dSig < 0  && dSig < -iThreshold ){
    else if (dSig < 0 ){
      vdDn[i]=gadGap[IDX_CCI];
      vdUp[i] = 0;
    } 
  }
  return(0);
}


//-----------------------------------------------------------------------------
// function: CheckAlert()
// Description: Check for new alerts
//-----------------------------------------------------------------------------
void CheckAlert() {
  static datetime tAlertBar;
  static int iPrevAlert=0;
  
  if (Alert_Popup || Alert_Email) {
    
    // Alert on the close of the current bar
    if (Alert_OnBarClose && tAlertBar<Time[iBarShift(Symbol(), TimeFrame_Period, Time[0])] && !gbInit) {
      
      tAlertBar=Time[iBarShift(Symbol(), TimeFrame_Period, Time[0])];
      // Clear alert flag
      if (iPrevAlert==1 && !UpSignal(1))
         iPrevAlert=0;
      else if (iPrevAlert==-1 && !DnSignal(1))
         iPrevAlert=0;
      // Alert and set alert flag
      if (UpSignal(1) && iPrevAlert!=1) {
         AlertNow(Symbol()+", "+TF2Str(Period())+": Genesis Matrix  Buy Signal.");
         iPrevAlert=1;
      }  
      else if (DnSignal(1) && iPrevAlert!=-1) {
         AlertNow(Symbol()+", "+TF2Str(Period())+": Genesis Matrix  Sell Signal.");
         iPrevAlert=-1;
      }
    }
  
    // Alert while the current bar is open
    if (!Alert_OnBarClose && tAlertBar<Time[iBarShift(Symbol(), TimeFrame_Period, Time[0])] && !gbInit) {
      // Clear alert flag
      if (iPrevAlert==1 && !UpSignal(0))
         iPrevAlert=0;
      else if (iPrevAlert==-1 && !DnSignal(0))
         iPrevAlert=0;      
      // Alert and set alert flag
      if (UpSignal(0) && iPrevAlert!=1) {
         AlertNow(Symbol()+", "+TF2Str(Period())+": Genesis Matrix  Buy Signal.");
         iPrevAlert=1;
         tAlertBar=Time[iBarShift(Symbol(), TimeFrame_Period, Time[0])];
      }  
      else if (DnSignal(0) && iPrevAlert!=-1) {
         AlertNow(Symbol()+", "+TF2Str(Period())+": Genesis Matrix Sell Signal.");
         iPrevAlert=-1;
         tAlertBar=Time[iBarShift(Symbol(), TimeFrame_Period, Time[0])];
      }
    }
  }
}


//-----------------------------------------------------------------------------
// function: AlertNow()
// Description: Signal the popup and email alerts
//-----------------------------------------------------------------------------
void AlertNow(string sAlertMsg) {
  //Popup Alert 
  if (Alert_Popup) 
    Alert(INDICATOR_NAME, ", ", sAlertMsg);      
  //Email Alert
  if (Alert_Email) {
    if (Alert_Subject=="")
      SendMail( sAlertMsg, "MT4 Alert!\n"+INDICATOR_NAME+"\n" + TimeToStr(Time[0],TIME_DATE|TIME_SECONDS )+"\n"+sAlertMsg);
    else 
      SendMail( Alert_Subject, "MT4 Alert!\n"+INDICATOR_NAME+"\n" + TimeToStr(Time[0],TIME_DATE|TIME_SECONDS )+"\n"+sAlertMsg);          
  }
}


//-----------------------------------------------------------------------------
// function: UpSignal()
// Description: Return true if there is an up signal
//-----------------------------------------------------------------------------
bool UpSignal(int i) {
  if (gadMACDUp[i]>0 && gadBBUp[i]>0 && gadEFTUp[i]>0 && gadCCIUp[i]>0)      //if (gadTVIDn[i]>0 && gadCCIDn[i]>0 && gadGHLDn[i]>0 && gadT3Dn[i]>0)
    return(True);
  else
    return(False);
}


//-----------------------------------------------------------------------------
// function: DnSignal()
// Description: eturn true if there is a down signal
//-----------------------------------------------------------------------------
bool DnSignal(int i) {
if (gadMACDUp[i]>0 && gadBBUp[i]>0 && gadEFTUp[i]>0 && gadCCIUp[i]>0)      //if (gadTVIDn[i]>0 && gadCCIDn[i]>0 && gadGHLDn[i]>0 && gadT3Dn[i]>0)
    return(True);
  else
    return(False);
}


//-----------------------------------------------------------------------------
// function: Writelabel()
// Description: Write a label for a bar
//-----------------------------------------------------------------------------
int Writelabel(string sLabel,double dPrice) {
  string sObjId;
  sObjId=gsIndicatorName+"_"+sLabel;
  if(ObjectFind(sObjId) < 0)
    ObjectCreate(sObjId, OBJ_TEXT, WindowFind(gsIndicatorName), Time[0]+Period()*60*2, dPrice);
  ObjectSetText(sObjId, sLabel, 8, "Calibri", Display_LabelColor); //Lucida Console
  ObjectMove(sObjId,0,Time[0]+Period()*60*2, dPrice);
  return(0);
}


//-----------------------------------------------------------------------------
// function: TF2Str()
// Description: Convert time-frame to a string
//-----------------------------------------------------------------------------
string TF2Str(int iPeriod) {
  switch(iPeriod) {
    case PERIOD_M1: return("M1");
    case PERIOD_M5: return("M5");
    case PERIOD_M15: return("M15");
    case PERIOD_M30: return("M30");
    case PERIOD_H1: return("H1");
    case PERIOD_H4: return("H4");
    case PERIOD_D1: return("D1");
    case PERIOD_W1: return("W1");
    case PERIOD_MN1: return("MN1");
    default: return("M"+(string)iPeriod);
  }
  return("M?");
}


//-----------------------------------------------------------------------------
// function: NextHigherTF()
// Description: Select the next higher time-frame. 
//              Note: M15 and M30 both select H1 as next higher TF. 
//-----------------------------------------------------------------------------
int NextHigherTF(int iPeriod) {
  if (iPeriod==0) iPeriod=Period();
  switch(iPeriod) {
    case PERIOD_M1: return(PERIOD_M5);
    case PERIOD_M5: return(PERIOD_M15);
    case PERIOD_M15: return(PERIOD_H1);
    case PERIOD_M30: return(PERIOD_H1);
    case PERIOD_H1: return(PERIOD_H4);
    case PERIOD_H4: return(PERIOD_D1);
    case PERIOD_D1: return(PERIOD_W1);
    case PERIOD_W1: return(PERIOD_MN1);
    case PERIOD_MN1: return(PERIOD_MN1);
    default: return(Period());
  }
  return(Period());
}