research ea to indi.mq4

//+------------------------------------------------------------------------------+//

//)   ____  _  _  ____  ____  ____  ____  __  __    __      ___  _____  __  __   (//

//)  ( ___)( \/ )(  _ \(  _ \( ___)( ___)(  \/  )  /__\    / __)(  _  )(  \/  )  (//

//)   )__)  )  (  )(_) ))   / )__)  )__)  )    (  /(__)\  ( (__  )(_)(  )    (   (//

//)  (__)  (_/\_)(____/(_)\_)(____)(____)(_/\/\_)(__)(__)()\___)(_____)(_/\/\_)  (//

//)   https://fxdreema.com                             Copyright 2021, fxDreema  (//

//+------------------------------------------------------------------------------+//

#property copyright   ""

#property link        "https://fxdreema.com"

#property description ""

#property version     "1.0"

#property strict

#property indicator_chart_window //----- here



/************************************************************************************************************************/

// +------------------------------------------------------------------------------------------------------------------+ //

// |                       INPUT PARAMETERS, GLOBAL VARIABLES, CONSTANTS, IMPORTS and INCLUDES                        | //

// |                      System and Custom variables and other definitions used in the project                       | //

// +------------------------------------------------------------------------------------------------------------------+ //

/************************************************************************************************************************/



//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//

// System constants (project settings) //

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//

//--

#define PROJECT_ID "mt4-4320"

//--

// Point Format Rules

#define POINT_FORMAT_RULES "0.001=0.01,0.00001=0.0001,0.000001=0.0001" // this is deserialized in a special function later

#define ENABLE_SPREAD_METER true

#define ENABLE_STATUS true

#define ENABLE_TEST_INDICATORS true

//--

// Events On/Off

#define ENABLE_EVENT_TICK 1 // enable "Tick" event

#define ENABLE_EVENT_TRADE 0 // enable "Trade" event

#define ENABLE_EVENT_TIMER 0 // enable "Timer" event

//--

// Virtual Stops

#define VIRTUAL_STOPS_ENABLED 0 // enable virtual stops

#define VIRTUAL_STOPS_TIMEOUT 0 // virtual stops timeout

#define USE_EMERGENCY_STOPS "no" // "yes" to use emergency (hard stops) when virtual stops are in use. "always" to use EMERGENCY_STOPS_ADD as emergency stops when there is no virtual stop.

#define EMERGENCY_STOPS_REL 0 // use 0 to disable hard stops when virtual stops are enabled. Use a value >=0 to automatically set hard stops with virtual. Example: if 2 is used, then hard stops will be 2 times bigger than virtual ones.

#define EMERGENCY_STOPS_ADD 0 // add pips to relative size of emergency stops (hard stops)

//--

// Settings for events

#define ON_TRADE_REALTIME 0 //

#define ON_TIMER_PERIOD 60 // Timer event period (in seconds)



//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//

// System constants (predefined constants) //

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//

//--

// Blocks Lookup Functions

string fxdBlocksLookupTable[];



#define TLOBJPROP_TIME1 801

#define OBJPROP_TL_PRICE_BY_SHIFT 802

#define OBJPROP_TL_SHIFT_BY_PRICE 803

#define OBJPROP_FIBOVALUE 804

#define OBJPROP_FIBOPRICEVALUE 805

#define OBJPROP_BARSHIFT1 807

#define OBJPROP_BARSHIFT2 808

#define OBJPROP_BARSHIFT3 809

#define SEL_CURRENT 0

#define SEL_INITIAL 1



//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//

// Enumerations, Imports, Constants, Variables //

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//











//--

// Constants (Input Parameters)

input int MagicStart = 4320; // Magic Number, kind of...

class c

{

		public:

	static int MagicStart;

};

int c::MagicStart;





//--

// Variables (Global Variables)

class v

{

		public:

};









//VVVVVVVVVVVVVVVVVVVVVVVVV//

// System global variables //

//^^^^^^^^^^^^^^^^^^^^^^^^^//

//--

int FXD_CURRENT_FUNCTION_ID = 0;

double FXD_MILS_INIT_END    = 0;

int FXD_TICKS_FROM_START    = 0;

int FXD_MORE_SHIFT          = 0;

bool FXD_DRAW_SPREAD_INFO   = false;

bool FXD_FIRST_TICK_PASSED  = false;

bool FXD_BREAK              = false;

bool FXD_CONTINUE           = false;

bool FXD_CHART_IS_OFFLINE   = false;

bool FXD_ONTIMER_TAKEN      = false;

bool FXD_ONTIMER_TAKEN_IN_MILLISECONDS = false;

double FXD_ONTIMER_TAKEN_TIME = 0;

bool USE_VIRTUAL_STOPS = VIRTUAL_STOPS_ENABLED;

string FXD_CURRENT_SYMBOL   = "";

int FXD_BLOCKS_COUNT        = 6;

datetime FXD_TICKSKIP_UNTIL = 0;



//- for use in OnChart() event

struct fxd_onchart

{

	int id;

	long lparam;

	double dparam;

	string sparam;

};

fxd_onchart FXD_ONCHART;



/************************************************************************************************************************/

// +------------------------------------------------------------------------------------------------------------------+ //

// |                                                 EVENT FUNCTIONS                                                  | //

// |                           These are the main functions that controls the whole project                           | //

// +------------------------------------------------------------------------------------------------------------------+ //

/************************************************************************************************************************/



//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//

// This function is executed once when the program starts //

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//

int OnInit()

{



	// Initiate Constants

	c::MagicStart = MagicStart;









	// do or do not not initilialize on reload

	if (UninitializeReason() != 0)

	{

		if (UninitializeReason() == REASON_CHARTCHANGE)

		{

			// if the symbol is the same, do not reload, otherwise continue below

			if (FXD_CURRENT_SYMBOL == Symbol()) {return INIT_SUCCEEDED;}

		}

		else

		{

			return INIT_SUCCEEDED;

		}

	}

	FXD_CURRENT_SYMBOL = Symbol();



	CurrentSymbol(FXD_CURRENT_SYMBOL); // CurrentSymbol() has internal memory that should be set from here when the symboll is changed

	CurrentTimeframe(PERIOD_CURRENT);











	Comment("");

	for (int i=ObjectsTotal(ChartID()); i>=0; i--)

	{

		string name = ObjectName(ChartID(), i);

		if (StringSubstr(name,0,8) == "fxd_cmnt") {ObjectDelete(ChartID(), name);}

	}

	ChartRedraw();







	//-- disable virtual stops in optimization, because graphical objects does not work

	// http://docs.mql4.com/runtime/testing

	if (MQLInfoInteger(MQL_OPTIMIZATION) || (MQLInfoInteger(MQL_TESTER) && !MQLInfoInteger(MQL_VISUAL_MODE))) {

		USE_VIRTUAL_STOPS = false;

	}



	//-- set initial local and server time

	TimeAtStart("set");



	//-- set initial balance

	AccountBalanceAtStart();



	//-- draw the initial spread info meter

	if (ENABLE_SPREAD_METER == false) {

		FXD_DRAW_SPREAD_INFO = false;

	}

	else {

		FXD_DRAW_SPREAD_INFO = !(MQLInfoInteger(MQL_TESTER) && !MQLInfoInteger(MQL_VISUAL_MODE));

	}

	if (FXD_DRAW_SPREAD_INFO) DrawSpreadInfo();



	//-- draw initial status

	if (ENABLE_STATUS) DrawStatus("waiting for tick...");



	//-- draw indicators after test

	TesterHideIndicators(!ENABLE_TEST_INDICATORS);



	//-- working with offline charts

	if (MQLInfoInteger(MQL_PROGRAM_TYPE) == PROGRAM_EXPERT)

	{

		FXD_CHART_IS_OFFLINE = ChartGetInteger(0, CHART_IS_OFFLINE);

	}



	if (MQLInfoInteger(MQL_PROGRAM_TYPE) != PROGRAM_SCRIPT)

	{

		if (FXD_CHART_IS_OFFLINE == true || (ENABLE_EVENT_TRADE == 1 && ON_TRADE_REALTIME == 1))

		{

			FXD_ONTIMER_TAKEN = true;

			EventSetMillisecondTimer(1);

		}

		if (ENABLE_EVENT_TIMER) {

			OnTimerSet(ON_TIMER_PERIOD);

		}

	}





	//-- Initialize blocks classes

	ArrayResize(_blocks_, 6);



	_blocks_[0] = new Block0();

	_blocks_[1] = new Block1();

	_blocks_[2] = new Block2();

	_blocks_[3] = new Block3();

	_blocks_[4] = new Block4();

	_blocks_[5] = new Block5();



	// fill the lookup table

	ArrayResize(fxdBlocksLookupTable, ArraySize(_blocks_));

	for (int i=0; i<ArraySize(_blocks_); i++)

	{

		fxdBlocksLookupTable[i] = _blocks_[i].__block_user_number;

	}



	// fill the list of inbound blocks for each BlockCalls instance

	for (int i=0; i<ArraySize(_blocks_); i++)

	{

		_blocks_[i].__announceThisBlock();

	}



	// List of initially disabled blocks

	int disabled_blocks_list[] = {};

	for (int l = 0; l < ArraySize(disabled_blocks_list); l++) {

		_blocks_[disabled_blocks_list[l]].__disabled = true;

	}







	FXD_MILS_INIT_END     = (double)GetTickCount();

	FXD_FIRST_TICK_PASSED = false; // reset is needed when changing inputs



	return(INIT_SUCCEEDED);

}



//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//

// This function is executed on every incoming tick //

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//



//----- here

int OnCalculate(const int rates_total,

                const int prev_calculated,

                const datetime &time[],

                const double &open[],

                const double &high[],

                const double &low[],

                const double &close[],

                const long &tick_volume[],

                const long &volume[],

                const int &spread[])

{

	FXD_TICKS_FROM_START++;



	if (ENABLE_STATUS && FXD_TICKS_FROM_START == 1) DrawStatus("working");



	//-- special system actions

	if (FXD_DRAW_SPREAD_INFO) DrawSpreadInfo();

	TicksData(""); // Collect ticks (if needed)

	TicksPerSecond(false, true); // Collect ticks per second

	if (USE_VIRTUAL_STOPS) {VirtualStopsDriver();}



	if (false) ExpirationWorker * expirationDummy = new ExpirationWorker();

	expirationWorker.Run();



	if (OrdersTotal()) // this makes things faster

	{

		OCODriver(); // Check and close OCO orders

	}



	if (ENABLE_EVENT_TRADE) {OnTrade();}





	// skip ticks

	if (TimeLocal() < FXD_TICKSKIP_UNTIL) {return(rates_total);}//--- here



	//-- run blocks

	int blocks_to_run[] = {0,3};

	for (int i=0; i<ArraySize(blocks_to_run); i++) {

		_blocks_[blocks_to_run[i]].run();

	}





	return(rates_total); //--- here

}







//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//

// This function is executed on every tick, because it's not native for MQL4  //

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//

void OnTrade()

{

	// This is needed so that the OnTradeEventDetector class is added into the code

	if (false) OnTradeEventDetector * dummy = new OnTradeEventDetector();



}



//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//

// This function is executed on a period basis //

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//

//----- here comment ontimer

/*

void OnTimer()

{

	//-- to simulate ticks in offline charts, Timer is used instead of infinite loop

	//-- the next function checks for changes in price and calls OnTick() manually

	if (FXD_CHART_IS_OFFLINE && RefreshRates()) {

		OnTick();

	}

	if (ON_TRADE_REALTIME == 1) {

		OnTrade();

	}



	static datetime t0 = 0;

	datetime t = 0;

	bool ok = false;



	if (FXD_ONTIMER_TAKEN)

	{

		if (FXD_ONTIMER_TAKEN_TIME > 0)

		{

			if (FXD_ONTIMER_TAKEN_IN_MILLISECONDS == true)

			{

				t = GetTickCount();

			}

			else

			{

				t = TimeLocal();

			}

			if ((t - t0) >= FXD_ONTIMER_TAKEN_TIME)

			{

				t0 = t;

				ok = true;

			}

		}



		if (ok == false) {

			return;

		}

	}



}

*/



//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//

// This function is executed when chart event happens //

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//

void OnChartEvent(

	const int id,         // Event ID

	const long& lparam,   // Parameter of type long event

	const double& dparam, // Parameter of type double event

	const string& sparam  // Parameter of type string events

)

{

	//-- write parameter to the system global variables

	FXD_ONCHART.id     = id;

	FXD_ONCHART.lparam = lparam;

	FXD_ONCHART.dparam = dparam;

	FXD_ONCHART.sparam = sparam;





	return;

}



//VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV//

// This function is executed once when the program ends //

//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//

void OnDeinit(const int reason)

{

	int reson = UninitializeReason();

	if (reson == REASON_CHARTCHANGE || reson == REASON_PARAMETERS || reason == REASON_TEMPLATE) {return;}



	//-- if Timer was set, kill it here

	EventKillTimer();



	if (ENABLE_STATUS) DrawStatus("stopped");

	if (ENABLE_SPREAD_METER) DrawSpreadInfo();







	if (MQLInfoInteger(MQL_TESTER)) {

		Print("Backtested in "+DoubleToString((GetTickCount()-FXD_MILS_INIT_END)/1000, 2)+" seconds");

		double tc = GetTickCount()-FXD_MILS_INIT_END;

		if (tc > 0)

		{

			Print("Average ticks per second: "+DoubleToString(FXD_TICKS_FROM_START/tc, 0));

		}

	}



	if (MQLInfoInteger(MQL_PROGRAM_TYPE) == PROGRAM_EXPERT)

	{

		switch(UninitializeReason())

		{

			case REASON_PROGRAM     : Print("Expert Advisor self terminated"); break;

			case REASON_REMOVE      : Print("Expert Advisor removed from the chart"); break;

			case REASON_RECOMPILE   : Print("Expert Advisor has been recompiled"); break;

			case REASON_CHARTCHANGE : Print("Symbol or chart period has been changed"); break;

			case REASON_CHARTCLOSE  : Print("Chart has been closed"); break;

			case REASON_PARAMETERS  : Print("Input parameters have been changed by a user"); break;

			case REASON_ACCOUNT     : Print("Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings"); break;

			case REASON_TEMPLATE    : Print("A new template has been applied"); break;

			case REASON_INITFAILED  : Print("OnInit() handler has returned a nonzero value"); break;

			case REASON_CLOSE       : Print("Terminal has been closed"); break;

		}

	}



	// delete dynamic pointers

	for (int i=0; i<ArraySize(_blocks_); i++)

	{

		delete _blocks_[i];

		_blocks_[i] = NULL;

	}

	ArrayResize(_blocks_, 0);



	return;

}



/************************************************************************************************************************/

// +------------------------------------------------------------------------------------------------------------------+ //

// |	                                         Classes of blocks                                                    | //

// |              Classes that contain the actual code of the blocks and their input parameters as well               | //

// +------------------------------------------------------------------------------------------------------------------+ //

/************************************************************************************************************************/



/**

	The base class for all block calls

   */

class BlockCalls

{

	public:

		bool __disabled; // whether or not the block is disabled



		string __block_user_number;

        int __block_number;

		int __block_waiting;

		int __parent_number;

		int __inbound_blocks[];

		int __outbound_blocks[];



		void __addInboundBlock(int id = 0) {

			int size = ArraySize(__inbound_blocks);

			for (int i = 0; i < size; i++) {

				if (__inbound_blocks[i] == id) {

					return;

				}

			}

			ArrayResize(__inbound_blocks, size + 1);

			__inbound_blocks[size] = id;

		}



		void BlockCalls() {

			__disabled          = false;

			__block_user_number = "";

			__block_number      = 0;

			__block_waiting     = 0;

			__parent_number     = 0;

		}



		/**

		   Announce this block to the list of inbound connections of all the blocks to which this block is connected to

		   */

		void __announceThisBlock()

