Code: Select all

#define GAPBETWEENENTRYALERTS 3600
datetime  aPairEntryAlertGiven[MAXPAIRS] = {0};

//-----------------------------------
// getSecondsSinceEntryAlert
//-----------------------------------
int getSecondsSinceEntryAlert(int iPairIndex)
{
	datetime dtNow = TimeCurrent();

	return(dtNow - aPairEntryAlertGiven[iPairIndex]);
}
//-----------------------------------
// setEntryAlertTimeNow
//-----------------------------------
void setEntryAlertTimeNow(int iPairIndex)
{
	aPairEntryAlertGiven[iPairIndex] = TimeCurrent();
}
//-----------------------------------
// clearEntryAlertTimeNow
//-----------------------------------
void clearEntryAlertTime(int iPairIndex)
{
	aPairEntryAlertGiven[iPairIndex] = 0;
}

//-----------------------------------
// doTimedEntryAlert
//-----------------------------------
void doTimedEntryAlert (int iPairIndex, string& strAlert )
{
	datetime dtNow = TimeCurrent();
	if( (dtNow - aPairEntryAlertGiven[iPairIndex]) < GAPBETWEENENTRYALERTS )
		return;
		
	setEntryAlertTimeNow(iPairIndex);
	Alert(strAlert);
}

Code: Select all

//+------------------------------------------------------------------+
//| Monitoring spread
//|
//| This code has been extracted from several headers and is incomplete
//| Copyright Brian Abram 2013
//| Licence: GPL (open source)
//+------------------------------------------------------------------+


double arrSpreadInPips[];
double arrSpreadInPipsFor1Hour[MAXPAIRS][60] = {0};
double arrAvgSpreadInPips[MAXPAIRS] = {0};
double arrHighSpreads[];
double arrLowSpreads[];


void init_PairPointsAndSpreads() {
	int pairCount = ArraySize(Pairs);

	ArrayResize(arrAskPrice, pairCount);
	ArrayResize(arrBidPrice, pairCount);
	ArrayResize(arrSpreadInPips, pairCount);
	ArrayResize(arrHighSpreads, pairCount);
	ArrayResize(arrLowSpreads, pairCount);

}


//+------------------------------------------------------------------+
//| updateAverageSpread
//+------------------------------------------------------------------+
void updateAverageSpread(int iPairIndex) {
	int iCurrMinute = Minute();
	int iLastMinute = -1;
	int iCount = 0;
	double dSpread;
	double dSum;
	// rolling numbers

	if( iLastMinute == iCurrMinute )
		return;
	iLastMinute = iCurrMinute;

	arrSpreadInPipsFor1Hour[iPairIndex][iCurrMinute] = arrSpreadInPips[iPairIndex];

	dSum = 0;
	for( int index = 0; index < 60; index++ ) {
		dSpread = arrSpreadInPipsFor1Hour[iPairIndex][index];
		if( dSpread > EPSILON ) {
			iCount ++;
			dSum = dSum + dSpread;
		}
	}
	if( iCount == 0 ) {
		Print("updateAverageSpread() ERROR  ERROR  ERROR : array is empty!");
		return;
	}
	double dAverage = dSum / iCount;
	arrAvgSpreadInPips[iPairIndex] = dAverage;

}

//+------------------------------------------------------------------+
//| getAverageSpreadInPips
//+------------------------------------------------------------------+
double getAverageSpreadInPips(int iPairIndex) { return(arrAvgSpreadInPips[iPairIndex] ); }


//+------------------------------------------------------------------+
//| getAverageSpreadInPips
//+------------------------------------------------------------------+
double getAverageSpreadInPoints(int iPairIndex) {

	double dAvgSpreadInPoints = bwaConvPipsToPoints(iPairIndex, arrAvgSpreadInPips[iPairIndex] );

	return(dAvgSpreadInPoints );
}

//+------------------------------------------------------------------+
//| updateSpread
//+------------------------------------------------------------------+
double updateSpread( int iPairIndex,  double& dAsk, double& dBid ) {
	dAsk = MarketInfo(Pairs[iPairIndex], MODE_ASK );
	dBid = MarketInfo(Pairs[iPairIndex], MODE_BID );
	double dRawSpread = dAsk - dBid;

	arrSpreadInPips[iPairIndex] = bwaConvPointsToPips( iPairIndex, dRawSpread);
	arrHighSpreads[iPairIndex] = MathMax( arrSpreadInPips[iPairIndex], arrHighSpreads[iPairIndex] ) ;
	arrLowSpreads[iPairIndex] = MathMin( arrSpreadInPips[iPairIndex], arrLowSpreads[iPairIndex] );

	updateAverageSpread(iPairIndex);
	double dAvgSpread = getAverageSpreadInPips(iPairIndex);

	bool bDebugTrace = false;
	if( bDebugTrace && IsTesting() ) {
		string strPart1 = "";
		string strPart2 = "";
		string strPart3 = "";
		string strPart4 = "";
		strPart1 = Pairs[iPairIndex]+ ": Spread: Ask, Bid, Diff, DiffInPips : ";
		strPart2 = DoubleToStr(dAsk,5)+ ",  "+ DoubleToStr(dBid,5)+",  "+DoubleToStr( dRawSpread,5) +"  " ;
		strPart3 = "SpInPips: " + DoubleToStr( arrSpreadInPips[iPairIndex],2) + "  ";
		strPart4 = "Avg Sp in Pips: "+ DoubleToStr( arrAvgSpreadInPips[iPairIndex], 2) + "  ";

		gSpreadDetail =  strPart1 + strPart2 + strPart3 + strPart4;
		Print( gSpreadDetail );
	}

	return(arrSpreadInPips[iPairIndex]);
}

