10.4 A Complete System

[pips400]

really quiet day.. nothing so far except scalped some pips off chf pairs

Its Bank Holiday in UK and US today, so not expecting the same momentum in price action until tomorrow.

[pips400]

Nice clear explanation Bob, thanks. I'll give that a try.

Anybody else having trouble with the recent 10.5 templates? When I start up Empty4 my charts look like this:

10.5.gif

Weekly S/R levels don't have any history, and no CSS. If I edit/replot CSS and 10.4 WP it looks OK, but that's a PITA to do for 20+ charts. Am I doing something wrong?

It does the same to me. If I go to H1 and then back to H4 it will be OK.
I use the attached scripts to change Time Frame on ALL pairs.
Move all to H1, and then all to H4.
HTH
Bernard

I find the easiest way to "populate" the CSS for each pair is simply to reload the profile I'm using, that does it all with one click.

[nicoacademia]

really quiet day.. nothing so far except scalped some pips off chf pairs

Its Bank Holiday in UK and US today, so not expecting the same momentum in price action until tomorrow.

then the fun really begins.
just check out the calendar.
it's all over the shop. every kind of important data too.
every pair will be hit with something.
rehearse well in this quiet time.

[alex84]

Go to 1H chart

1. CSS is red so not a good time to enter, However if it was
2. buy pending at DP, DR1 and TP at WS1 would be the setup.
3. BUY LIMIT at WP
4. RED bar CSS is telling us to wait

thanks Bob for explanations of new tpl
You wrote WS1 instead of WR1 for your TP
But i guess everybody understood watching objects on your illustrated chart
thanks

[ronald123]

Hi guys,

not really much to do with this topic, but was just wondering: has anybody else here been unable to connect to their broker(s) since MQ forced its last Empty4 update (build 500) up to its 'customers'? Waiting for a 'fix' for more than one week now; tried everything to get this crap working again (complete un-install/re-install, different version overwrite for 'terminal.exe', etc.), no success so far. Anyway, just wondered about this...

Cheers and good luck to all

[6y588]

Given that it is a bank holiday today, and not much action on the forex market. I decided to implement a sound alert feature in the CSS indicator. Sometimes I missed crosses, as I do not monitor the screen constantly, hence the auditory alert helps me occasionally.

Its feature is that there is one alert per currency per timeframe, which is reset ON the hour, i.e. 10:00, 11:00, etc, using showOnlySymbolOnChart=false.

For example, an alert goes off for H4 GBP and D1 NZD during this hour, then there is no more alerts for both this currencies until the NEXT hour. But a D1 GBP and H4 NZD alert can still go off during this hour.

Code: Select all

//+------------------------------------------------------------------+
//|                                        CurrencySlopeStrength.mq4 |
//|                      Copyright 2012, Deltabron - Paul Geirnaerdt |
//|                                          http://www.deltabron.nl |
//+------------------------------------------------------------------+
//
// Parts based on CCFp.mq4, downloaded from mql4.com
// TMA Calculations © 2012 by ZZNBRM
//
#property copyright "Copyright 2012, Deltabron - Paul Geirnaerdt"
#property link      "http://www.deltabron.nl"
//----
#property indicator_separate_window
#property indicator_buffers 8

#define version            "v1.0.7 D"