		{

		   // add the current block number to the list of inbound blocks

		   // for each outbound block that is provided

			for (int i = 0; i < ArraySize(__outbound_blocks); i++)

			{

				int block = __outbound_blocks[i]; // outbound block number

				int size  = ArraySize(_blocks_[block].__inbound_blocks); // the size of its inbound list



				// skip if the current block was already added

				for (int j = 0; j < size; j++) {

					if (_blocks_[block].__inbound_blocks[j] == __block_number)

					{

						return;

					}

				}



				// add the current block number to the list of inbound blocks of the other block

				ArrayResize(_blocks_[block].__inbound_blocks, size + 1);

				_blocks_[block].__inbound_blocks[size] = __block_number;

			}

		}



		// this is here, because it is used in the "run" function

		virtual void _execute_() = 0;



		/**

			In the derived class this method should be used to set dynamic parameters or other stuff before the main execute.

			This method is automatically called within the main "run" method below, before the execution of the main class.

			*/

		virtual void _beforeExecute_() {return;};

		bool _beforeExecuteEnabled; // for speed



		/**

			Same as _beforeExecute_, but to work after the execute method.

			*/

		virtual void _afterExecute_() {return;};

		bool _afterExecuteEnabled; // for speed



		/**

			This is the method that is used to run the block

			*/

		virtual void run(int _parent_=0) {

			__parent_number = _parent_;

			if (__disabled || FXD_BREAK) {return;}

			FXD_CURRENT_FUNCTION_ID = __block_number;



			if (_beforeExecuteEnabled) {_beforeExecute_();}

			_execute_();

			if (_afterExecuteEnabled) {_afterExecute_();}



			if (__block_waiting && FXD_CURRENT_FUNCTION_ID == __block_number) {fxdWait.Accumulate(FXD_CURRENT_FUNCTION_ID);}

		}

};



BlockCalls *_blocks_[];





// "Condition" model

template<typename T1,typename _T1_,typename T2,typename T3,typename _T3_,typename T4>

class MDL_Condition: public BlockCalls

{

	public: /* Input Parameters */

	T1 Lo; virtual _T1_ _Lo_(){return(_T1_)0;}

	T2 compare;

	T3 Ro; virtual _T3_ _Ro_(){return(_T3_)0;}

	T4 crosswidth;

	virtual void _callback_(int r) {return;}



	public: /* Constructor */

	MDL_Condition()

	{

		compare = (string)">";

		crosswidth = (int)1;

	}



	public: /* The main method */

	virtual void _execute_()

	{

		bool output1 = false, output2 = false; // output 1 and output 2

		int crossover = 0;

		

		if (compare == "x>" || compare == "x<") {crossover = 1;}

		

		for (int i = 0; i <= crossover; i++)

		{

			// i=0 - normal pass, i=1 - crossover pass

		

			// Left operand of the condition

			FXD_MORE_SHIFT = i * crosswidth;

			_T1_ lo = _Lo_();

			if (MathAbs(lo) == EMPTY_VALUE) {return;}

		

			// Right operand of the condition

			FXD_MORE_SHIFT = i * crosswidth;

			_T3_ ro = _Ro_();

			if (MathAbs(ro) == EMPTY_VALUE) {return;}

		

			// Conditions

			if (CompareValues(compare, lo, ro))

			{

				if (i == 0)

				{

					output1 = true;

				}

			}

			else

			{

				if (i == 0)

				{

					output2 = true;

				}

				else

				{

					output2 = false;

				}

			}

		

			if (crossover == 1)

			{

				if (CompareValues(compare, ro, lo))

				{

					if (i == 0)

					{

						output2 = true;

					}

				}

				else

				{

					if (i == 1)

					{

						output1 = false;

					}

				}

			}

		}

		

		FXD_MORE_SHIFT = 0; // reset

		

			  if (output1 == true) {_callback_(1);}

		else if (output2 == true) {_callback_(0);}

	}

};



// "Once per bar" model

template<typename T1,typename T2,typename T3>

class MDL_OncePerBar: public BlockCalls

{

	public: /* Input Parameters */

	T1 Symbol;

	T2 Period;

	T3 PassMaxTimes;

	/* Static Parameters */

	string tokens[];

	int passes[];

	datetime old_values[];

	datetime time[];

	virtual void _callback_(int r) {return;}



	public: /* Constructor */

	MDL_OncePerBar()

	{

		Symbol = (string)CurrentSymbol();

		Period = (ENUM_TIMEFRAMES)CurrentTimeframe();

		PassMaxTimes = (int)1;

	}



	public: /* The main method */

	virtual void _execute_()

	{

		// this is static for speed reasons

		

		bool next    = false;

		string token = Symbol + IntegerToString(Period);

		int index    = ArraySearch(tokens, token);

		

		if (index == -1)

		{

			index = ArraySize(tokens);

			

			ArrayResize(tokens, index + 1);

			ArrayResize(old_values, index + 1);

			ArrayResize(passes, index + 1);

			

			tokens[index] = token;

			passes[index] = 0;

			old_values[index] = 0;

		}

		

		if (PassMaxTimes > 0)

		{

			CopyTime(Symbol, Period, 1, 1, time);

			datetime new_value = time[0];

		

			if (new_value > old_values[index])

			{

				passes[index]++;

		

				if (passes[index] >= PassMaxTimes)

				{

					old_values[index]  = new_value;

					passes[index] = 0;

				}

		

				next = true;

			}

		}

		

		if (next) {_callback_(1);} else {_callback_(0);}

	}

};



// "Draw Arrow" model

template<typename T1,typename T2,typename T3,typename T4,typename T5,typename T6,typename _T6_,typename T7,typename _T7_,typename T8,typename T9,typename T10,typename T11,typename T12,typename T13,typename T14,typename T15,typename T16,typename T17>

class MDL_ChartDrawArrow: public BlockCalls

{

	public: /* Input Parameters */

	T1 ObjectPerBar;

	T2 ObjectUpdate;

	T3 ObjName;

	T4 ObjectType;

	T5 ObjArrowCode;

	T6 ObjTime1; virtual _T6_ _ObjTime1_(){return(_T6_)0;}

	T7 ObjPrice1; virtual _T7_ _ObjPrice1_(){return(_T7_)0;}

	T8 ObjAnchor;

	T9 ObjColor;

	T10 ObjStyle;

	T11 ObjWidth;

	T12 ObjBack;

	T13 ObjSelectable;

	T14 ObjSelected;

	T15 ObjHidden;

	T16 ObjZorder;

	T17 ObjChartSubWindow;

	/* Static Parameters */

	int count;

	datetime time0;

	virtual void _callback_(int r) {return;}



	public: /* Constructor */

	MDL_ChartDrawArrow()

	{

		ObjectPerBar = (bool)true;

		ObjectUpdate = (bool)true;

		ObjName = (string)"";

		ObjectType = (ENUM_OBJECT)OBJ_ARROW_UP;

		ObjArrowCode = (int)58;

		ObjAnchor = (int)ANCHOR_TOP;

		ObjColor = (color)clrDeepPink;

		ObjStyle = (ENUM_LINE_STYLE)STYLE_SOLID;

		ObjWidth = (int)1;

		ObjBack = (bool)false;

		ObjSelectable = (bool)true;

		ObjSelected = (bool)false;

		ObjHidden = (bool)false;

		ObjZorder = (int)0;

		ObjChartSubWindow = (string)"";

		/* Static Parameters (initial value) */

		count =  0;

		time0 =  0;

	}



	public: /* The main method */

	virtual void _execute_()

	{

		string ObjNamePrefix = "fxd_arrow_";

		long ObjChartID      = 0;

		int subwindow_id     = WindowFindVisible(ObjChartID, ObjChartSubWindow);

		

		if (subwindow_id >= 0)

		{

			string name       = "";

			string name_base  = "";

			bool get_new_name = false;

			bool do_update    = true;

		

			if (ObjectPerBar == true)

			{

				datetime time = iTime(Symbol(),0,1);

		

				if (time0 < time)

				{

					time0        = time;

					get_new_name = true;

				}

				else

				{

					if (ObjectUpdate == false) {do_update = false;}

				}

			}

			else

			{

				if (ObjectUpdate == false) {get_new_name = true;}

			}

		

			if (do_update)

			{

				if (ObjName != "") {name_base = ObjName;} else {name_base = ObjNamePrefix + __block_user_number + "_";}

		

				if (get_new_name == false)

				{

					name = name_base + IntegerToString(count);

				}

				else

				{

					while (true)

					{

						count++;

						name = name_base + IntegerToString(count);

		

						if (ObjectFind(ObjChartID,name) < 0) {break;}

					}

				}

		

				if (ObjName != "" && count == 0) {name = ObjName;}

		

				if (ObjectFind(ObjChartID,name) < 0 && !ObjectCreate(ObjChartID,name,(ENUM_OBJECT)ObjectType,subwindow_id,0,0))

				{

					Print(__FUNCTION__,": failed to create arrow object! Error code = ",GetLastError());

				}

		

				if (ObjectType == OBJ_ARROW) ObjectSetInteger(ObjChartID,name,OBJPROP_ARROWCODE,ObjArrowCode);

		

				ObjectSetInteger(ObjChartID,name,OBJPROP_TIME,0,(long)_ObjTime1_());

				ObjectSetDouble(ObjChartID,name,OBJPROP_PRICE,0,(double)_ObjPrice1_());

				ObjectSetInteger(ObjChartID,name,OBJPROP_ANCHOR,ObjAnchor);

		

				ObjectSetInteger(ObjChartID,name,OBJPROP_STYLE,ObjStyle);

				ObjectSetInteger(ObjChartID,name,OBJPROP_COLOR,ObjColor);

				ObjectSetInteger(ObjChartID,name,OBJPROP_BACK,ObjBack);

				ObjectSetInteger(ObjChartID,name,OBJPROP_WIDTH,ObjWidth);

				ObjectSetInteger(ObjChartID,name,OBJPROP_SELECTABLE,ObjSelectable);

				ObjectSetInteger(ObjChartID,name,OBJPROP_SELECTED,ObjSelected);

				ObjectSetInteger(ObjChartID,name,OBJPROP_HIDDEN,ObjHidden);

				ObjectSetInteger(ObjChartID,name,OBJPROP_ZORDER,ObjZorder);

		

				ChartRedraw();

			}

		}

		

		_callback_(1);

	}

};





//------------------------------------------------------------------------------------------------------------------------



// "Moving Average" model

class MDLIC_indicators_iMA

{

	public: /* Input Parameters */

	int MAperiod;

	int MAshift;

	ENUM_MA_METHOD MAmethod;

	ENUM_APPLIED_PRICE AppliedPrice;

	string Symbol;

	ENUM_TIMEFRAMES Period;

	int Shift;

	virtual void _callback_(int r) {return;}



	public: /* Constructor */

	MDLIC_indicators_iMA()

	{

		MAperiod = (int)14;

		MAshift = (int)0;

		MAmethod = (ENUM_MA_METHOD)MODE_SMA;

		AppliedPrice = (ENUM_APPLIED_PRICE)PRICE_CLOSE;

		Symbol = (string)CurrentSymbol();

		Period = (ENUM_TIMEFRAMES)CurrentTimeframe();

		Shift = (int)0;

	}



	public: /* The main method */

	double _execute_()

	{

		return iMA(Symbol, Period, MAperiod, MAshift, MAmethod, AppliedPrice, Shift + FXD_MORE_SHIFT);

	}

};



// "Time" model

class MDLIC_value_time

{

	public: /* Input Parameters */

	int ModeTime;

	int TimeSource;

	string TimeStamp;

	int TimeCandleID;

	string TimeMarket;

	ENUM_TIMEFRAMES TimeCandleTimeframe;

	int TimeComponentYear;

	int TimeComponentMonth;

	double TimeComponentDay;

	double TimeComponentHour;

	double TimeComponentMinute;

	int TimeComponentSecond;

	int ModeTimeShift;

	int TimeShiftYears;

	int TimeShiftMonths;

	int TimeShiftWeeks;

	double TimeShiftDays;

	double TimeShiftHours;

	double TimeShiftMinutes;

	int TimeShiftSeconds;

	bool TimeSkipWeekdays;

	/* Static Parameters */

	datetime retval;

	datetime retval0;

	int ModeTime0;

	int smodeshift;

	int years0;

	int months0;

	datetime Time[];

	virtual void _callback_(int r) {return;}



	public: /* Constructor */

	MDLIC_value_time()

	{

		ModeTime = (int)0;

		TimeSource = (int)0;

		TimeStamp = (string)"00:00";

		TimeCandleID = (int)1;

		TimeMarket = (string)"";

		TimeCandleTimeframe = (ENUM_TIMEFRAMES)0;

		TimeComponentYear = (int)0;

		TimeComponentMonth = (int)0;

		TimeComponentDay = (double)0.0;

		TimeComponentHour = (double)12.0;

		TimeComponentMinute = (double)0.0;

		TimeComponentSecond = (int)0;

		ModeTimeShift = (int)0;

		TimeShiftYears = (int)0;

		TimeShiftMonths = (int)0;

		TimeShiftWeeks = (int)0;

		TimeShiftDays = (double)0.0;

		TimeShiftHours = (double)0.0;

		TimeShiftMinutes = (double)0.0;

		TimeShiftSeconds = (int)0;

		TimeSkipWeekdays = (bool)false;

		/* Static Parameters (initial value) */

		retval =  0;

		retval0 =  0;

		ModeTime0 =  0;

		smodeshift =  0;

		years0 =  0;

		months0 =  0;

	}



	public: /* The main method */

	datetime _execute_()

	{

		// this is static for speed reasons

		

		if (TimeMarket == "") TimeMarket = Symbol();

		

		if (ModeTime == 0)

		{

			     if (TimeSource == 0) {retval = TimeCurrent();}

			else if (TimeSource == 1) {retval = TimeLocal();}

			else if (TimeSource == 2) {retval = TimeGMT();}

		}

		else if (ModeTime == 1)

		{

			retval  = StringToTime(TimeStamp);

			retval0 = retval;

		}

		else if (ModeTime==2)

		{

			retval = TimeFromComponents(TimeSource, TimeComponentYear, TimeComponentMonth, TimeComponentDay, TimeComponentHour, TimeComponentMinute, TimeComponentSecond);

		}

		else if (ModeTime == 3)

		{

			ArraySetAsSeries(Time,true);

			CopyTime(TimeMarket,TimeCandleTimeframe,TimeCandleID,1,Time);

			retval = Time[0];

		}

		

		if (ModeTimeShift > 0)

		{

			int sh = 1;

		

			if (ModeTimeShift == 1) {sh = -1;}

		

			if (

				   ModeTimeShift != smodeshift

				|| TimeShiftYears != years0

				|| TimeShiftMonths != months0

			)

			{

				years0  = TimeShiftYears;

				months0 = TimeShiftMonths;

		

				if (TimeShiftYears > 0 || TimeShiftMonths > 0)

				{

					int year = 0, month = 0, week = 0, day = 0, hour = 0, minute = 0, second = 0;

		

					if (ModeTime == 3)

					{

						year   = TimeComponentYear;

						month  = TimeComponentYear;

						day    = (int)MathFloor(TimeComponentDay);

						hour   = (int)(MathFloor(TimeComponentHour) + (24 * (TimeComponentDay - MathFloor(TimeComponentDay))));

						minute = (int)(MathFloor(TimeComponentMinute) + (60 * (TimeComponentHour - MathFloor(TimeComponentHour))));

						second = (int)(TimeComponentSecond + (60 * (TimeComponentMinute - MathFloor(TimeComponentMinute))));

					}

					else {

						year   = TimeYear(retval);

						month  = TimeMonth(retval);

						day    = TimeDay(retval);

						hour   = TimeHour(retval);

						minute = TimeMinute(retval);

						second = TimeSeconds(retval);

					}

		

					year  = year + TimeShiftYears * sh;

					month = month + TimeShiftMonths * sh;

		

					     if (month < 0) {month = 12 - month;}

					else if (month > 12) {month = month - 12;}

		

					retval = StringToTime(IntegerToString(year)+"."+IntegerToString(month)+"."+IntegerToString(day)+" "+IntegerToString(hour)+":"+IntegerToString(minute)+":"+IntegerToString(second));

				}

			}

		

			retval = retval + (sh * ((604800 * TimeShiftWeeks) + SecondsFromComponents(TimeShiftDays, TimeShiftHours, TimeShiftMinutes, TimeShiftSeconds)));

		

			if (TimeSkipWeekdays == true)

			{

				int weekday = TimeDayOfWeek(retval);

		

				if (sh > 0) { // forward

					     if (weekday == 0) {retval = retval + 86400;}

					else if (weekday == 6) {retval = retval + 172800;}

				}

				else if (sh < 0) { // back

					     if (weekday == 0) {retval = retval - 172800;}

					else if (weekday == 6) {retval = retval - 86400;}

				}

			}

		}

		

		smodeshift = ModeTimeShift;

		ModeTime0  = ModeTime;

		

		return (datetime)retval;

	}

};