Code: Select all

#define ean "Your_EA's_Name_"
#define indie "Your_Indicator's_Name_"
// For EA's...
#define etp cat(ean, TradePair[cc], "_", string(Period()), "_") // Used in Multi-Symbol functions.
#define esp cat(ean, symbol, "_", string(Period()) "_") // Used in Single Symbol functions.
// For indicators
#define itp cat(indie, TradePair[cc], "_", string(Period()), "_") // Used in Multi-Symbol functions.
#define isp cat(indie, symbol, "_", string(Period()) "_") // Used in Single Symbol functions.

Code: Select all

   for (int cc = 0; cc < NoOfPairs; cc++)
   {
		fnerk = TradePair[cc];
		do something with fnerk;
   }

Code: Select all

//======== Lazy Typists' String Concatenation Functions========
string cat(string part1, string part2)
{
   string line = StringConcatenate(part1 + part2);
   return(line);
}

string cat(string part1, string part2, string part3)
{
   string line = StringConcatenate(part1 + part2 + part3);
   return(line);
}

string cat(string part1, string part2, string part3, string part4)
{
   string line = StringConcatenate(part1 + part2 + part3 + part4);
   return(line);
}

Code: Select all

// For EA's
//GlobalVariableCheck
      gvc(cat(etp, "My_Variable_Name"))

//GlobalVariableSet
      gvs(cat(esp, "My_Variable_Name"), NormalizeDouble(0, 0));

//GlobalVariableGet
      gvg(cat(etp, "My_Variable_Name"))

//GlobalVariableDel
      gvd(cat(etp, "My_Variable_Name"))

Code: Select all

      gvg(cat(etp, "My_Variable_Name_", string(UniqueIdentifier)))

Code: Select all

//---- Constants
#define  FILENAME          "Experts\files\/"+Symbol()+"-MagicNumber.txt"  // Change this to your file location

//---- Externals
extern string MN_Ex="------- Magic Number Settings (0 for automatic)";
extern int MagicNumber=0; // For 0 we generate MagicNumber automagically and store it in a file on disk

Code: Select all

int init()

   ... Other stuff

   // Get Magic Number
   if(MagicNumber==0) MagicNumber=GetMagicNumber();

return(0);

Code: Select all

//+------------------------------------------------------------------+
//| Generate or Retrieve Existing Magic Number                       |
//+------------------------------------------------------------------+

int GetMagicNumber()
  {
   if(MagicNumber==0)
     {
      //Open Symbol file and read contents
      int handle,space,i,pos[];
      string str,word;
      handle=FileOpen(FILENAME,FILE_TXT|FILE_READ|FILE_WRITE);    // Try to open the file
      if(handle==-1) {FileWrite(handle,""); FileClose(handle);}   // If it doesn't exist then we need to create it

      if(FileSize(handle)==0)                                     // If the file exists but its contents are zero
        {
         Print("File "+FILENAME+" Wasn't Found! That's ok. We'll create it!"); 
         MagicNumber=WindowHandle(Symbol(),0);// MagicNumber = 37338;
         FileWrite(handle,MagicNumber);
         FileClose(handle);
         Print("File: "+FILENAME+" was created!");
         return(MagicNumber);
        }

      if(FileSize(handle)>0)                                      // If the file exists and the size of the file is greater than 0.
        {
         str=FileReadString(handle);                              // Read one paragraph to the str variable
         if(str!="")                                              // If the string isn't empty
           {
            space=0;
            for(i=0;i<StringLen(str);i++)
              {
               if(StringGetChar(str,i)==32)// Look for 32 spaces only
                 {
                  space++;
                  ArrayResize(pos,space); // Increase the array size
                  pos[space-1]=i;         // Write the number of the space position to array
                 }
              }                           // Now we have array with numbers of positions of all spaces
            for(i=0;i<=space;i++)         // Read the elements of the string
              {
               if(i==0) word=StringSubstr(str,0,pos[0]);                   // The first element of the string (in this case it is the magic number)
               else word=StringSubstr(str,pos[i-1]+1,pos[i]-pos[i-1]-1);   // The rest of the elements
                                                                           // Perform analysis, calculate StrToInteger or whatever StrToDouble here.
               FileClose(handle);         // Close the file
               MagicNumber=StringToInteger(word);

              }
           }
        }
     }
   return(MagicNumber);
  }