//+------------------------------------------------------------------+
//| Release Notes                                                    |
//+------------------------------------------------------------------+
// v1.0.0 (alpha), 6/1/12
// * Added support to auto create symbolnames
// * Added 'maxBars' setting to limit number of history bars calculated and improve performance
// v1.0.0, 6/4/12
// * BUG: added (almost) unique identifier for objects to get multiple instances in one window (thanks, Verb)
// * New default for user setting 'symbolsToWeigh', it now has all symbols that the NanningBob 10.2 system looks at
// v1.0.1, 6/11/12
// * Added a alert for crosses of the Currency Slope Strength
// * Added user settings for the colo(u)r of weak, normal and strong cross alerts.
// * Added user setting 'autoTimeFrame' to use timeframe on chart. If set to false setting 'timeFrame' is used.
// * User can now set all timeframes.
// v1.0.2, 6/12/12
// * Added option to disable so-called 'repainting', that is not to consider future bars for any calculation
// * Changed indicator short name
// * Code optimization
// v1.0.3, 6/26/12
// * Improved display format for 'showOnlySymbolOnChart' is set to 'true'
// * Added background indicator line for difference of two Slope lines, difference must be over threshold
// v1.0.4, 12/4/12
// * Fixed bug in 'showOnlySymbolOnChart' logic, thanks George
// v1.0.5, 3/28/13
// * Merged code from SlopeValues
// * Exclude symbols the broker does not offer
// v1.0.6, 4/17/13
// * Added timeframe in display table
// v1.0.7, 4/26/13
// * Fixed issue for single symbol use
// * Introduced user variable for single symbol use
// * Introduced multi colored background for single symbol use

#define EPSILON            0.00000001

#define CURRENCYCOUNT      8

//---- parameters

//extern string  gen               = "----General inputs----";
extern string  gen               = "----General inputs----";
extern bool    autoSymbols       = true;
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 bool    weighOnlySymbolOnChart = true;
extern int     maxBars           = 100;
extern string  nonPropFont       = "Lucida Console";
extern bool    addSundayToMonday = true;
extern bool    showOnlySymbolOnChart = true;

extern string  ind               = "----Indicator inputs----";
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      = true;
extern bool    showCrossAlerts   = true;
extern double  differenceThreshold= 2.5;

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               = "----Colo(u)r inputs----";
extern color   Color_USD         = Black;
extern color   Color_EUR         = Aqua;
extern color   Color_GBP         = DodgerBlue;
extern color   Color_CHF         = Blue;
extern color   Color_JPY         = Orange;
extern color   Color_AUD         = Yellow;
extern color   Color_CAD         = White;
extern color   Color_NZD         = Gold;
extern color   colorWeakCross    = OrangeRed;
extern color   colorNormalCross  = Gold;
extern color   colorStrongCross  = LimeGreen;
extern color   colorDifferenceUp = DarkGreen;
extern color   colorDifferenceDn = Maroon;
extern color   colorDifferenceLo = Goldenrod;
extern color   colorTimeframe    = White;


// global indicator variables
string   indicatorName = "CurrencySlopeStrength";
string   shortName;
int      userTimeFrame;
string   almostUniqueIndex;
bool     sundayCandlesDetected;                          

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

// symbol & currency variables
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];

// object parameters
int      verticalShift = 14;
int      verticalOffset = 30;
int      horizontalShift = 100;
int      horizontalOffset = 10;

//----
int      nextBarTime[];
string   nextCurrencyTime[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
   initSymbols();
 
   string now = TimeCurrent();
   almostUniqueIndex = StringSubstr(now, StringLen(now) - 3) + WindowsTotal();

//---- indicators
   shortName = indicatorName + " - " + version + " - id" + WindowsTotal() + StringSubstr(now, StringLen(now) - 1);
   IndicatorShortName(shortName);
//----
   currencyColors[0] = Color_USD;
   SetIndexBuffer(0, arrUSD);
   SetIndexLabel(0, "USD"); 
   
   currencyColors[1] = Color_EUR;
   SetIndexBuffer(1, arrEUR);
   SetIndexLabel(1, "EUR"); 
   
   currencyColors[2] = Color_GBP;
   SetIndexBuffer(2, arrGBP);
   SetIndexLabel(2, "GBP"); 

   currencyColors[3] = Color_CHF;
   SetIndexBuffer(3, arrCHF);
   SetIndexLabel(3, "CHF"); 

   currencyColors[4] = Color_JPY;
   SetIndexBuffer(4, arrJPY);
   SetIndexLabel(4, "JPY"); 

   currencyColors[5] = Color_AUD;
   SetIndexBuffer(5, arrAUD);
   SetIndexLabel(5, "AUD"); 

   currencyColors[6] = Color_CAD;
   SetIndexBuffer(6, arrCAD);
   SetIndexLabel(6, "CAD"); 

   currencyColors[7] = Color_NZD;
   SetIndexBuffer(7, arrNZD);
   SetIndexLabel(7, "NZD"); 
//----

   sundayCandlesDetected = false;
   for ( int i = 0; i < 8; i++ )
   {
      if ( TimeDayOfWeek( iTime( NULL, PERIOD_D1, i ) ) == 0 )
      {
         sundayCandlesDetected = true;
         break;
      }
   }
   
   if ( weighOnlySymbolOnChart ) showOnlySymbolOnChart = true;
   
   return(0);
}