// "Candle" model

class MDLIC_candles_candles

{

	public: /* Input Parameters */

	string iOHLC;

	string ModeCandleFindBy;

	int CandleID;

	string TimeStamp;

	string Symbol;

	ENUM_TIMEFRAMES Period;

	virtual void _callback_(int r) {return;}



	public: /* Constructor */

	MDLIC_candles_candles()

	{

		iOHLC = (string)"iClose";

		ModeCandleFindBy = (string)"id";

		CandleID = (int)0;

		TimeStamp = (string)"00:00";

		Symbol = (string)CurrentSymbol();

		Period = (ENUM_TIMEFRAMES)CurrentTimeframe();

	}



	public: /* The main method */

	double _execute_()

	{

		int digits = (int)SymbolInfoInteger(Symbol, SYMBOL_DIGITS);

		

		double O[];

		double H[];

		double L[];

		double C[]; 

		long cTickVolume[];

		long cRealVolume[];

		datetime T[];

		

		double retval = EMPTY_VALUE;

		

		// candle's id will change, so we don't want to mess with the variable CandleID;

		int cID = CandleID;

		

		if (ModeCandleFindBy == "time")

		{

			cID = iCandleID(Symbol, Period, StringToTimeEx(TimeStamp, "server"));

		}

		

		cID = cID + FXD_MORE_SHIFT;

		

		//-- the common levels ----------------------------------------------------

		if (iOHLC == "iOpen")

		{

			if (CopyOpen(Symbol,Period,cID,1,O) > -1) retval = O[0];

		}

		else if (iOHLC == "iHigh")

		{

			if (CopyHigh(Symbol,Period,cID,1,H) > -1) retval = H[0];

		}

		else if (iOHLC == "iLow")

		{

			if (CopyLow(Symbol,Period,cID,1,L) > -1) retval = L[0];

		}

		else if (iOHLC == "iClose")

		{

			if (CopyClose(Symbol,Period,cID,1,C) > -1) retval = C[0];

		}

		

		//-- non-price values  ----------------------------------------------------

		else if (iOHLC == "iVolume" || iOHLC == "iTickVolume")

		{

			if (CopyTickVolume(Symbol,Period,cID,1,cTickVolume) > -1) retval = (double)cTickVolume[0];

			

			return retval;

		}

		else if (iOHLC == "iRealVolume")

		{

			if (CopyRealVolume(Symbol,Period,cID,1,cRealVolume) > -1) retval = (double)cRealVolume[0];

			

			return retval;

		}

		else if (iOHLC == "iTime")

		{

			if (CopyTime(Symbol,Period,cID,1,T) > -1) retval = (double)T[0];

			

			return retval;

		}

		

		//-- simple calculations --------------------------------------------------

		else if (iOHLC == "iMedian")

		{

			if (

				   CopyLow(Symbol,Period,cID,1,L) > -1

				&& CopyHigh(Symbol,Period,cID,1,H) > -1

			)

			{

				retval = ((L[0]+H[0])/2);

			}

		}

		else if (iOHLC == "iTypical")

		{

			if (

				   CopyLow(Symbol,Period,cID,1,L) > -1

				&& CopyHigh(Symbol,Period,cID,1,H) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

			)

			{

				retval = ((L[0]+H[0]+C[0])/3);

			}

		}

		else if (iOHLC == "iAverage")

		{

			if (

				   CopyLow(Symbol,Period,cID,1,L) > -1

				&& CopyHigh(Symbol,Period,cID,1,H) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

			)

			{

				retval = ((L[0]+H[0]+C[0]+C[0])/4);

			}

		}

		

		//-- more complex levels --------------------------------------------------

		else if (iOHLC=="iTotal")

		{

			if (

				   CopyHigh(Symbol,Period,cID,1,H) > -1

				&& CopyLow(Symbol,Period,cID,1,L) > -1

			)

			{

				retval = toPips(MathAbs(H[0]-L[0]),Symbol);

			}

		}

		else if (iOHLC == "iBody")

		{

			if (

				   CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

			)

			{

				retval = toPips(MathAbs(C[0]-O[0]),Symbol);

			}

		}

		else if (iOHLC == "iUpperWick")

		{

			if (

				   CopyHigh(Symbol,Period,cID,1,H) > -1

				&& CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

				&& CopyLow(Symbol,Period,cID,1,L) > -1

			)

			{

				retval = (C[0] > O[0]) ? toPips(MathAbs(H[0]-C[0]),Symbol) : toPips(MathAbs(H[0]-O[0]),Symbol);

			}

		}

		else if (iOHLC == "iBottomWick")

		{

			if (

				   CopyHigh(Symbol,Period,cID,1,H) > -1

				&& CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

				&& CopyLow(Symbol,Period,cID,1,L) > -1

			)

			{

				retval = (C[0] > O[0]) ? toPips(MathAbs(O[0]-L[0]),Symbol) : toPips(MathAbs(C[0]-L[0]),Symbol);

			}

		}

		else if (iOHLC == "iGap")

		{

			if (

				   CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID+1,1,C) > -1

			)

			{

				retval = toPips(MathAbs(O[0]-C[0]),Symbol);

			}

		}

		else if (iOHLC == "iBullTotal")

		{

			if (

				   CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

				&& CopyHigh(Symbol,Period,cID,1,H) > -1

				&& CopyLow(Symbol,Period,cID,1,L) > -1

				&& C[0] > O[0]

			)

			{

				retval = toPips((H[0]-L[0]),Symbol);

			}

		}

		else if (iOHLC == "iBullBody")

		{

			if (

				   CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

				&& C[0] > O[0]

			)

			{

				retval = toPips((C[0]-O[0]),Symbol);

			}

		}

		else if (iOHLC == "iBullUpperWick")

		{

			if (

				   CopyHigh(Symbol,Period,cID,1,H) > -1

				&& CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

				&& C[0] > O[0]

			)

			{

				retval = toPips((H[0]-C[0]),Symbol);

			}

		}

		else if (iOHLC == "iBullBottomWick")

		{

			if (

				   CopyLow(Symbol,Period,cID,1,L) > -1

				&& CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

				&& C[0] > O[0]

			)

			{

				retval = toPips((O[0]-L[0]),Symbol);

			}

		}

		else if (iOHLC == "iBearTotal")

		{

			if (

				   CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

				&& CopyHigh(Symbol,Period,cID,1,H) > -1

				&& CopyLow(Symbol,Period,cID,1,L) > -1

				&& C[0] < O[0]

			)

			{

				retval = toPips((H[0]-L[0]),Symbol);

			}

		}

		else if (iOHLC == "iBearBody")

		{

			if (

				   CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

				&& C[0] < O[0]

			)

			{

				retval = toPips((O[0]-C[0]),Symbol);

			}

		}

		else if (iOHLC == "iBearUpperWick")

		{

			if (

				   CopyHigh(Symbol,Period,cID,1,H) > -1

				&& CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

				&& C[0] < O[0]

			)

			{

				retval = toPips((H[0]-O[0]),Symbol);

			}

		}

		else if (iOHLC == "iBearBottomWick")

		{

			if (

				   CopyLow(Symbol,Period,cID,1,L) > -1

				&& CopyOpen(Symbol,Period,cID,1,O) > -1

				&& CopyClose(Symbol,Period,cID,1,C) > -1

				&& C[0] < O[0]

			)

			{

				retval = toPips((C[0]-L[0]),Symbol);

			}

		}

		

		return NormalizeDouble(retval, digits);

	}

};





//------------------------------------------------------------------------------------------------------------------------



// Block 1 (Crosses above)

class Block0: public MDL_Condition<MDLIC_indicators_iMA,double,string,MDLIC_indicators_iMA,double,int>

{



	public: /* Constructor */

	Block0() {

		__block_number = 0;

		__block_user_number = "1";





		// Fill the list of outbound blocks

		int ___outbound_blocks[1] = {1};

		ArrayCopy(__outbound_blocks, ___outbound_blocks);



		// IC input parameters

		Lo.MAperiod = 5;

		Ro.MAperiod = 20;

		// Block input parameters

		compare = "x>";

	}



	public: /* Custom methods */

	virtual double _Lo_() {

		Lo.MAmethod = MODE_SMA;

		Lo.AppliedPrice = PRICE_CLOSE;

		Lo.Symbol = CurrentSymbol();

		Lo.Period = CurrentTimeframe();



		return Lo._execute_();

	}

	virtual double _Ro_() {

		Ro.MAmethod = MODE_SMA;

		Ro.AppliedPrice = PRICE_CLOSE;

		Ro.Symbol = CurrentSymbol();

		Ro.Period = CurrentTimeframe();



		return Ro._execute_();

	}



	public: /* Callback & Run */

	virtual void _callback_(int value) {

		if (value == 1) {

			_blocks_[1].run(0);

		}

	}

};



// Block 2 (Once per bar)

class Block1: public MDL_OncePerBar<string,ENUM_TIMEFRAMES,int>

{



	public: /* Constructor */

	Block1() {

		__block_number = 1;

		__block_user_number = "2";

		_beforeExecuteEnabled = true;



		// Fill the list of outbound blocks

		int ___outbound_blocks[1] = {2};

		ArrayCopy(__outbound_blocks, ___outbound_blocks);

	}



	public: /* Callback & Run */

	virtual void _callback_(int value) {

		if (value == 1) {

			_blocks_[2].run(1);

		}

	}



	virtual void _beforeExecute_()

	{



		Symbol = (string)CurrentSymbol();

		Period = (ENUM_TIMEFRAMES)CurrentTimeframe();

	}

};



// Block 3 (Draw Arrow UP)

class Block2: public MDL_ChartDrawArrow<bool,bool,string,ENUM_OBJECT,int,MDLIC_value_time,datetime,MDLIC_candles_candles,double,int,color,ENUM_LINE_STYLE,int,bool,bool,bool,bool,int,string>

{



	public: /* Constructor */

	Block2() {

		__block_number = 2;

		__block_user_number = "3";

		_beforeExecuteEnabled = true;



		// IC input parameters

		ObjTime1.ModeTime = 3;

		ObjTime1.TimeCandleID = 0;

		ObjPrice1.iOHLC = "iHigh";

		ObjPrice1.TimeStamp = "";

		// Block input parameters

		ObjectUpdate = false;

	}



	public: /* Custom methods */

	virtual datetime _ObjTime1_() {return ObjTime1._execute_();}

	virtual double _ObjPrice1_() {

		ObjPrice1.Symbol = CurrentSymbol();

		ObjPrice1.Period = CurrentTimeframe();



		return ObjPrice1._execute_();

	}



	public: /* Callback & Run */

	virtual void _callback_(int value) {

	}



	virtual void _beforeExecute_()

	{



		ObjectType = (ENUM_OBJECT)OBJ_ARROW_UP;

		ObjAnchor = (int)ANCHOR_TOP;

		ObjColor = (color)clrDeepPink;

		ObjStyle = (ENUM_LINE_STYLE)STYLE_SOLID;

	}

};



// Block 4 (Crosses below)

class Block3: public MDL_Condition<MDLIC_indicators_iMA,double,string,MDLIC_indicators_iMA,double,int>

{



	public: /* Constructor */

	Block3() {

		__block_number = 3;

		__block_user_number = "4";





		// Fill the list of outbound blocks

		int ___outbound_blocks[1] = {4};

		ArrayCopy(__outbound_blocks, ___outbound_blocks);



		// IC input parameters

		Lo.MAperiod = 5;

		Ro.MAperiod = 20;

		// Block input parameters

		compare = "x<";

	}



	public: /* Custom methods */

	virtual double _Lo_() {

		Lo.MAmethod = MODE_SMA;

		Lo.AppliedPrice = PRICE_CLOSE;

		Lo.Symbol = CurrentSymbol();

		Lo.Period = CurrentTimeframe();



		return Lo._execute_();

	}

	virtual double _Ro_() {

		Ro.MAmethod = MODE_SMA;

		Ro.AppliedPrice = PRICE_CLOSE;

		Ro.Symbol = CurrentSymbol();

		Ro.Period = CurrentTimeframe();



		return Ro._execute_();

	}



	public: /* Callback & Run */

	virtual void _callback_(int value) {

		if (value == 1) {

			_blocks_[4].run(3);

		}

	}

};



// Block 5 (Once per bar)

class Block4: public MDL_OncePerBar<string,ENUM_TIMEFRAMES,int>

{



	public: /* Constructor */

	Block4() {

		__block_number = 4;

		__block_user_number = "5";

		_beforeExecuteEnabled = true;



		// Fill the list of outbound blocks

		int ___outbound_blocks[1] = {5};

		ArrayCopy(__outbound_blocks, ___outbound_blocks);

	}



	public: /* Callback & Run */

	virtual void _callback_(int value) {

		if (value == 1) {

			_blocks_[5].run(4);

		}

	}



	virtual void _beforeExecute_()

	{



		Symbol = (string)CurrentSymbol();

		Period = (ENUM_TIMEFRAMES)CurrentTimeframe();

	}

};



// Block 6 (Draw Arrow Down)

class Block5: public MDL_ChartDrawArrow<bool,bool,string,ENUM_OBJECT,int,MDLIC_value_time,datetime,MDLIC_candles_candles,double,int,color,ENUM_LINE_STYLE,int,bool,bool,bool,bool,int,string>

{



	public: /* Constructor */

	Block5() {

		__block_number = 5;

		__block_user_number = "6";

		_beforeExecuteEnabled = true;



		// IC input parameters

		ObjTime1.ModeTime = 3;

		ObjPrice1.iOHLC = "iLow";

		ObjPrice1.CandleID = 1;

		ObjPrice1.TimeStamp = "";

		// Block input parameters

		ObjectUpdate = false;

	}



	public: /* Custom methods */

	virtual datetime _ObjTime1_() {return ObjTime1._execute_();}

	virtual double _ObjPrice1_() {

		ObjPrice1.Symbol = CurrentSymbol();

		ObjPrice1.Period = CurrentTimeframe();



		return ObjPrice1._execute_();

	}



	public: /* Callback & Run */

	virtual void _callback_(int value) {

	}



	virtual void _beforeExecute_()

	{



		ObjectType = (ENUM_OBJECT)OBJ_ARROW_DOWN;

		ObjAnchor = (int)ANCHOR_TOP;

		ObjColor = (color)clrDeepPink;

		ObjStyle = (ENUM_LINE_STYLE)STYLE_SOLID;

	}

};





/************************************************************************************************************************/

// +------------------------------------------------------------------------------------------------------------------+ //

// |                                                   Functions                                                      | //

// |                                 System and Custom functions used in the program                                  | //

// +------------------------------------------------------------------------------------------------------------------+ //

/************************************************************************************************************************/





double AccountBalanceAtStart()

{

	// This function MUST be run once at pogram's start

	static double memory = 0;



	if (memory == 0)

	{

		memory = NormalizeDouble(AccountInfoDouble(ACCOUNT_BALANCE), 2);

	}



	return memory;

}



template<typename T>

int ArraySearch(T &array[], T value)

{

	int index = -1;

	int size  = ArraySize(array);



	for (int i = 0; i < size; i++)

	{

		if (array[i] == value)

		{

			index = i;

			break;

		}  

	}



   return index;

}