//+------------------------------------------------------------------+
//| Initialize Symbols Array                                         |
//+------------------------------------------------------------------+
int initSymbols()
{
   int i;
   
   // Get extra characters on this crimmal's symbol names
   string symbolExtraChars = StringSubstr(Symbol(), 6, 4);

   if ( weighOnlySymbolOnChart )
   {
      symbolsToWeigh = Symbol();
   }
      
   // Trim user input
   symbolsToWeigh = StringTrimLeft(symbolsToWeigh);
   symbolsToWeigh = StringTrimRight(symbolsToWeigh);

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

   // Build symbolNames array as the user likes it
   if ( autoSymbols )
   {
      createSymbolNamesArray();
   }
   else
   {
      // Split user input
      i = StringFind( symbolsToWeigh, "," ); 
      while ( i != -1 )
      {
         int size = ArraySize(symbolNames);
         string newSymbol = StringConcatenate(StringSubstr(symbolsToWeigh, 0, i), symbolExtraChars);
         if ( MarketInfo( newSymbol, MODE_TRADEALLOWED ) > EPSILON )
         {
            ArrayResize( symbolNames, size + 1 );
            // Set array
            symbolNames[size] = newSymbol;
         }
         // Trim symbols
         symbolsToWeigh = StringSubstr(symbolsToWeigh, i + 1);
         i = StringFind(symbolsToWeigh, ","); 
      }
   }
   
   // Kill unwanted symbols from array
   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 )
            {
               continue;
            }
            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);
   // Print("symbolCount: ", symbolCount);

   for ( i = 0; i < symbolCount; i++ )
   {
      // Increase currency occurrence
      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 );
}

//+------------------------------------------------------------------+
//| GetTimeframeString( int tf )                                     |
//+------------------------------------------------------------------+
string GetTimeframeString( int tf )
{
   string result;
   switch ( tf )
   {
      case PERIOD_M1:   result = "M1";    break;
      case PERIOD_M5:   result = "M5";    break;
      case PERIOD_M15:  result = "M15";   break;
      case PERIOD_M30:  result = "M30";   break;
      case PERIOD_H1:   result = "H1";    break;
      case PERIOD_H4:   result = "H4";    break;
      case PERIOD_D1:   result = "D1";    break;
      case PERIOD_W1:   result = "W1";    break;
      case PERIOD_MN1:  result = "MN1";   break;
      default: result = "SRITSOD";
   }
   return ( result );
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   int windex = WindowFind ( shortName );
   if ( windex > 0 )
   {
      ObjectsDeleteAll ( windex );
   }   
//----
   return(0);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{
   int limit;
   int counted_bars = IndicatorCounted();

   if (counted_bars < 0)  return(-1);
   if (counted_bars > 0)  counted_bars -= 10;

   limit = Bars - counted_bars;

   if ( maxBars > 0 )
   {
      limit = MathMin (maxBars, limit);   
   }   

   int i;
   
   for ( i = 0; i < CURRENCYCOUNT; i++ )
   {
      SetIndexStyle( i, DRAW_LINE, STYLE_SOLID, 2, currencyColors[i] );
   }   

   RefreshRates();
   
   for ( i = limit; i >= 0; i-- )
   {
      int index;
      double diff = 0.0;
      
      ArrayInitialize(currencyValues, 0.0);

      // Calc Slope into currencyValues[]  
      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 )
      {
         // Show ordered table
         ShowCurrencyTable( userTimeFrame );
      }
      
      // Only two currencies, show background
      if ( showOnlySymbolOnChart )
      {
         // Create background object
         int windex = WindowFind ( shortName );
         string objectName = almostUniqueIndex + "_diff_" + Time[i];
         if ( ObjectFind ( objectName ) == -1 )
         {
            if ( ObjectCreate ( objectName, OBJ_VLINE, windex, Time[i], 0 ) )
            {
               ObjectSet ( objectName, OBJPROP_BACK, true );
               ObjectSet ( objectName, OBJPROP_WIDTH, 8 );
            }
         }
         // Determine background color
         if ( MathAbs( diff ) > differenceThreshold ) 
         {
            // Check diff sign
            double cssLong = currencyValues[GetCurrencyIndex(StringSubstr(Symbol(), 0, 3))];
            double cssShort = currencyValues[GetCurrencyIndex(StringSubstr(Symbol(), 3, 3))];
            if ( cssLong > cssShort )
               ObjectSet ( objectName, OBJPROP_COLOR, colorDifferenceUp );
            else
               ObjectSet ( objectName, OBJPROP_COLOR, colorDifferenceDn );
         }
         else
         {
            // Below threshold
            ObjectSet ( objectName, OBJPROP_COLOR, colorDifferenceLo );
         }
      }

   }

   return(0);
}

//+------------------------------------------------------------------+
//| GetSlope()                                                       |
//+------------------------------------------------------------------+
double GetSlope(string symbol, int tf, int shift)
{
   double dblTma, dblPrev;
   int shiftWithoutSunday = shift;
   if ( addSundayToMonday && sundayCandlesDetected && tf == PERIOD_D1 )
   {
      if ( TimeDayOfWeek( iTime( symbol, PERIOD_D1, shift ) ) == 0  ) shiftWithoutSunday++;
   }   
   double atr = iATR(symbol, tf, 25, shiftWithoutSunday + 10) / 10;
   //change from 100
   double gadblSlope = 0.0;
   if ( atr != 0 )
   {
      if ( ignoreFuture )
      {
         dblTma = calcTmaTrue( symbol, tf, shiftWithoutSunday );
         dblPrev = calcPrevTrue( symbol, tf, shiftWithoutSunday );
      }
      else
      {   
         dblTma = calcTma( symbol, tf, shiftWithoutSunday );
         dblPrev = calcTma( symbol, tf, shiftWithoutSunday + 1 );
      }   
      gadblSlope = ( dblTma - dblPrev ) / atr;
   }
   
   return ( gadblSlope );

}

//+------------------------------------------------------------------+
//| calcTma()                                                        |
//+------------------------------------------------------------------+
double calcTma( string symbol, int tf,  int shift )
{
   double dblSum  = iClose( symbol, tf, shift ) * 3;
   double dblSumw = 3;
   int jnx, knx;
         
   for ( jnx = 1, knx = 20; jnx <= 20; jnx++, knx-- )
   {
      dblSum  += iClose(symbol, tf, shift + jnx) * knx;
      dblSumw += knx;

      if ( jnx <= shift )
      {
         dblSum  += iClose(symbol, tf, shift - jnx) * knx;
         dblSumw += knx;
      }
   }
   
   return ( dblSum / dblSumw );
}


//+------------------------------------------------------------------+
//| calcTmaTrue()                                                    |
//+------------------------------------------------------------------+
double calcTmaTrue( string symbol, int tf, int inx )
{
   return ( iMA( symbol, tf, 3, 0, MODE_LWMA, PRICE_CLOSE, inx ) );
}