template<typename T>

bool ArrayStripKey(T &array[], int key)

{

	int x    = 0;

	int size = ArraySize(array);



	for (int i=0; i<size; i++)

	{

		if (i != key)

		{

			array[x] = array[i];

			x++;

		}

	}



	if (x < size)

	{

		ArrayResize(array, x);

		

		return true; // stripped

	}



	return false; // not stripped

}



int CheckForTradingError(int error_code=-1, string msg_prefix="")

{

   // return 0 -> no error

   // return 1 -> overcomable error

   // return 2 -> fatal error

   

   if (error_code<0) {

      error_code=GetLastError();  

   }

   

   int retval=0;

   static int tryouts=0;

   

   //-- error check -----------------------------------------------------

   switch(error_code)

   {

      //-- no error

      case 0:

         retval=0;

         break;

      //-- overcomable errors

      case 1: // No error returned

         RefreshRates();

         retval=1;

         break;

      case 4: //ERR_SERVER_BUSY

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Retrying.."));}

         Sleep(1000);

         RefreshRates();

         retval=1;

         break;

      case 6: //ERR_NO_CONNECTION

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Retrying.."));}

         while(!IsConnected()) {Sleep(100);}

         while(IsTradeContextBusy()) {Sleep(50);}

         RefreshRates();

         retval=1;

         break;

      case 128: //ERR_TRADE_TIMEOUT

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Retrying.."));}

         RefreshRates();

         retval=1;

         break;

      case 129: //ERR_INVALID_PRICE

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Retrying.."));}

         if (!IsTesting()) {while(RefreshRates()==false) {Sleep(1);}}

         retval=1;

         break;

      case 130: //ERR_INVALID_STOPS

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Waiting for a new tick to retry.."));}

         if (!IsTesting()) {while(RefreshRates()==false) {Sleep(1);}}

         retval=1;

         break;

      case 135: //ERR_PRICE_CHANGED

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Waiting for a new tick to retry.."));}

         if (!IsTesting()) {while(RefreshRates()==false) {Sleep(1);}}

         retval=1;

         break;

      case 136: //ERR_OFF_QUOTES

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Waiting for a new tick to retry.."));}

         if (!IsTesting()) {while(RefreshRates()==false) {Sleep(1);}}

         retval=1;

         break;

      case 137: //ERR_BROKER_BUSY

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Retrying.."));}

         Sleep(1000);

         retval=1;

         break;

      case 138: //ERR_REQUOTE

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Waiting for a new tick to retry.."));}

         if (!IsTesting()) {while(RefreshRates()==false) {Sleep(1);}}

         retval=1;

         break;

      case 142: //This code should be processed in the same way as error 128.

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Retrying.."));}

         RefreshRates();

         retval=1;

         break;

      case 143: //This code should be processed in the same way as error 128.

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Retrying.."));}

         RefreshRates();

         retval=1;

         break;

      /*case 145: //ERR_TRADE_MODIFY_DENIED

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Waiting for a new tick to retry.."));}

         while(RefreshRates()==false) {Sleep(1);}

         return(1);

      */

      case 146: //ERR_TRADE_CONTEXT_BUSY

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code),". Retrying.."));}

         while(IsTradeContextBusy()) {Sleep(50);}

         RefreshRates();

         retval=1;

         break;

      //-- critical errors

      default:

         if (msg_prefix!="") {Print(StringConcatenate(msg_prefix,": ",ErrorMessage(error_code)));}

         retval=2;

         break;

   }



   if (retval==0) {tryouts=0;}

   else if (retval==1) {

      tryouts++;

      if (tryouts>=10) {

         tryouts=0;

         retval=2;

      } else {

         Print("retry #"+(string)tryouts+" of 10");

      }

   }

   

   return(retval);

}



bool CloseTrade(ulong ticket, ulong slippage = 0, color arrowcolor = CLR_NONE)

{

	bool success = false;

	bool exists  = false;

	

	for (int i = 0; i < OrdersTotal(); i++)

	{

		if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;



		if (OrderTicket() == ticket)

		{

			exists = true;

			break;

		}

	}



	if (exists == false)

	{

		return false;

	}



	while (true)

	{

		//-- wait if needed -----------------------------------------------

		WaitTradeContextIfBusy();



		//-- close --------------------------------------------------------

		success = OrderClose((int)ticket, OrderLots(), OrderClosePrice(), (int)(slippage * PipValue(OrderSymbol())), arrowcolor);



		if (success == true)

		{

			if (USE_VIRTUAL_STOPS) {

				VirtualStopsDriver("clear", ticket);

			}



			expirationWorker.RemoveExpiration(ticket);



			OnTrade();



			return true;

		}



		//-- errors -------------------------------------------------------

		int erraction = CheckForTradingError(GetLastError(), "Closing trade #" + (string)ticket + " error");



		switch(erraction)

		{

			case 0: break;    // no error

			case 1: continue; // overcomable error

			case 2: break;    // fatal error

		}



		break;

	}



	return false;

}



template<typename DT1, typename DT2>

bool CompareValues(string sign, DT1 v1, DT2 v2)

{

	     if (sign == ">") return(v1 > v2);

	else if (sign == "<") return(v1 < v2);

	else if (sign == ">=") return(v1 >= v2);

	else if (sign == "<=") return(v1 <= v2);

	else if (sign == "==") return(v1 == v2);

	else if (sign == "!=") return(v1 != v2);

	else if (sign == "x>") return(v1 > v2);

	else if (sign == "x<") return(v1 < v2);



	return false;

}



string CurrentSymbol(string symbol = "")

{

   static string memory = "";



	// Set

   if (symbol != "")

	{

		memory = symbol;

	}

	// Get

	else if (memory == "")

	{

		memory = Symbol();

	}



   return memory;

}



ENUM_TIMEFRAMES CurrentTimeframe(ENUM_TIMEFRAMES timeframe = -1)

{

	static ENUM_TIMEFRAMES memory = 0;



   if (timeframe >= 0) {memory = timeframe;}



   return memory;

}



double CustomPoint(string symbol)

{

	static string symbols[];

	static double points[];

	static string last_symbol = "-";

	static double last_point  = 0;

	static int last_i         = 0;

	static int size           = 0;



	//-- variant A) use the cache for the last used symbol

	if (symbol == last_symbol)

	{

		return last_point;

	}



	//-- variant B) search in the array cache

	int i			= last_i;

	int start_i	= i;

	bool found	= false;



	if (size > 0)

	{

		while (true)

		{

			if (symbols[i] == symbol)

			{

				last_symbol	= symbol;

				last_point	= points[i];

				last_i		= i;



				return last_point;

			}



			i++;



			if (i >= size)

			{

				i = 0;

			}

			if (i == start_i) {break;}

		}

	}



	//-- variant C) add this symbol to the cache

	i		= size;

	size	= size + 1;



	ArrayResize(symbols, size);

	ArrayResize(points, size);



	symbols[i]	= symbol;

	points[i]	= 0;

	last_symbol	= symbol;

	last_i		= i;



	//-- unserialize rules from FXD_POINT_FORMAT_RULES

	string rules[];

	StringExplode(",", POINT_FORMAT_RULES, rules);



	int rules_count = ArraySize(rules);



	if (rules_count > 0)

	{

		string rule[];



		for (int r = 0; r < rules_count; r++)

		{

			StringExplode("=", rules[r], rule);



			//-- a single rule must contain 2 parts, [0] from and [1] to

			if (ArraySize(rule) != 2) {continue;}



			double from = StringToDouble(rule[0]);

			double to	= StringToDouble(rule[1]);



			//-- "to" must be a positive number, different than 0

			if (to <= 0) {continue;}



			//-- "from" can be a number or a string

			// a) string

			if (from == 0 && StringLen(rule[0]) > 0)

			{

				string s_from = rule[0];

				int pos       = StringFind(s_from, "?");



				if (pos < 0) // ? not found

				{

					if (StringFind(symbol, s_from) == 0) {points[i] = to;}

				}

				else if (pos == 0) // ? is the first symbol => match the second symbol

				{

					if (StringFind(symbol, StringSubstr(s_from, 1), 3) == 3)

					{

						points[i] = to;

					}

				}

				else if (pos > 0) // ? is the second symbol => match the first symbol

				{

					if (StringFind(symbol, StringSubstr(s_from, 0, pos)) == 0)

					{

						points[i] = to;

					}

				}

			}



			// b) number

			if (from == 0) {continue;}



			if (SymbolInfoDouble(symbol, SYMBOL_POINT) == from)

			{

				points[i] = to;

			}

		}

	}



	if (points[i] == 0)

	{

		points[i] = SymbolInfoDouble(symbol, SYMBOL_POINT);

	}



	last_point = points[i];



	return last_point;

}



bool DeleteOrder(int ticket, color arrowcolor=clrNONE)

{

   bool success=false;

   if (!OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES)) {return(false);}

   

   while(true)

   {

      //-- wait if needed -----------------------------------------------

      WaitTradeContextIfBusy();

      //-- delete -------------------------------------------------------

      success=OrderDelete(ticket,arrowcolor);

      if (success==true) {

         if (USE_VIRTUAL_STOPS) {

            VirtualStopsDriver("clear",ticket);

         }

         OnTrade();

         return(true);

      }

      //-- error check --------------------------------------------------

      int erraction=CheckForTradingError(GetLastError(), "Deleting order #"+(string)ticket+" error");

      switch(erraction)

      {

         case 0: break;    // no error

         case 1: continue; // overcomable error

         case 2: break;    // fatal error

      }

      break;

   }

   return(false);

}



void DrawSpreadInfo()

{

   static bool allow_draw = true;

   if (allow_draw==false) {return;}

   if (MQLInfoInteger(MQL_TESTER) && !MQLInfoInteger(MQL_VISUAL_MODE)) {allow_draw=false;} // Allowed to draw only once in testing mode



   static bool passed         = false;

   static double max_spread   = 0;

   static double min_spread   = EMPTY_VALUE;

   static double avg_spread   = 0;

   static double avg_add      = 0;

   static double avg_cnt      = 0;



   double custom_point = CustomPoint(Symbol());

   double current_spread = 0;

   if (custom_point > 0) {

      current_spread = (SymbolInfoDouble(Symbol(),SYMBOL_ASK)-SymbolInfoDouble(Symbol(),SYMBOL_BID))/custom_point;

   }

   if (current_spread > max_spread) {max_spread = current_spread;}

   if (current_spread < min_spread) {min_spread = current_spread;}

   

   avg_cnt++;

   avg_add     = avg_add + current_spread;

   avg_spread  = avg_add / avg_cnt;



   int x=0; int y=0;

   string name;



   // create objects

   if (passed == false)

   {

      passed=true;

      

      name="fxd_spread_current_label";

      if (ObjectFind(0, name)==-1) {

         ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);

         ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x+1);

         ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y+1);

         ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);

         ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 18);

         ObjectSetInteger(0, name, OBJPROP_COLOR, clrDarkOrange);

         ObjectSetString(0, name, OBJPROP_FONT, "Arial");

         ObjectSetString(0, name, OBJPROP_TEXT, "Spread:");

      }

      name="fxd_spread_max_label";

      if (ObjectFind(0, name)==-1) {

         ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);

         ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x+148);

         ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y+17);

         ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);

         ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 7);

         ObjectSetInteger(0, name, OBJPROP_COLOR, clrOrangeRed);

         ObjectSetString(0, name, OBJPROP_FONT, "Arial");

         ObjectSetString(0, name, OBJPROP_TEXT, "max:");

      }

      name="fxd_spread_avg_label";

      if (ObjectFind(0, name)==-1) {

         ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);

         ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x+148);

         ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y+9);

         ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);

         ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 7);

         ObjectSetInteger(0, name, OBJPROP_COLOR, clrDarkOrange);

         ObjectSetString(0, name, OBJPROP_FONT, "Arial");

         ObjectSetString(0, name, OBJPROP_TEXT, "avg:");

      }

      name="fxd_spread_min_label";

      if (ObjectFind(0, name)==-1) {

         ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);

         ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x+148);

         ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y+1);

         ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);

         ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 7);

         ObjectSetInteger(0, name, OBJPROP_COLOR, clrGold);

         ObjectSetString(0, name, OBJPROP_FONT, "Arial");

         ObjectSetString(0, name, OBJPROP_TEXT, "min:");

      }

      name="fxd_spread_current";

      if (ObjectFind(0, name)==-1) {

         ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);

         ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x+93);

         ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y+1);

         ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);

         ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 18);

         ObjectSetInteger(0, name, OBJPROP_COLOR, clrDarkOrange);

         ObjectSetString(0, name, OBJPROP_FONT, "Arial");

         ObjectSetString(0, name, OBJPROP_TEXT, "0");

      }

      name="fxd_spread_max";

      if (ObjectFind(0, name)==-1) {

         ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);

         ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x+173);

         ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y+17);

         ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);

         ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 7);

         ObjectSetInteger(0, name, OBJPROP_COLOR, clrOrangeRed);

         ObjectSetString(0, name, OBJPROP_FONT, "Arial");

         ObjectSetString(0, name, OBJPROP_TEXT, "0");

      }

      name="fxd_spread_avg";

      if (ObjectFind(0, name)==-1) {

         ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);

         ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x+173);

         ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y+9);

         ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);

         ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 7);

         ObjectSetInteger(0, name, OBJPROP_COLOR, clrDarkOrange);

         ObjectSetString(0, name, OBJPROP_FONT, "Arial");

         ObjectSetString(0, name, OBJPROP_TEXT, "0");

      }

      name="fxd_spread_min";

      if (ObjectFind(0, name)==-1) {

         ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);

         ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x+173);

         ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y+1);

         ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);

         ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);

         ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 7);

         ObjectSetInteger(0, name, OBJPROP_COLOR, clrGold);

         ObjectSetString(0, name, OBJPROP_FONT, "Arial");

         ObjectSetString(0, name, OBJPROP_TEXT, "0");

      }

   }

   

   ObjectSetString(0, "fxd_spread_current", OBJPROP_TEXT, DoubleToStr(current_spread,2));

   ObjectSetString(0, "fxd_spread_max", OBJPROP_TEXT, DoubleToStr(max_spread,2));

   ObjectSetString(0, "fxd_spread_avg", OBJPROP_TEXT, DoubleToStr(avg_spread,2));

   ObjectSetString(0, "fxd_spread_min", OBJPROP_TEXT, DoubleToStr(min_spread,2));

}



string DrawStatus(string text="")

{

   static string memory;

   if (text=="") {

      return(memory);

   }

   

   static bool passed = false;

   int x=210; int y=0;

   string name;



   //-- draw the objects once

   if (passed == false)

   {

      passed = true;

      name="fxd_status_title";

      ObjectCreate(0,name, OBJ_LABEL, 0, 0, 0);

      ObjectSetInteger(0,name, OBJPROP_BACK, false);

      ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);

      ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);

      ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);

      ObjectSetInteger(0,name, OBJPROP_XDISTANCE, x);

      ObjectSetInteger(0,name, OBJPROP_YDISTANCE, y+17);

      ObjectSetString(0,name, OBJPROP_TEXT, "Status");

      ObjectSetString(0,name, OBJPROP_FONT, "Arial");

      ObjectSetInteger(0,name, OBJPROP_FONTSIZE, 7);

      ObjectSetInteger(0,name, OBJPROP_COLOR, clrGray);

      

      name="fxd_status_text";

      ObjectCreate(0,name, OBJ_LABEL, 0, 0, 0);

      ObjectSetInteger(0,name, OBJPROP_BACK, false);

      ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_LOWER);

      ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);

      ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);

      ObjectSetInteger(0,name, OBJPROP_XDISTANCE, x+2);

      ObjectSetInteger(0,name, OBJPROP_YDISTANCE, y+1);

      ObjectSetString(0,name, OBJPROP_FONT, "Arial");

      ObjectSetInteger(0,name, OBJPROP_FONTSIZE, 12);

      ObjectSetInteger(0,name, OBJPROP_COLOR, clrAqua);

   }



   //-- update the text when needed

   if (text != memory) {

      memory=text;

      ObjectSetString(0,"fxd_status_text", OBJPROP_TEXT, text);

   }

   

   return(text);

}