//+------------------------------------------------------------------+
//| calcPrevTrue()                                                   |
//+------------------------------------------------------------------+
double calcPrevTrue( string symbol, int tf, int inx )
{
   double dblSum  = iClose( symbol, tf, inx + 1 ) * 3;
   double dblSumw = 3;
   int jnx, knx;
   
   dblSum  += iClose( symbol, tf, inx ) * 20;
   dblSumw += 20;
         
   for ( jnx = 1, knx = 20; jnx <= 20; jnx++, knx-- )
   {
      dblSum  += iClose( symbol, tf, inx + 1 + jnx ) * knx;
      dblSumw += knx;
   }
   
   return ( dblSum / dblSumw );
}
 
//+------------------------------------------------------------------+
//| CalculateCurrencySlopeStrength(int tf, int shift                 |
//+------------------------------------------------------------------+
void CalculateCurrencySlopeStrength(int tf, int shift)
{
   int i;
   // Get Slope for all symbols and totalize for all currencies   
   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++ )
   {
      // average
      if ( currencyOccurrences[i] > 0 ) currencyValues[i] /= currencyOccurrences[i]; else currencyValues[i] = 0;
   }
}

//+------------------------------------------------------------------+
//| ShowCurrencyTable()                                              |
//+------------------------------------------------------------------+
void ShowCurrencyTable( int tf )
{
   int i = 0;
   int tempValue;
   string objectName;
   string showText;
   color showColor;
   int windex = WindowFind ( shortName );

   if ( showOnlySymbolOnChart )
   {
      // Header
      objectName = almostUniqueIndex + "_css_obj_column_currency_tf";
      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, verticalOffset - 18 );
         }
      }
      showText = "TF ";
      ObjectSetText ( objectName, showText, 14, nonPropFont, colorTimeframe );

      objectName = almostUniqueIndex + "_css_obj_column_value_tf";
      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, verticalOffset - 18 );
         }
      }
      ObjectSetText ( objectName, GetTimeframeString( tf ), 14, nonPropFont, colorTimeframe );
      
      // Chart symbols only
      // Loop currency values and header output objects, creating them if necessary 
      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 + 1) + 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 + 1) + 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) * 3 + verticalOffset - 10 );
         }
      }
      showText = "threshold = " + DoubleToStr(differenceThreshold, 1);
      ObjectSetText ( objectName, showText, 8, nonPropFont, Yellow );
   }
   else
   {
      // Header
      objectName = almostUniqueIndex + "_css_obj_column_currency_tf";
      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 );
         }
      }
      showText = "TF ";
      ObjectSetText ( objectName, showText, 12, nonPropFont, colorTimeframe );

      objectName = almostUniqueIndex + "_css_obj_column_value_tf";
      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 );
         }
      }
      ObjectSetText ( objectName, GetTimeframeString( tf ), 12, nonPropFont, colorTimeframe );
      
      // Full table
      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;
      }
   
      // Sort currency to values
      ArraySort(tempCurrencyValues, WHOLE_ARRAY, 0, MODE_DESCEND);

      int horizontalOffsetCross = 0;
      // Loop currency values and header output objects, creating them if necessary 
      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 + 1) + 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 + 1) + verticalOffset - 18 );
            }
         }
         showText = RightAlign(DoubleToStr(tempCurrencyValues[i][0], 2), 5);
         ObjectSetText ( objectName, showText, 12, nonPropFont, currencyColors[tempValue] );
      
         // Detect and show crosses if users want to
         // Test for normalized values to filter trivial crosses
         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;
               showAlert( "Cross Weak:", currencyNames[tempValue], userTimeFrame);
            }
            else if  ( tempCurrencyValues[i][0] > 0.4 || tempCurrencyValues[i + 1][0] < -0.4 )
            {
               showColor = colorNormalCross;
               showAlert( "Cross Normal:", currencyNames[tempValue], userTimeFrame);
            } else {
               showAlert( "Cross Strong:", currencyNames[tempValue], userTimeFrame);
            }
      
            // Prior values of this currency is lower than next currency, this is a cross.
            DrawCell(windex, objectName, horizontalShift * 0 + horizontalOffset + 88 + horizontalOffsetCross, (verticalShift + 2) * (i + 1) + verticalOffset - 20, 1, 27, showColor );
      
            // Move cross location to next column if necessary
            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 ); // Number of squares used.
      iHeight  = MathRound ( ( nHeight * 100 ) / 77 ); // Real height size.
      iWidth   = MathRound ( ( nWidth * 100 ) / 77 ); // Real width size.
      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 ); // Number of squares used.
      iHeight  = MathRound ( ( nHeight * 100 ) / 77 ); // Real height size.
      iWidth   = MathRound ( ( nWidth * 100 ) / 77 ); // Real width size.
      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++;
   }   
}
bool isNewBar(int bar)
{
  if( bar == TimeHour(TimeLocal()) )
    return(false);
  else
    bar = TimeHour(TimeLocal());
  return(true);
}
string timeFrameToStr(int userTimeFrame)
{
		if ( userTimeFrame == PERIOD_M1 )       return( "M1" );
		else if ( userTimeFrame == PERIOD_M5 )   return( "M5" );
		else if ( userTimeFrame == PERIOD_M15 )  return( "M15" );
		else if ( userTimeFrame == PERIOD_M30 )  return( "M30" );
		else if ( userTimeFrame == PERIOD_H1 )   return( "H1" );
		else if ( userTimeFrame == PERIOD_H4 )   return( "H4" );
		else if ( userTimeFrame == PERIOD_D1 )   return( "D1" );
		else if ( userTimeFrame == PERIOD_W1 )   return( "W1" );
		else if ( userTimeFrame == PERIOD_MN1 )  return( "MN1" );
}
void showAlert(string msg, string cur, int utf)
{
   int   total=ArraySize(nextCurrencyTime);
   bool  exist=false;
   for(int i=0; i<total; i++)
   {
      if( nextCurrencyTime[i] == cur ) exist=true;
   }
   if( !exist ) 
   {
      ArrayResize(nextCurrencyTime, total+1);
      ArrayResize(nextBarTime, total+1);
      nextCurrencyTime[total] = cur;
   }

   int   count=ArraySize(nextCurrencyTime);
   int   curIndex=-1;
   for(i=0; i<count; i++)
   {
      if( nextCurrencyTime[i] == cur ) curIndex=i;
   }
   if( curIndex<0 ) return(0);

   if( isNewBar( nextBarTime[curIndex] ) )
   {
      nextBarTime[curIndex] = TimeHour(TimeLocal());
      Alert(timeFrameToStr(utf)+" "+msg+" "+cur);
   }
}