string ErrorMessage(int error_code=-1)

{

	string e = "";

	

	if (error_code < 0) {error_code = GetLastError();}

	

	switch(error_code)

	{

		//-- codes returned from trade server

		case 0:	return("");

		case 1:	e = "No error returned"; break;

		case 2:	e = "Common error"; break;

		case 3:	e = "Invalid trade parameters"; break;

		case 4:	e = "Trade server is busy"; break;

		case 5:	e = "Old version of the client terminal"; break;

		case 6:	e = "No connection with trade server"; break;

		case 7:	e = "Not enough rights"; break;

		case 8:	e = "Too frequent requests"; break;

		case 9:	e = "Malfunctional trade operation (never returned error)"; break;

		case 64:  e = "Account disabled"; break;

		case 65:  e = "Invalid account"; break;

		case 128: e = "Trade timeout"; break;

		case 129: e = "Invalid price"; break;

		case 130: e = "Invalid Sl or TP"; break;

		case 131: e = "Invalid trade volume"; break;

		case 132: e = "Market is closed"; break;

		case 133: e = "Trade is disabled"; break;

		case 134: e = "Not enough money"; break;

		case 135: e = "Price changed"; break;

		case 136: e = "Off quotes"; break;

		case 137: e = "Broker is busy (never returned error)"; break;

		case 138: e = "Requote"; break;

		case 139: e = "Order is locked"; break;

		case 140: e = "Only long trades allowed"; break;

		case 141: e = "Too many requests"; break;

		case 145: e = "Modification denied because order too close to market"; break;

		case 146: e = "Trade context is busy"; break;

		case 147: e = "Expirations are denied by broker"; break;

		case 148: e = "Amount of open and pending orders has reached the limit"; break;

		case 149: e = "Hedging is prohibited"; break;

		case 150: e = "Prohibited by FIFO rules"; break;

		

		//-- mql4 errors

		case 4000: e = "No error"; break;

		case 4001: e = "Wrong function pointer"; break;

		case 4002: e = "Array index is out of range"; break;

		case 4003: e = "No memory for function call stack"; break;

		case 4004: e = "Recursive stack overflow"; break;

		case 4005: e = "Not enough stack for parameter"; break;

		case 4006: e = "No memory for parameter string"; break;

		case 4007: e = "No memory for temp string"; break;

		case 4008: e = "Not initialized string"; break;

		case 4009: e = "Not initialized string in array"; break;

		case 4010: e = "No memory for array string"; break;

		case 4011: e = "Too long string"; break;

		case 4012: e = "Remainder from zero divide"; break;

		case 4013: e = "Zero divide"; break;

		case 4014: e = "Unknown command"; break;

		case 4015: e = "Wrong jump"; break;

		case 4016: e = "Not initialized array"; break;

		case 4017: e = "dll calls are not allowed"; break;

		case 4018: e = "Cannot load library"; break;

		case 4019: e = "Cannot call function"; break;

		case 4020: e = "Expert function calls are not allowed"; break;

		case 4021: e = "Not enough memory for temp string returned from function"; break;

		case 4022: e = "System is busy"; break;

		case 4050: e = "Invalid function parameters count"; break;

		case 4051: e = "Invalid function parameter value"; break;

		case 4052: e = "String function internal error"; break;

		case 4053: e = "Some array error"; break;

		case 4054: e = "Incorrect series array using"; break;

		case 4055: e = "Custom indicator error"; break;

		case 4056: e = "Arrays are incompatible"; break;

		case 4057: e = "Global variables processing error"; break;

		case 4058: e = "Global variable not found"; break;

		case 4059: e = "Function is not allowed in testing mode"; break;

		case 4060: e = "Function is not confirmed"; break;

		case 4061: e = "Send mail error"; break;

		case 4062: e = "String parameter expected"; break;

		case 4063: e = "Integer parameter expected"; break;

		case 4064: e = "Double parameter expected"; break;

		case 4065: e = "Array as parameter expected"; break;

		case 4066: e = "Requested history data in update state"; break;

		case 4099: e = "End of file"; break;

		case 4100: e = "Some file error"; break;

		case 4101: e = "Wrong file name"; break;

		case 4102: e = "Too many opened files"; break;

		case 4103: e = "Cannot open file"; break;

		case 4104: e = "Incompatible access to a file"; break;

		case 4105: e = "No order selected"; break;

		case 4106: e = "Unknown symbol"; break;

		case 4107: e = "Invalid price parameter for trade function"; break;

		case 4108: e = "Invalid ticket"; break;

		case 4109: e = "Trade is not allowed in the expert properties"; break;

		case 4110: e = "Longs are not allowed in the expert properties"; break;

		case 4111: e = "Shorts are not allowed in the expert properties"; break;

		

		//-- objects errors

		case 4200: e = "Object is already exist"; break;

		case 4201: e = "Unknown object property"; break;

		case 4202: e = "Object is not exist"; break;

		case 4203: e = "Unknown object type"; break;

		case 4204: e = "No object name"; break;

		case 4205: e = "Object coordinates error"; break;

		case 4206: e = "No specified subwindow"; break;

		case 4207: e = "Graphical object error"; break;  

		case 4210: e = "Unknown chart property"; break;

		case 4211: e = "Chart not found"; break;

		case 4212: e = "Chart subwindow not found"; break;

		case 4213: e = "Chart indicator not found"; break;

		case 4220: e = "Symbol select error"; break;

		case 4250: e = "Notification error"; break;

		case 4251: e = "Notification parameter error"; break;

		case 4252: e = "Notifications disabled"; break;

		case 4253: e = "Notification send too frequent"; break;

		

		//-- ftp errors

		case 4260: e = "FTP server is not specified"; break;

		case 4261: e = "FTP login is not specified"; break;

		case 4262: e = "FTP connection failed"; break;

		case 4263: e = "FTP connection closed"; break;

		case 4264: e = "FTP path not found on server"; break;

		case 4265: e = "File not found in the MQL4\\Files directory to send on FTP server"; break;

		case 4266: e = "Common error during FTP data transmission"; break;

		

		//-- filesystem errors

		case 5001: e = "Too many opened files"; break;

		case 5002: e = "Wrong file name"; break;

		case 5003: e = "Too long file name"; break;

		case 5004: e = "Cannot open file"; break;

		case 5005: e = "Text file buffer allocation error"; break;

		case 5006: e = "Cannot delete file"; break;

		case 5007: e = "Invalid file handle (file closed or was not opened)"; break;

		case 5008: e = "Wrong file handle (handle index is out of handle table)"; break;

		case 5009: e = "File must be opened with FILE_WRITE flag"; break;

		case 5010: e = "File must be opened with FILE_READ flag"; break;

		case 5011: e = "File must be opened with FILE_BIN flag"; break;

		case 5012: e = "File must be opened with FILE_TXT flag"; break;

		case 5013: e = "File must be opened with FILE_TXT or FILE_CSV flag"; break;

		case 5014: e = "File must be opened with FILE_CSV flag"; break;

		case 5015: e = "File read error"; break;

		case 5016: e = "File write error"; break;

		case 5017: e = "String size must be specified for binary file"; break;

		case 5018: e = "Incompatible file (for string arrays-TXT, for others-BIN)"; break;

		case 5019: e = "File is directory, not file"; break;

		case 5020: e = "File does not exist"; break;

		case 5021: e = "File cannot be rewritten"; break;

		case 5022: e = "Wrong directory name"; break;

		case 5023: e = "Directory does not exist"; break;

		case 5024: e = "Specified file is not directory"; break;

		case 5025: e = "Cannot delete directory"; break;

		case 5026: e = "Cannot clean directory"; break;

		

		//-- other errors

		case 5027: e = "Array resize error"; break;

		case 5028: e = "String resize error"; break;

		case 5029: e = "Structure contains strings or dynamic arrays"; break;

		

		//-- http request

		case 5200: e = "Invalid URL"; break;

		case 5201: e = "Failed to connect to specified URL"; break;

		case 5202: e = "Timeout exceeded"; break;

		case 5203: e = "HTTP request failed"; break;



		default:	e = "Unknown error";

	}



	e = StringConcatenate(e, " (", error_code, ")");

	

	return e;

}



class ExpirationWorker

{

private:

	struct CachedItems

	{

		long ticket;

		datetime expiration;

	};



	CachedItems cachedItems[];

	long chartID;

	string chartObjectPrefix;

	string chartObjectSuffix;



	template<typename T>

	void ArrayClone(T &dest[], T &src[])

	{

		int size = ArraySize(src);

		ArrayResize(dest, size);



		for (int i = 0; i < size; i++)

		{

			dest[i] = src[i];

		}

	}



	void InitialDiscovery()

	{

		ArrayResize(cachedItems, 0);



		int total = OrdersTotal();



		for (int index = 0; index <= total; index++)

		{

			long ticket = GetTicketByIndex(index);



			if (ticket == 0) continue;



			datetime expiration = GetExpirationFromObject(ticket);



			if (expiration > 0)

			{

				SetExpirationInCache(ticket, expiration);

			}

		}

	}



	long GetTicketByIndex(int index)

	{

		long ticket = 0;



		if (OrderSelect(index, SELECT_BY_POS, MODE_TRADES))

		{

			if (OrderType() <= OP_SELL) ticket = (long)OrderTicket();

		}



		return ticket;

	}



	datetime GetExpirationFromObject(long ticket)

	{

		datetime expiration = (datetime)0;

		

		string objectName = chartObjectPrefix + IntegerToString(ticket) + chartObjectSuffix;



		if (ObjectFind(chartID, objectName) == chartID)

		{

			expiration = (datetime)ObjectGetInteger(chartID, objectName, OBJPROP_TIME);

		}



		return expiration;

	}



	bool RemoveExpirationObject(long ticket)

	{

		bool success      = false;

		string objectName = "";



		objectName = chartObjectPrefix + IntegerToString(ticket) + chartObjectSuffix;

		success    = ObjectDelete(chartID, objectName);



		return success;

	}



	void RemoveExpirationFromCache(long ticket)

	{

		int size = ArraySize(cachedItems);

		CachedItems newItems[];

		int newSize = 0;

		bool itemRemoved = false;



		for (int i = 0; i < size; i++)

		{

			if (cachedItems[i].ticket == ticket)

			{

				itemRemoved = true;

			}

			else

			{

				newSize++;

				ArrayResize(newItems, newSize);

				newItems[newSize - 1].ticket     = cachedItems[i].ticket;

				newItems[newSize - 1].expiration = cachedItems[i].expiration;

			}

		}



		if (itemRemoved) ArrayClone(cachedItems, newItems);

	}



	void SetExpirationInCache(long ticket, datetime expiration)

	{

		bool alreadyExists = false;

		int size           = ArraySize(cachedItems);



		for (int i = 0; i < size; i++)

		{

			if (cachedItems[i].ticket == ticket)

			{

				cachedItems[i].expiration = expiration;

				alreadyExists = true;

				break;

			}

		}



		if (alreadyExists == false)

		{

			ArrayResize(cachedItems, size + 1);

			cachedItems[size].ticket     = ticket;

			cachedItems[size].expiration = expiration;

		}

	}



	bool SetExpirationInObject(long ticket, datetime expiration)

	{

		if (!OrderSelect((int)ticket, SELECT_BY_TICKET)) return false;



		string objectName = chartObjectPrefix + IntegerToString(ticket) + chartObjectSuffix;

		double price      = OrderOpenPrice();



		if (ObjectFind(chartID, objectName) == chartID)

		{

			ObjectSetInteger(chartID, objectName, OBJPROP_TIME, expiration);

			ObjectSetDouble(chartID, objectName, OBJPROP_PRICE, price);

		}

		else

		{

			ObjectCreate(chartID, objectName, OBJ_ARROW, 0, expiration, price);

		}



		ObjectSetInteger(chartID, objectName, OBJPROP_ARROWCODE, 77);

		ObjectSetInteger(chartID, objectName, OBJPROP_HIDDEN, true);

		ObjectSetInteger(chartID, objectName, OBJPROP_ANCHOR, ANCHOR_TOP);

		ObjectSetInteger(chartID, objectName, OBJPROP_COLOR, clrRed);

		ObjectSetInteger(chartID, objectName, OBJPROP_SELECTABLE, false);

		ObjectSetInteger(chartID, objectName, OBJPROP_TIMEFRAMES, OBJ_NO_PERIODS);

		ObjectSetString(chartID, objectName, OBJPROP_TEXT, TimeToString(expiration));



		return true;

	}

	

	bool TradeExists(long ticket)

	{

		bool exists  = false;



		for (int i = 0; i < OrdersTotal(); i++)

		{

			if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;



			if (OrderTicket() == ticket)

			{

				exists = true;

				break;

			}

		}



		return exists;

	}



public:

	// Default constructor

	ExpirationWorker()

	{

		chartID           = 0;

		chartObjectPrefix = "#";

		chartObjectSuffix = " Expiration Marker";



		InitialDiscovery();

	}



	void SetExpiration(long ticket, datetime expiration)

	{

		if (expiration <= 0)

		{

			RemoveExpiration(ticket);

		}

		else

		{

			SetExpirationInObject(ticket, expiration);

			SetExpirationInCache(ticket, expiration);

		}

	}



	datetime GetExpiration(long ticket)

	{

		datetime expiration = (datetime)0;

		int size            = ArraySize(cachedItems);



		for (int i = 0; i < size; i++)

		{

			if (cachedItems[i].ticket == ticket)

			{

				expiration = cachedItems[i].expiration;

				break;

			}

		}



		return expiration;

	}



	void RemoveExpiration(long ticket)

	{

		RemoveExpirationObject(ticket);

		RemoveExpirationFromCache(ticket);

	}



	void Run()

	{

		int count = ArraySize(cachedItems);



		if (count > 0)

		{

			datetime timeNow = TimeCurrent();



			for (int i = 0; i < count; i++)

			{

				if (timeNow >= cachedItems[i].expiration)

				{

					long ticket           = cachedItems[i].ticket;

					bool removeExpiration = false;



					if (TradeExists(ticket))

					{

						if (CloseTrade(ticket))

						{

							Print("close #", ticket, " by expiration");

							removeExpiration = true;

						}

					}

					else

					{

						removeExpiration = true;

					}



					if (removeExpiration)

					{

						RemoveExpiration(ticket);



						// Removing expiration causes change in the size of the cache,

						// so reset of the size and one step back of the index is needed

						count = ArraySize(cachedItems);

						i--;

					}

				}

			}

		}

	}

};



ExpirationWorker expirationWorker;



int OCODriver()

{

	static int last_known_ticket = 0;

   static int orders1[];

   static int orders2[];

   int i, size;

   

   int total = OrdersTotal();

   

   for (int pos=total-1; pos>=0; pos--)

   {

      if (OrderSelect(pos,SELECT_BY_POS,MODE_TRADES))

      {

         int ticket = OrderTicket();

         

         //-- end here if we reach the last known ticket

         if (ticket == last_known_ticket) {break;}

         

         //-- set the last known ticket, only if this is the first iteration

         if (pos == total-1) {

            last_known_ticket = ticket;

         }

         

         //-- we are searching for pending orders, skip trades

         if (OrderType() <= OP_SELL) {continue;}

         

         //--

         if (StringSubstr(OrderComment(), 0, 5) == "[oco:")

         {

            int ticket_oco = StrToInteger(StringSubstr(OrderComment(), 5, StringLen(OrderComment())-1)); 

            

            bool found = false;

            size = ArraySize(orders2);

            for (i=0; i<size; i++)

            {

               if (orders2[i] == ticket_oco) {

                  found = true;

                  break;

               }

            }

            

            if (found == false) {

               ArrayResize(orders1, size+1);

               ArrayResize(orders2, size+1);

               orders1[size] = ticket_oco;

               orders2[size] = ticket;

            }

         }

      }

   }

   

   size = ArraySize(orders1);

   int dbremove = false;

   for (i=size-1; i>=0; i--)

   {

      if (OrderSelect(orders1[i], SELECT_BY_TICKET, MODE_TRADES) == false || OrderType() <= OP_SELL)

      {

         if (OrderSelect(orders2[i], SELECT_BY_TICKET, MODE_TRADES)) {

            if (DeleteOrder(orders2[i],clrWhite))

            {

               dbremove = true;

            }

         }

         else {

            dbremove = true;

         }

         

         if (dbremove == true)

         {

            ArrayStripKey(orders1, i);

            ArrayStripKey(orders2, i);

         }

      }

   }

   

   size = ArraySize(orders2);

   dbremove = false;

   for (i=size-1; i>=0; i--)

   {

      if (OrderSelect(orders2[i], SELECT_BY_TICKET, MODE_TRADES) == false || OrderType() <= OP_SELL)

      {

         if (OrderSelect(orders1[i], SELECT_BY_TICKET, MODE_TRADES)) {

            if (DeleteOrder(orders1[i],clrWhite))

            {

               dbremove = true;

            }

         }

         else {

            dbremove = true;

         }

         

         if (dbremove == true)

         {

            ArrayStripKey(orders1, i);

            ArrayStripKey(orders2, i);

         }

      }

   }

   

   return true;

}



bool OnTimerSet(double seconds)

{

   if (FXD_ONTIMER_TAKEN)

   {

      if (seconds<=0) {

         FXD_ONTIMER_TAKEN_IN_MILLISECONDS = false;

         FXD_ONTIMER_TAKEN_TIME = 0;

      }

      else if (seconds < 1) {

         FXD_ONTIMER_TAKEN_IN_MILLISECONDS = true;

         FXD_ONTIMER_TAKEN_TIME = seconds*1000; 

      }

      else {

         FXD_ONTIMER_TAKEN_IN_MILLISECONDS = false;

         FXD_ONTIMER_TAKEN_TIME = seconds;

      }

      

      return true;

   }



   if (seconds<=0) {

      EventKillTimer();

   }

   else if (seconds < 1) {

      return (EventSetMillisecondTimer((int)(seconds*1000)));  

   }

   else {

      return (EventSetTimer((int)seconds));

   }

   

   return true;

}



class OnTradeEventDetector

{

private:

	//--- structures

	struct EventValues

	{

		// special fields

		string   reason,

		         detail;



		// order related fields

		long     magic,

		         ticket;

		int      type;

		datetime timeClose,

		         timeOpen,

		         timeExpiration;

		double   commission,

		         priceOpen,

		         priceClose,

		         profit,

		         stopLoss,

		         swap,

		         takeProfit,

		         volume;

		string   comment,

		         symbol;

	};

	

	struct Position

	{

		int type;

		long     magic,

		         ticket;

		datetime timeClose,

		         timeExpiration,

		         timeOpen;

		double   commission,

		         priceCurrent,

		         priceOpen,

		         profit,

		         stopLoss,

		         swap,

		         takeProfit,

		         volume;

		string   comment,

		         symbol;

	};



	struct PendingOrder

	{

		int type;

		long     magic,

		         ticket;

		datetime timeClose,

		         timeExpiration,

		         timeOpen;

		double   priceCurrent,

		         priceOpen,

		         stopLoss,

		         takeProfit,

		         volume;

		string   comment,

		         symbol;

	};

	

	struct PositionExpirationTimes

	{

		long ticket;

		datetime timeExpiration;

	};

	

	//--- variables and arrays

	bool debug;



	int eventValuesQueueIndex;

	EventValues eventValues[];



	PendingOrder previousPendingOrders[];

	PendingOrder pendingOrders[];



	Position previousPositions[];

	Position positions[];



	PositionExpirationTimes positionExpirationTimes[];



	//--- methods

	

	/**

	* Like ArrayCopy(), but for any type.

	*/

	template<typename T>

	void CopyList(T &dest[], T &src[])

	{

		int size = ArraySize(src);

		ArrayResize(dest, size);



		for (int i = 0; i < size; i++)

		{

			dest[i] = src[i];

		}

	}



	/**

	* Overloaded method 1 of 2

	*/

	int MakeListOf(PendingOrder &list[])

	{

		ArrayResize(list, 0);



		int count        = OrdersTotal();

		int howManyAdded = 0;



		for (int index = 0; index < count; index++)

		{

			if (OrderSelect(index, SELECT_BY_POS) == false) continue;

			if (OrderType() < OP_BUYLIMIT) continue;



			howManyAdded++;

			ArrayResize(list, howManyAdded);

			int i = howManyAdded - 1;



			// int

			list[i].type   = OrderType();

			list[i].magic  = OrderMagicNumber();

			list[i].ticket = OrderTicket();



			// datetime

			list[i].timeClose      = OrderCloseTime();

			list[i].timeExpiration = OrderExpiration();

			list[i].timeOpen       = OrderOpenTime();



			// double

			list[i].priceCurrent = OrderClosePrice();

			list[i].priceOpen    = OrderOpenPrice();

			list[i].stopLoss     = OrderStopLoss();

			list[i].takeProfit   = OrderTakeProfit();

			list[i].volume       = OrderLots();



			// string

			list[i].comment = OrderComment();

			list[i].symbol  = OrderSymbol();

		}



		return howManyAdded;

	}



	/**

	* Overloaded method 2 of 2

	*/

	int MakeListOf(Position &list[])

	{

		ArrayResize(list, 0);



		int count        = OrdersTotal();

		int howManyAdded = 0;



		for (int index = 0; index < count; index++)

		{

			if (OrderSelect(index, SELECT_BY_POS) == false) continue;

			if (OrderType() > OP_SELL) continue;



			howManyAdded++;

			ArrayResize(list, howManyAdded);

			int i = howManyAdded - 1;



			// int

			list[i].type   = OrderType();

			list[i].magic  = OrderMagicNumber();

			list[i].ticket = OrderTicket();



			// datetime

			list[i].timeClose      = OrderCloseTime();

			list[i].timeExpiration = (datetime)0;

			list[i].timeOpen       = OrderOpenTime();



			// double

			list[i].commission   = OrderCommission();

			list[i].priceCurrent = OrderClosePrice();

			list[i].priceOpen    = OrderOpenPrice();

			list[i].profit       = OrderProfit();

			list[i].stopLoss     = OrderStopLoss();

			list[i].swap         = OrderSwap();

			list[i].takeProfit   = OrderTakeProfit();

			list[i].volume       = OrderLots();



			// string

			list[i].comment = OrderComment();

			list[i].symbol  = OrderSymbol();

			

			// extract expiration

			list[i].timeExpiration = expirationWorker.GetExpiration(list[i].ticket);



			if (USE_VIRTUAL_STOPS)

			{

				list[i].stopLoss   = VirtualStopsDriver("get sl", list[i].ticket);

				list[i].takeProfit = VirtualStopsDriver("get tp", list[i].ticket);

			}

		}



		return howManyAdded;

	}



	/**

	* This method loops through 2 lists of items and finds a difference. This difference is the event.

	* "Items" are either pending orders or positions.

	*

	* Returns true if an event is detected or false if not.

	*/

	template<typename ITEMS_TYPE> 

	bool DetectEvent(ITEMS_TYPE &previousItems[], ITEMS_TYPE &currentItems[])

	{

		ITEMS_TYPE item;

		string reason   = "";

		string detail   = "";

		int countBefore = ArraySize(previousItems);

		int countNow    = ArraySize(currentItems);



		// New

		if (countBefore < countNow)

		{

			item   = currentItems[countNow - 1];

			reason = "new";

		}

		// Gone

		else if (countBefore > countNow)

		{

			item   = FindMissingItem(previousItems, currentItems);

			reason = "close";

		}

		// Same => check for modifications

		else if (countBefore == countNow && countNow > 0)

		{

			int count = ArraySize(currentItems);



			for (int index = 0; index < count; index++)

			{

				item = currentItems[index];

				ITEMS_TYPE previous = previousItems[index];

				ITEMS_TYPE current  = currentItems[index];



				if (previous.ticket != current.ticket)

				{

					// The order changes when a trade is closed partially - the original ticket is gone ane a new one is created at the end

					// That's why we are gonna check whether the parent of the last trade is the same as the previous trade

					current = currentItems[count - 1];



					if (previous.ticket == attrTicketParent(current.ticket))

					{

						item = current;

						reason = "decrement";

					}

					else

					{

						Print("Positions order mismatch");

					}



					break;

				}



				if (previous.volume != current.volume)

				{

					// Volume increment

					if (previous.volume < current.volume)

					{

						reason = "increment";



						break;

					}

					// Volume decrement

					else

					{

						reason = "decrement";



						break;

					}

				}



				// SL & TP modified

				if (

					   previous.stopLoss != current.stopLoss

					&& previous.takeProfit != current.takeProfit

				) {

					reason = "modify";

					detail = "sltp";



					break;

				}

				// SL modified

				else if (previous.stopLoss != current.stopLoss)

				{

					reason = "modify";

					detail = "sl";



					break;

				}

				// TP modified

				else if (previous.takeProfit != current.takeProfit)

				{

					reason = "modify";

					detail = "tp";



					break;

				}

				

				if (previous.timeExpiration != current.timeExpiration)

				{

					reason = "modify";

					detail = "expiration";



					break;

				}

			}

		}



		if (reason == "")

		{

			return false;

		}



		UpdateValues(item, reason, detail);



		return true;

	}

	

	/**

	* From the list of previous orders or positions, find the item that is missing

	* in the list of current orders or positions.

	*

	* Return the ticket number or 0 if nothing is found.

	*/

	template<typename T> 

	T FindMissingItem(T &previous[], T &current[])

	{

		int previousCount = ArraySize(previous);

		int currentCount  = ArraySize(current);

		T item;



		long ticket = 0;



		for (int i = 0; i < previousCount; i++)

		{

			bool found = false;



			for (int j = 0; j < currentCount; j++)

			{

				if (previous[i].ticket == current[j].ticket)

				{

					found = true;

					break;

				}

			}



			if (found == false)

			{

				item = previous[i];

				break;

			}

		}



		return item;

	}

	

	/**

	* Overloaded method 1 of 2

	*/

	void UpdateValues(Position &item, string reason, string detail)

	{

		long ticket        = item.ticket;

		datetime timeOpen  = item.timeOpen;

		datetime timeClose = item.timeClose;

		double priceOpen   = item.priceOpen;

		double priceClose  = item.priceCurrent;

		double profit      = item.profit;

		double swap        = item.swap;

		double commission  = item.commission;

		double volume      = item.volume;



		if (reason == "close" || reason == "decrement")

		{

			if (OrderSelect((int)ticket, SELECT_BY_TICKET, MODE_HISTORY))

			{

				timeOpen   = OrderOpenTime();

				timeClose  = OrderCloseTime();

				priceOpen  = OrderOpenPrice();

				priceClose = OrderClosePrice();

				profit     = OrderProfit();

				swap       = OrderSwap();

				commission = OrderCommission();

				volume     = OrderLots();



				if (detail == "")

				{

					if (

						item.timeExpiration > 0

						&& item.timeExpiration <= timeClose

					) {

						detail = "expiration";

					}

				}



				if (detail == "")

				{

					string comment = OrderComment();



					// Try with comments, which works in the Tester, but it could not work in real

					     if (comment == "[tp]") detail = "tp";

					else if (comment == "[sl]") detail = "sl";



					// Try to detect close by SL or TP by the close price

					if (detail == "")

					{

						int type = item.type;



						double sl = OrderStopLoss();

						double tp = OrderTakeProfit();



						if (type == 0) // BUY

						{

							     if (sl > 0 && priceClose <= sl) detail = "sl";

							else if (tp > 0 && priceClose >= tp) detail = "tp";

						}

						else if (type == 1) // SELL

						{

							     if (sl > 0 && priceClose >= sl) detail = "sl";

							else if (tp > 0 && priceClose <= tp) detail = "tp";

						}

					}

				}

			}

		}



		int i = eventValuesQueueIndex;



		eventValues[i].reason = reason;

		eventValues[i].detail = detail;

 

		eventValues[i].priceClose     = priceClose;

		eventValues[i].timeClose      = timeClose;

		eventValues[i].comment        = item.comment;

		eventValues[i].commission     = commission;

		eventValues[i].timeExpiration = item.timeExpiration;

		eventValues[i].volume         = volume;

		eventValues[i].magic          = item.magic;

		eventValues[i].priceOpen      = priceOpen;

		eventValues[i].timeOpen       = timeOpen;

		eventValues[i].profit         = profit;

		eventValues[i].stopLoss       = item.stopLoss;

		eventValues[i].swap           = swap;

		eventValues[i].symbol         = item.symbol;

		eventValues[i].takeProfit     = item.takeProfit;

		eventValues[i].ticket         = ticket;

		eventValues[i].type           = item.type;



		if (debug)

		{

			PrintUpdatedValues();

		}

	}

	

	/**

	* Overloaded method 2 of 2

	*/

	void UpdateValues(PendingOrder &item, string reason, string detail)

	{

		int i = eventValuesQueueIndex;



		eventValues[i].reason = reason;

		eventValues[i].detail = detail;



		eventValues[i].priceClose     = item.priceCurrent;

		eventValues[i].timeClose      = item.timeClose;

		eventValues[i].comment        = item.comment;

		eventValues[i].commission     = 0.0;

		eventValues[i].timeExpiration = item.timeExpiration;

		eventValues[i].volume         = item.volume;

		eventValues[i].magic          = item.magic;

		eventValues[i].priceOpen      = item.priceOpen;

		eventValues[i].timeOpen       = item.timeOpen;

		eventValues[i].profit         = 0.0;

		eventValues[i].stopLoss       = item.stopLoss;

		eventValues[i].swap           = 0.0;

		eventValues[i].symbol         = item.symbol;

		eventValues[i].takeProfit     = item.takeProfit;

		eventValues[i].ticket         = item.ticket;

		eventValues[i].type           = item.type;



		if (debug)

		{

			PrintUpdatedValues();

		}

	}



	void PrintUpdatedValues()

	{

		Print(

			" <<<"

		);

		

		Print(

			" | reason: ", e_Reason(),

			" | detail: ", e_ReasonDetail(),

			" | ticket: ", e_attrTicket(),

			" | type: ", EnumToString((ENUM_ORDER_TYPE)e_attrType())

		);

		

		Print(

			" | openTime : ", e_attrOpenTime(),

			" | openPrice : ", e_attrOpenPrice()

		);

		

		Print(

			" | closeTime: ", e_attrCloseTime(),

			" | closePrice: ", e_attrClosePrice()

		);

		

		Print(

			" | volume: ", e_attrLots(),

			" | sl: ", e_attrStopLoss(),

			" | tp: ", e_attrTakeProfit(),

			" | profit: ", e_attrProfit(),

			" | swap: ", e_attrSwap(),

			" | exp: ", e_attrExpiration(),

			" | comment: ", e_attrComment()

		);

		

		Print(

			">>>"

		);

	}



	int AddEventValues()

	{

		eventValuesQueueIndex++;

		ArrayResize(eventValues, eventValuesQueueIndex + 1);



		return eventValuesQueueIndex;

	}



	int RemoveEventValues()

	{

		if (eventValuesQueueIndex == -1)

		{

			Print("Cannot remove event values, add them first. (in function ", __FUNCTION__, ")");

		}

		else

		{

			eventValuesQueueIndex--;

			ArrayResize(eventValues, eventValuesQueueIndex + 1);

		}



		return eventValuesQueueIndex;

	}



public:

	/**

	* Default constructor

	*/

	OnTradeEventDetector(void)

	{

		debug = false;

		eventValuesQueueIndex = -1;

	};



	bool Start()

	{

		AddEventValues();



		MakeListOf(positions);

		MakeListOf(pendingOrders);



		bool success = false;



		if (!success) success = DetectEvent(previousPositions, positions);



		if (!success) success = DetectEvent(previousPendingOrders, pendingOrders);



		CopyList(previousPositions, positions);

		CopyList(previousPendingOrders, pendingOrders);



		return success;

	}