[Staedtler]

really quiet day.. nothing so far except scalped some pips off chf pairs

Its Bank Holiday in UK and US today, so not expecting the same momentum in price action until tomorrow.

then the fun really begins.
just check out the calendar.
it's all over the shop. every kind of important data too.
every pair will be hit with something.
rehearse well in this quiet time.

We got a serious line up for this week ! 2 weeks of zzzzz hopefully this week will spur some serious action

[nicoacademia]

just some highlights GDP on CHF/USD/CAD. CAD rate statements.

bank of canada governor is due on start of june.

and kuroda speaking soon too.

and actual china PMI data at the end of this week.

check the calendar for more.

[willmalou]

Can you post this please

Given that it is a bank holiday today, and not much action on the forex market. I decided to implement a sound alert feature in the CSS indicator. Sometimes I missed crosses, as I do not monitor the screen constantly, hence the auditory alert helps me occasionally.

Its feature is that there is one alert per currency per timeframe, which is reset ON the hour, i.e. 10:00, 11:00, etc, using showOnlySymbolOnChart=false.

For example, an alert goes off for H4 GBP and D1 NZD during this hour, then there is no more alerts for both this currencies until the NEXT hour. But a D1 GBP and H4 NZD alert can still go off during this hour.

[zentauro67]

Thanks Bernard for the scripts. Very useful. I use 4H to see what is the "right side" and 1H for scalping. So, this will be a save time.

I don´t see too much action today. Maybe I will go to 15 min charts looking for range boxes and be back to 10.4 tomorrow.