	void End()

	{

		RemoveEventValues();

	}



	string EventValueReason() {return eventValues[eventValuesQueueIndex].reason;}

	string EventValueDetail() {return eventValues[eventValuesQueueIndex].detail;}



	int EventValueType() {return eventValues[eventValuesQueueIndex].type;}



	datetime EventValueTimeClose()      {return eventValues[eventValuesQueueIndex].timeClose;}

	datetime EventValueTimeOpen()       {return eventValues[eventValuesQueueIndex].timeOpen;}

	datetime EventValueTimeExpiration() {return eventValues[eventValuesQueueIndex].timeExpiration;}



	long EventValueMagic()  {return eventValues[eventValuesQueueIndex].magic;}

	long EventValueTicket() {return eventValues[eventValuesQueueIndex].ticket;}



	double EventValueCommission() {return eventValues[eventValuesQueueIndex].commission;}

	double EventValuePriceOpen()  {return eventValues[eventValuesQueueIndex].priceOpen;}

	double EventValuePriceClose() {return eventValues[eventValuesQueueIndex].priceClose;}

	double EventValueProfit()     {return eventValues[eventValuesQueueIndex].profit;}

	double EventValueStopLoss()   {return eventValues[eventValuesQueueIndex].stopLoss;}

	double EventValueSwap()       {return eventValues[eventValuesQueueIndex].swap;}

	double EventValueTakeProfit() {return eventValues[eventValuesQueueIndex].takeProfit;}

	double EventValueVolume()     {return eventValues[eventValuesQueueIndex].volume;}



	string EventValueComment() {return eventValues[eventValuesQueueIndex].comment;}

	string EventValueSymbol()  {return eventValues[eventValuesQueueIndex].symbol;}

};



OnTradeEventDetector onTradeEventDetector;



/**

* This is a replacement for the system function.

* The difference is that this can also get the expiration for trades.

*/

datetime OrderExpiration(bool check_trade)

{

	datetime expiration = (datetime)0;



	if (OrderType() > OP_SELL)

	{

		expiration = OrderExpiration();

	}

	else if (check_trade)

	{

		expiration = (datetime)expirationWorker.GetExpiration(OrderTicket());

	}



	return expiration;

}



bool PendingOrderSelectByTicket(ulong ticket)

{

	if (OrderSelect((int)ticket, SELECT_BY_TICKET, MODE_TRADES) && OrderType() > 1)

	{

		return true;

	}



	return false;

}



double PipValue(string symbol)

{

	if (symbol == "") symbol = Symbol();



	return CustomPoint(symbol) / SymbolInfoDouble(symbol, SYMBOL_POINT);

}



int SecondsFromComponents(double days, double hours, double minutes, int seconds)

{

	int retval =

		86400 * (int)MathFloor(days)

		+ 3600 * (int)(MathFloor(hours) + (24 * (days - MathFloor(days))))

		+ 60 * (int)(MathFloor(minutes) + (60 * (hours - MathFloor(hours))))

		+ (int)((double)seconds + (60 * (minutes - MathFloor(minutes))));



	return retval;

}



template<typename T>

void StringExplode(string delimiter, string inputString, T &output[])

{

	int begin   = 0;

	int end     = 0;

	int element = 0;

	int length  = StringLen(inputString);

	int length_delimiter = StringLen(delimiter);

	T empty_val  = (typename(T) == "string") ? (T)"" : (T)0;



	if (length > 0)

	{

		while (true)

		{

			end = StringFind(inputString, delimiter, begin);



			ArrayResize(output, element + 1);

			output[element] = empty_val;

	

			if (end != -1)

			{

				if (end > begin)

				{

					output[element] = (T)StringSubstr(inputString, begin, end - begin);

				}

			}

			else

			{

				output[element] = (T)StringSubstr(inputString, begin, length - begin);

				break;

			}

			

			begin = end + 1 + (length_delimiter - 1);

			element++;

		}

	}

	else

	{

		ArrayResize(output, 1);

		output[element] = empty_val;

	}

}



datetime StringToTimeEx(string str, string mode="server")

{

	// mode: server, local, gmt

	if (StringFind(str, " ") != -1) {

	   return StringToTime(str);

	}

	

	datetime now = 0;

	datetime retval = 0;

	

	if (mode == "server") {now = TimeCurrent();}

	else if (mode == "local") {now = TimeLocal();}

	else if (mode == "gmt") {now = TimeGMT();}

	

	return StringToTime((string)TimeYear(now)+"."+(string)TimeMonth(now)+"."+(string)TimeDay(now)+" "+str);

}



double TicksData(string symbol = "", int type = 0, int shift = 0)

{

	static bool collecting_ticks = false;

	static string symbols[];

	static int zero_sid[];

	static double memoryASK[][100];

	static double memoryBID[][100];



	int sid = 0, size = 0, i = 0, id = 0;

	double ask = 0, bid = 0, retval = 0;

	bool exists = false;



	if (ArraySize(symbols) == 0)

	{

		ArrayResize(symbols, 1);

		ArrayResize(zero_sid, 1);

		ArrayResize(memoryASK, 1);

		ArrayResize(memoryBID, 1);



		symbols[0] = _Symbol;

	}



	if (type > 0 && shift > 0)

	{

		collecting_ticks = true;

	}



	if (collecting_ticks == false)

	{

		if (type > 0 && shift == 0)

		{

			// going to get ticks

		}

		else

		{

			return 0;

		}

	}



	if (symbol == "") symbol = _Symbol;



	if (type == 0)

	{

		exists = false;

		size   = ArraySize(symbols);



		if (size == 0) {ArrayResize(symbols, 1);}



		for (i=0; i<size; i++)

		{

			if (symbols[i] == symbol)

			{

				exists = true;

				sid    = i;

				break;

			}

		}



		if (exists == false)

		{

			int newsize = ArraySize(symbols) + 1;



			ArrayResize(symbols, newsize);

			symbols[newsize-1] = symbol;



			ArrayResize(zero_sid, newsize);

			ArrayResize(memoryASK, newsize);

			ArrayResize(memoryBID, newsize);



			sid=newsize;

		}



		if (sid >= 0)

		{

			ask = SymbolInfoDouble(symbol, SYMBOL_ASK);

			bid = SymbolInfoDouble(symbol, SYMBOL_BID);



			if (bid == 0 && MQLInfoInteger(MQL_TESTER))

			{

				Print("Ticks data collector error: " + symbol + " cannot be backtested. Only the current symbol can be backtested. The EA will be terminated.");

				ExpertRemove();

			}



			if (

				   symbol == _Symbol

				|| ask != memoryASK[sid][0]

				|| bid != memoryBID[sid][0]

			)

			{

				memoryASK[sid][zero_sid[sid]] = ask;

				memoryBID[sid][zero_sid[sid]] = bid;

				zero_sid[sid]                 = zero_sid[sid] + 1;



				if (zero_sid[sid] == 100)

				{

					zero_sid[sid] = 0;

				}

			}

		}

	}

	else

	{

		if (shift <= 0)

		{

			if (type == SYMBOL_ASK)

			{

				return SymbolInfoDouble(symbol, SYMBOL_ASK);

			}

			else if (type == SYMBOL_BID)

			{

				return SymbolInfoDouble(symbol, SYMBOL_BID); 

			}

			else

			{

				double mid = ((SymbolInfoDouble(symbol, SYMBOL_ASK) + SymbolInfoDouble(symbol, SYMBOL_BID)) / 2);



				return mid;

			}

		}

		else

		{

			size = ArraySize(symbols);



			for (i = 0; i < size; i++)

			{

				if (symbols[i] == symbol)

				{

					sid = i;

				}

			}



			if (shift < 100)

			{

				id = zero_sid[sid] - shift - 1;



				if(id < 0) {id = id + 100;}



				if (type == SYMBOL_ASK)

				{

					retval = memoryASK[sid][id];



					if (retval == 0)

					{

						retval = SymbolInfoDouble(symbol, SYMBOL_ASK);

					}

				}

				else if (type == SYMBOL_BID)

				{

					retval = memoryBID[sid][id];



					if (retval == 0)

					{

						retval = SymbolInfoDouble(symbol, SYMBOL_BID);

					}

				}

			}

		}

	}



	return retval;

}



int TicksPerSecond(bool get_max = false, bool set = false)

{

	static datetime time0 = 0;

	static int ticks      = 0;

	static int tps        = 0;

	static int tpsmax     = 0;



	datetime time1 = TimeLocal();



	if (set == true)

	{

		if (time1 > time0)

		{

			if (time1 - time0 > 1)

			{

				tps = 0;

			}

			else

			{

				tps = ticks;

			}



			time0 = time1;

			ticks = 0;

		}



		ticks++;



		if (tps > tpsmax) {tpsmax = tps;}

	}



	if (get_max)

	{

		return tpsmax;

	}



	return tps;

}



datetime TimeAtStart(string cmd = "server")

{

	static datetime local  = 0;

	static datetime server = 0;



	if (cmd == "local")

	{

		return local;

	}

	else if (cmd == "server")

	{

		return server;

	}

	else if (cmd == "set")

	{

		local  = TimeLocal();

		server = TimeCurrent();

	}



	return 0;

}



datetime TimeFromComponents(

	int time_src = 0,

	int    y = 0,

	int    m = 0,

	double d = 0,

	double h = 0,

	double i = 0,

	int    s = 0

) {

	MqlDateTime tm;



	     if (time_src == 0) {TimeCurrent(tm);}

	else if (time_src == 1) {TimeLocal(tm);}

	else if (time_src == 2) {TimeGMT(tm);}



	if (y > 0)

	{

		if (y < 100) {y = 2000 + y;}

		tm.year = y;

	}

	if (m > 0) {tm.mon = m;}

	if (d > 0) {tm.day = (int)MathFloor(d);}



	tm.hour = (int)(MathFloor(h) + (24 * (d - MathFloor(d))));

	tm.min  = (int)(MathFloor(i) + (60 * (h - MathFloor(h))));

	tm.sec  = (int)((double)s + (60 * (i - MathFloor(i))));



	return StructToTime(tm);

}



bool TradeSelectByTicket(ulong ticket)

{

	if (OrderSelect((int)ticket, SELECT_BY_TICKET, MODE_TRADES) && OrderType() < 2)

	{

		return true;

	}



	return false;

}



double VirtualStopsDriver(

	string command = "",

	ulong ti       = 0,

	double sl      = 0,

	double tp      = 0,

	double slp     = 0,

	double tpp     = 0

)

{

	static bool initialized     = false;

	static string name          = "";

	static string loop_name[2]  = {"sl", "tp"};

	static color  loop_color[2] = {DeepPink, DodgerBlue};

	static double loop_price[2] = {0, 0};

	static ulong mem_to_ti[]; // tickets

	static int mem_to[];      // timeouts

	static bool trade_pass = false;

	int i = 0;



	// Are Virtual Stops even enabled?

	if (!USE_VIRTUAL_STOPS)

	{

		return 0;

	}

	

	if (initialized == false || command == "initialize")

	{

		initialized = true;

	}



	// Listen

	if (command == "" || command == "listen")

	{

		int total     = ObjectsTotal(0, -1, OBJ_HLINE);

		int length    = 0;

		color clr     = clrNONE;

		int sltp      = 0;

		ulong ticket  = 0;

		double level  = 0;

		double askbid = 0;

		int polarity  = 0;

		string symbol = "";



		for (i = total - 1; i >= 0; i--)

		{

			name = ObjectName(0, i, -1, OBJ_HLINE); // for example: #1 sl



			if (StringSubstr(name, 0, 1) != "#")

			{

				continue;

			}



			length = StringLen(name);



			if (length < 5)

			{

				continue;

			}



			clr = (color)ObjectGetInteger(0, name, OBJPROP_COLOR);



			if (clr != loop_color[0] && clr != loop_color[1])

			{

				continue;

			}



			string last_symbols = StringSubstr(name, length-2, 2);



			if (last_symbols == "sl")

			{

				sltp = -1;

			}

			else if (last_symbols == "tp")

			{

				sltp = 1;

			}

			else

			{

				continue;	

			}



			ulong ticket0 = StringToInteger(StringSubstr(name, 1, length - 4));



			// prevent loading the same ticket number twice in a row

			if (ticket0 != ticket)

			{

				ticket = ticket0;



				if (TradeSelectByTicket(ticket))

				{

					symbol     = OrderSymbol();

					polarity   = (OrderType() == 0) ? 1 : -1;

					askbid   = (OrderType() == 0) ? SymbolInfoDouble(symbol, SYMBOL_BID) : SymbolInfoDouble(symbol, SYMBOL_ASK);

					

					trade_pass = true;

				}

				else

				{

					trade_pass = false;

				}

			}



			if (trade_pass)

			{

				level    = ObjectGetDouble(0, name, OBJPROP_PRICE, 0);



				if (level > 0)

				{

					// polarize levels

					double level_p  = polarity * level;

					double askbid_p = polarity * askbid;



					if (

						   (sltp == -1 && (level_p - askbid_p) >= 0) // sl

						|| (sltp == 1 && (askbid_p - level_p) >= 0)  // tp

					)

					{

						//-- Virtual Stops SL Timeout

						if (

							   (VIRTUAL_STOPS_TIMEOUT > 0)

							&& (sltp == -1 && (level_p - askbid_p) >= 0) // sl

						)

						{

							// start timeout?

							int index = ArraySearch(mem_to_ti, ticket);



							if (index < 0)

							{

								int size = ArraySize(mem_to_ti);

								ArrayResize(mem_to_ti, size+1);

								ArrayResize(mem_to, size+1);

								mem_to_ti[size] = ticket;

								mem_to[size]    = (int)TimeLocal();



								Print(

									"#",

									ticket,

									" timeout of ",

									VIRTUAL_STOPS_TIMEOUT,

									" seconds started"

								);



								return 0;

							}

							else

							{

								if (TimeLocal() - mem_to[index] <= VIRTUAL_STOPS_TIMEOUT)

								{

									return 0;

								}

							}

						}



						if (CloseTrade(ticket))

						{

							// check this before deleting the lines

							//OnTradeListener();



							// delete objects

							ObjectDelete(0, "#" + (string)ticket + " sl");

							ObjectDelete(0, "#" + (string)ticket + " tp");

						}

					}

					else

					{

						if (VIRTUAL_STOPS_TIMEOUT > 0)

						{

							i = ArraySearch(mem_to_ti, ticket);



							if (i >= 0)

							{

								ArrayStripKey(mem_to_ti, i);

								ArrayStripKey(mem_to, i);

							}

						}

					}

				}

			}

			else if (

					!PendingOrderSelectByTicket(ticket)

				|| OrderCloseTime() > 0 // in case the order has been closed

			)

			{

				ObjectDelete(0, name);

			}

			else

			{

				PendingOrderSelectByTicket(ticket);

			}

		}

	}

	// Get SL or TP

	else if (

		ti > 0

		&& (

			   command == "get sl"

			|| command == "get tp"

		)

	)

	{

		double value = 0;



		name = "#" + IntegerToString(ti) + " " + StringSubstr(command, 4, 2);



		if (ObjectFind(0, name) > -1)

		{

			value = ObjectGetDouble(0, name, OBJPROP_PRICE, 0);

		}



		return value;

	}

	// Set SL and TP

	else if (

		ti > 0

		&& (

			   command == "set"

			|| command == "modify"

			|| command == "clear"

			|| command == "partial"

		)

	)

	{

		loop_price[0] = sl;

		loop_price[1] = tp;



		for (i = 0; i < 2; i++)

		{

			name = "#" + IntegerToString(ti) + " " + loop_name[i];

			

			if (loop_price[i] > 0)

			{

				// 1) create a new line

				if (ObjectFind(0, name) == -1)

				{

						 ObjectCreate(0, name, OBJ_HLINE, 0, 0, loop_price[i]);

					ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);

					ObjectSetInteger(0, name, OBJPROP_COLOR, loop_color[i]);

					ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_DOT);

					ObjectSetString(0, name, OBJPROP_TEXT, name + " (virtual)");

				}

				// 2) modify existing line

				else

				{

					ObjectSetDouble(0, name, OBJPROP_PRICE, 0, loop_price[i]);

				}

			}

			else

			{

				// 3) delete existing line

				ObjectDelete(0, name);

			}

		}



		// print message

		if (command == "set" || command == "modify")

		{

			Print(

				command,

				" #",

				IntegerToString(ti),

				": virtual sl ",

				DoubleToStr(sl, (int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS)),

				" tp ",

				DoubleToStr(tp,(int)SymbolInfoInteger(Symbol(),SYMBOL_DIGITS))

			);

		}



		return 1;

	}



	return 1;

}



void WaitTradeContextIfBusy()

{

	if(IsTradeContextBusy()) {

      while(true)

      {

         Sleep(1);

         if(!IsTradeContextBusy()) {

            RefreshRates();

            break;

         }

      }

   }

   return;

}



int WindowFindVisible(long chart_id, string term)

{

   //-- the search term can be chart name, such as Force(13), or subwindow index

   if (term == "" || term == "0") {return 0;}

   

   int subwindow = (int)StringToInteger(term);

  

   if (subwindow == 0 && StringLen(term) > 1)

   {

      subwindow = ChartWindowFind(chart_id, term);

   }

   

   if (subwindow > 0 && !ChartGetInteger(chart_id, CHART_WINDOW_IS_VISIBLE, subwindow))

   {

      return -1;  

   }

   

   return subwindow;

}



long attrTicketParent(long ticket)

{

	int pos, total;

	long retval = 0;

	static long parents_idx[];

	static long parents[];



	//-- if parent ticket is known, return it ----------------------------

	int size = ArraySize(parents_idx);

	int idx  = -1;



	if (size > 0)

	{

		for (int i=size-1; i>=0; i--)

		{

			if (parents_idx[i] == ticket)

			{

				idx = i;

				break;

			}  

		}

	}



	if (idx >- 1)

	{

		retval = parents[idx];

	}

	else

	{

		if (!OrderSelect((int)ticket,SELECT_BY_TICKET))

		{

			retval = ticket;

		}



		//-- check if trade is added to volume ----------------------------

		if (retval == 0)

		{

			string comment = OrderComment();

			int p_pos      = StringFind(comment, "[p=");



			if (p_pos >= 0)

			{

				string p_tag = StringSubstr(comment,p_pos);

				p_tag        = StringSubstr(p_tag,0,StringFind(p_tag,"]")+1);

				retval       = (int)StringToInteger(StringSubstr(p_tag,3,-1));

			}

		}



		double OP   = OrderOpenPrice();

		datetime OT = OrderOpenTime();

		string S    = OrderSymbol();

		int M       = OrderMagicNumber();

		int T       = OrderType(); 

		double L    = OrderLots();

		int D       = (int)MarketInfo(S,MODE_DIGITS);



		//-- Check "from #Number" comment

		if (retval == 0)

		{

			total = OrdersTotal();

			long ticketTmp   = ticket;



			// Now start recursive search from trade to trade to find the parent one

			while (true)

			{

				if (!OrderSelect((int)ticketTmp, SELECT_BY_TICKET))

				{

					retval = ticket;

					break;

				}

						

				string comment = OrderComment();



				if (StringSubstr(comment, 0, 6) == "from #")

				{

					long ticketCurrent = (long)StringToInteger(StringSubstr(comment, 6));

					

					if (ticketTmp == ticketCurrent)

					{

						// eventually the most parent trade has its own ticket number in "from #Number", so stop here

						break;

					}

					else

					{

						// if the ticket number in "from #Number" is different, go to load that ticket number

						ticketTmp = ticketCurrent;

						continue;

					}

				}

				else

				{

					retval = ticketTmp;

					break;

				}

			}

		}



		//-- check if trade is partially closed (in trades) ---------------

		if (retval == 0)

		{

			total = OrdersTotal();



			for (pos=total-1; pos>=0; pos--)

			{

				if (OrderSelect(pos,SELECT_BY_POS,MODE_TRADES))

				{

					if (OrderOpenTime() < OT)

					{

						break;

					}



					if (

						OrderTicket() < ticket

						&& (OrderSymbol() == S)

						&& (OrderMagicNumber() == M)

						&& (OrderType() == T)

						&& (NormalizeDouble(OrderOpenPrice(),D) == NormalizeDouble(OP,D))

						&& (OrderOpenTime() == OT)

					)

					{

					

						retval = OrderTicket();

					}

				}

			}

		}



		//-- still nothing found - search in history trades now -----------

		if (retval == 0)

		{

			total = OrdersHistoryTotal();



			for (pos=total-1; pos>=0; pos--)

			{

				if (OrderSelect(pos,SELECT_BY_POS,MODE_HISTORY))

				{

					if (OrderOpenTime() < OT)

					{

						break;

					}



					if (

						OrderTicket() < ticket

						&& (OrderSymbol() == S)

						&& (OrderMagicNumber() == M)

						&& (OrderType() == T)

						&& (NormalizeDouble(OrderOpenPrice(),D) == NormalizeDouble(OP,D))

						&& (OrderOpenTime() == OT)

					)

					{

						retval = OrderTicket();

					}

				}

			}

		}



		if (retval > 0)

		{

			size=ArraySize(parents_idx);

			ArrayResize(parents_idx,size+1);

			ArrayResize(parents,size+1);

			parents_idx[size] = ticket;

			parents[size]     = retval;

		}

	}



	if (!OrderSelect((int)ticket,SELECT_BY_TICKET))

	{

		retval = ticket;

	}



	if (retval <= 0)

	{

		retval = ticket;

	}



	return retval;

}



string e_Reason() {return onTradeEventDetector.EventValueReason();}



string e_ReasonDetail() {return onTradeEventDetector.EventValueDetail();}



double e_attrClosePrice() {return onTradeEventDetector.EventValuePriceClose();}



datetime e_attrCloseTime() {return onTradeEventDetector.EventValueTimeClose();}



string e_attrComment() {return onTradeEventDetector.EventValueComment();}



datetime e_attrExpiration() {return onTradeEventDetector.EventValueTimeExpiration();}



double e_attrLots() {return onTradeEventDetector.EventValueVolume();}



double e_attrOpenPrice() {return onTradeEventDetector.EventValuePriceOpen();}



datetime e_attrOpenTime() {return onTradeEventDetector.EventValueTimeOpen();}



double e_attrProfit() {return onTradeEventDetector.EventValueProfit();}



double e_attrStopLoss() {return onTradeEventDetector.EventValueStopLoss();}



double e_attrSwap() {return onTradeEventDetector.EventValueSwap();}



double e_attrTakeProfit() {return onTradeEventDetector.EventValueTakeProfit();}



int e_attrTicket() {return (int)onTradeEventDetector.EventValueTicket();}



int e_attrType() {return onTradeEventDetector.EventValueType();}



int iCandleID(string SYMBOL, ENUM_TIMEFRAMES TIMEFRAME, datetime time_stamp)

{

	bool TimeStampPrevDayShift = true;

	int CandleID               = 0;



	// get the time resolution of the desired period, in minutes

	int mins_tf  = TIMEFRAME;

	int mins_tf0 = 0;



	if (TIMEFRAME == PERIOD_CURRENT)

	{

		mins_tf = (int)PeriodSeconds(PERIOD_CURRENT) / 60;

	}



	// get the difference between now and the time we want, in minutes

	int days_adjust = 0;



	if (TimeStampPrevDayShift)

	{

		// automatically shift to the previous day

		if (time_stamp > TimeCurrent())

		{

			time_stamp = time_stamp - 86400;

		}



		// also shift weekdays

		while (true)

		{

			int dow = TimeDayOfWeek(time_stamp);



			if (dow > 0 && dow < 6) {break;}



			time_stamp = time_stamp - 86400;

			days_adjust++;

		}

	}



	int mins_diff = (int)(TimeCurrent() - time_stamp);

	mins_diff = mins_diff - days_adjust*86400;

	mins_diff = mins_diff / 60;



	// the difference is negative => quit here

	if (mins_diff < 0)

	{

		return (int)EMPTY_VALUE;

	}



	// now calculate the candle ID, it is relative to the current time

	if (mins_diff > 0)

	{

		CandleID = (int)MathCeil((double)mins_diff/(double)mins_tf);

	}



	// now, after all the shifting and in case of missing candles, the calculated candle id can be few candles early

	// so we will search for the right candle

	while(true)

	{

		if (iTime(SYMBOL, TIMEFRAME, CandleID) >= time_stamp) {break;}



		CandleID--;



		if (CandleID <= 0) {CandleID = 0; break;}

	}



	return CandleID;

}



double toPips(double digits, string symbol)

{

	if (symbol == "") symbol = Symbol();



   return digits / (PipValue(symbol) * SymbolInfoDouble(symbol, SYMBOL_POINT));

}













class FxdWaiting

{

	private:

		int beginning_id;

		ushort bank  [][2][20]; // 2 banks, 20 possible parallel waiting blocks per chain of blocks

		ushort state [][2];     // second dimention values: 0 - count of the blocks put on hold, 1 - current bank id



	public:

		void Initialize(int count)

		{

			ArrayResize(bank, count);

			ArrayResize(state, count);

		}



		bool Run(int id = 0)

		{

			beginning_id = id;



			int range = ArrayRange(state, 0);

			if (range < id+1) {

				ArrayResize(bank, id+1);

				ArrayResize(state, id+1);



				// set values to 0, otherwise they have random values

				for (int ii = range; ii < id+1; ii++)

				{

				   state[ii][0] = 0;

				   state[ii][1] = 0;

				}

			}



			// are there blocks put on hold?

			int count = state[id][0];

			int bank_id = state[id][1];



			// if no block are put on hold -> escape

			if (count == 0) {return false;}

			else

			{

				state[id][0] = 0; // null the count

				state[id][1] = (bank_id) ? 0 : 1; // switch to the other bank

			}



			//== now we will run the blocks put on hold



			for (int i = 0; i < count; i++)

			{

				int block_to_run = bank[id][bank_id][i];

				_blocks_[block_to_run].run();

			}



			return true;

		}



		void Accumulate(int block_id = 0)

		{

			int count   = ++state[beginning_id][0];

			int bank_id = state[beginning_id][1];



			bank[beginning_id][bank_id][count-1] = (ushort)block_id;

		}

};

FxdWaiting fxdWait;







//+------------------------------------------------------------------+

//| END                                                              |

//| Created with fxDreema EA Builder           https://fxdreema.com/ |

//+------------------------------------------------------------------+



/*<fxdreema:eNrtWm1v2zgM/itF9rmD7Thv7jAgTVq0h7bJNSmK7Yuh2Eqiq2MZktIsGPrfj5Rkx/Hc27rrhm3tp9mm+IikHlIMVxJ0gs8ycN2gEfE0pZFiPJWNIxL4wWcWOPDQxAWtoDFnNIkbRxI0GsOT0/7NxRTf2kFD8rWIKL4AjGs/KiIWVNmPXuPogQXu09G8OrSmRvOejubXobU0WvPpaK06tDagPejPs4RHdzqUbQwlOu+5uENXx1oJnuSBloEXNC44vnn2jWkDXB+e0phFRHEhQ3bZx68VgK4FvexnVDAel83r4Ge5ZPPcPscCXPZXVC3NYnwdDU/CiYF3Yft+liWMxmPBrLugOr4+H5yEg4vR5MR6PtmuZjzBFydo2G/jnQ1g/Pjk+nw0DAc319cnVzqKEN9Jbo/VcuHfwQhWDKbno6tCgHHsoKurjAhtBRj26b19uH7OcAGC5/wJ8UJRJLiUGxar5S4lHwx8HoeQflKCYDTcIv1RK/xSrWe0CEupQAGgTFl0Z+MQM0lmCQX7Z1AsdPwAmgpTQ5zg80P5eGx1AEgmw2gtFV/lit08YUwmYa5tpaIru8+KxzQJDQyoDzicMpYqDQubAkMIHBCFU484F7HcD3LGoLYVRkJIZUQSaoUpFyuS5IGVFLGQPzsP0BpF1FoWlAMInvL5vHHENCREJSaK7M5CL1FMmV3QxAEGmMoDMuP39N1MvLfbA4p22iIDUkLxuKHCdRC6CTg8w3e35yEwrNgQpnJvIBz3RDA8hpLJsCFfq2ytZBmZwTfUc43J1L46CAv7RFKv1nXQxRJGoruF4Os0Pox4woXNkDenp8NBv2fZWUjgeN/k3J8DZQ43lC2WqhwTTJUZHA8Vh1JtTWzgdBWYny7w1db12kKpzfrOLMKNx0TKS/JpylZU/kCKe89AcSTiKI0ouHVMxO9Ccs8YfQB19WBmzP4Kv/09fnu++2vwe+ZQr9v8Hn7X1lhjcR33jZ7pPmo575r2DCM7+we6sx0hfEyb9S7wWnyTwQFRa/icJJJal0B8BdypXCJGabrNdjDHf4X96+vRbXgzLkH3heCbARDUXpatriUtyDCf3Jq72MFzS9Y0VGxFa+7hwt9LwJ3aNaa7M9r4bVJuuBybWVqgyCqzjjpO4Di5tSgckDRO6PmwrJcjXhJxR/du015ZCZ/mgqz29sTk00ugFeEpTdUHag4hh+hW5Jfg57K8oF1ZMCTbsriKfwZu21C73p6RxQ4sXat9I6tLJhTCHe8tae6iPak2Oa5vI4sCdLBcXtxWSai925OWVW8pvdsTNktC8PtRRXRa1gTN7Kn9fVRsfK0V37EMTYrtzrvEeDClHyis27Y6DmP6a1pAxTX/1hC5Y2slG51dDOwW7AxKQ24Ghtyw6xS60+OtPVmWN5N1dK3SfFfmv+v6e7xjNBHop9HSVjmQ9K8GZ6PrcDoa79J8UJRBbBYTMaQ0G7P0brdiklc1XDGZfriADnl0YdwyK273u8u8Mh0Tc9mWaxayBjFpAhUKa3+15rklOY2r6sarMxbHNK2XfdSluJrl6OiSCDVZz27hrPimXN2ft09oPkefACZoe4eCbHSR/tG9gm9+y+ZHiO3a7rlZRJMFfvH8LL0F0AF9PNBOHpjL6UnNs9frPVNz4fy/5mI+78xbzk9sLvzXycOzTB7evU4efuPJg/86eZjRhG++afLgd1qVyYPzAiYPrd988tB6nTx84+TB71aaA995oZOH9i8xefDLk4fh6Pbqj5k9uK+zh9fZw0+cPWApurA/A58+enBfRw8vYfTQfh09PKG5aO2NHoZ8k369v2jv989Nx3mRw4cHTRsIkmLpwvjj5SaSSLF7Gj5GawTNBMc2IUzzOxEiJqiE+yFaHlByoPgB/uiuLle2rWhjGkBLqPKsjoC/YQIN/5os8qy+/PvCz33HFiaMBLWdjOfjj3PPPXSdQ6c7dbyg1Quczttez/u4pwJ5webbb1VZkQWL

QiClMFxpenio0JI07plkQIYwYTNBxDbEE8y+SESMQr5SZ+tj65B/UMhFKPMbCvo9x1qRcZaqUKwt95r5n/vkhJsLvsp7nLeO49qbQ3EbN/joFn/VU1XqGKWqWtt+dnf/0VtR7OaK/6H5YMrMWtLwngm1JgkEk2fSKqRawYSzJNWtoM4ak/UYRYSgEKAFTaNtDQiuqchDQZNq51NdQuL9zgce6D00RRKJUtwmOc97hTTaRnCk+WzI1joUp1giQpkBM+NQl9ZC3NyJbZUzAg9DR4EKcPpLvgl3w6lCFWK4ECRbhlww2J8UUw2wd8qzKT/mSt8Nxf0DW6SqVKrqCxgwhoCl+yXtHq4DjY+l+uFfGvLANA==

:fxdreema>*/