Desynced Forex

//+------------------------------------------------------------------+
//|                                                     Su3D[v4].mq4 |
//|                                      Copyright © 2008, Sgibnev   |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "25.03.2009"

//+------------------------------------------------------------------+
//| ÓÑÒÀÍÎÂÊÀ ÂÐÅÌÅÍÈ ÄÅÉÑÒÂÈß ÝÊÑÏÅÐÒÀ ÄÎ:                          +                                                 |
//+------------------------------------------------------------------+
double Days = 25;
double Months = 03;
double Years = 2009;

//double Account1 =40263; 
//double Account2 =183199671;
//double Account3 =183202028;
 

//---- Âíåøíèå ïåðåìåííûå (äîñòóïíûå â îêíå ñâîéñòâ ýêñïåðòà) - ìîæíî óñòàíîâèòü çíà÷åíèÿ ïî óìîë÷àíèþ
extern string 		Symbols 	         	= "GBPUSDH1, AUDCADH1, EURJPYH1, EURUSDH1, USDJPYH1";
extern int        Charts                     = 1;
extern string 		Rick   	           = "TotalEquityRisk 1-5";
extern double     TotalEquityRisk     =3 ;
extern string 		Trade 	           = "Long&Short=0, Only Long=1, Only Short=-1";
extern int      	TradeDirection		        	= 0;		// Ðàçðåøåííîå íàïðàâëåíèå òîðãîâëè: 0 - Buy & Sell, 1 - Buy Only, -1 - Sell Only

int               Profit                     =1; 
//string 		Properties 	            	= "=========== Properties ===========";
double		LotExponent;	
int			PipStep;	
int			TakeProfit						= 25;		// Íåîáõîäèìàÿ äëÿ çàêðûòèÿ ïîçèöèé ïðèáûëü
int			MaxTrades						= 18;		// Ìàêñèìàëüíîå êîë-âî äîëèâîê
int			StopLoss				      	= 15;		// Ïðè óáûòêå ïîñëåäíåé äîëèâêè ðàçìåðîì LastStopLoss ïóíêòîâ âñÿ ñåðèÿ çàêðûâàåòñÿ

int 			Expert_Id 						= 2009;	// Óíèêàëüíûé èäåíòèôèêàòîð ýêñïåðòà. Åñëè íà 2-õ ãðàôèêàõ ñ îäèíàêîâûì Ñèìâîëîì È ÒàéìÔðåéìîì äîëæíî ðàáîòàòü 2 ýêñïåðòà, íàäî óñòàíîâèòü èì ðàçíûå Expert_Id
//int      	TradeDirection		        	= 0;		// Ðàçðåøåííîå íàïðàâëåíèå òîðãîâëè: 0 - Buy & Sell, 1 - Buy Only, -1 - Sell Only
double      StartLot_b, StartLot_s;	// Ñòàðòîâûé ëîò


double RBCImax = 40,FTLMmax = 10,STLMmax = 100,STLMmin = 20,PCCImax = 20;  //M5 
double FTLM,STLM,PCCI,RBCI,SATL,FATL,RFTL,RSTL;
double aSATL[4],aFATL[4],aRFTL[4],aRSTL[4],aFTLM[4],aSTLM[4],aPCCI[4],aRBCI[4];
double tFATL,tRFTL,tSATL,tRSTL,tFTLM,tRBCI,tSTLM,tPCCI;
double atFATL[2];


bool L1 = True,L2A = True,L2B = True, L3 = True,L4 = True,L5 = True,L6 = True,L7 = True,L8 =True;
bool S1 = True,S2A = True,S2B = True,S3 = True,S4 = True,S5 = True,S6 = True,S7 = True,S8 = True;

   int shift;


//========================================================
string 	Trade_Properties 		= "--------Trade-Properties-------";
int 		Slippage 				= 5;
int 		PauseBeforeTrade		= 5;
int 		MaxWaitingTime			= 300;
color 	OrderBuyColor 			= Lime;
color 	OrderSellColor 		= Red;

 string 	Allow_Flags		 		= "-----------Allow-Flags---------";
 bool		Allow_Info				= false;
 bool		Allow_LogFile			= false;
 bool		Allow_TradeLogFile	= false;
 bool		Allow_ErrorMail		= true;
 bool		Allow_ErrorLogFile	= false;

 string 	Info_Properties 		= "--------Info-Properties--------";
 bool		EnglishInfo				= true;
 int		Font_Size_Variant		= 2; //îò 1 äî 10
 color 	Standart_Color 		= White;
 color 	Warning_Color 			= Magenta;
 color 	Price_Up_Color 		= Lime;
color 	Price_Down_Color 		= Red;

string	strComment, strPeriod, TradeInfoLib_Font = "Arial";
double	TradeInfoLib_FontSize, TradeInfoLib_HeadFontSize;

string	_Symbol, ExpertName;
int		_Period, _MagicNumber, _Digits;
double	_Point, _StopLevel, _Spread;
datetime StartTime;

/////////////////////////////////////////////////////////////////////////////////
string stringServer						= "";
string stringReal							= "";
string stringDemo							= "";
string stringTradeAllow					= "";
string stringTradeNotAllow				= "";
string stringLoaded						= "";

string stringOpenedPosition			= "";
string stringOpenedOrder				= "";
string stringPointBefore				= "";

string stringGlobalStop					= "";
string stringGlobalStop1				= "";
string stringGlobalStop2				= "";
string stringNoBars						= "";

string stringInvalidParameters		= "";///////////////////////////////
string stringInvalidOrderType			= "";//////////////////////////////////////
string stringInvalidVolume				= "";
string stringIncorrectAbove			= "";
string stringIncorrectBelow			= "";
string stringIncorrectTooBeside		= " ";
string stringInvalidExpiration		= " ";
string stringIncorrectExpiration		= "";

string stringSendingOrder				= "";
string stringSendingOrder1				= "";
string stringSendingPosition			= "";
string stringSendingPosition1			= "";

string stringCheck						= "";
string stringCheckError					= "";
string stringCheckOK						= "";

string stringNoConnection				= "";
string stringStopped						= "";
string stringTimeOut						= "";
string stringSuccessfully				= "";
/////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////
/**/ void TradeInfoLib_Initialization ( int TradeInfoLib_ExpertId, string TradeInfoLib_ExpertName )
/////////////////////////////////////////////////////////////////////////////////
// Èíèöèàëèçàöèÿ ïåðåìåííûõ, ñîçäàíèå îáúåêòîâ äëÿ âûâîäà èíôîðìàöèè,
// çàïèñü â ëîã èíôîðìàöèè îá èíèöèàëèçàöèè.
// Ãåíåðàöèÿ êîììåíòàðèÿ ê îðäåðàì ( êîòîðûå áóäóò îòêðûòû ñ ïîìîùüþ ô-öèè _OrderSend )
//
// Íåîáõîäèìî âûçâàòü ô-öèþ èç init() ýêñïåðòà
/////////////////////////////////////////////////////////////////////////////////
{

		/////////////////////////////////////////////////////////////////////////////////
		if ( EnglishInfo )
		{
				stringServer						= "Server ";
				stringReal							= "REAL ACCOUNT #";
				stringDemo							= "Demo account #";
				stringTradeAllow					= "TRADE IS ALLOWED!";
				stringTradeNotAllow				= "Trade is not allowed";
				stringLoaded						= "Expert loaded successfully...";

				stringOpenedPosition				= " - position opened by this expert:";
				stringOpenedOrder					= " - order opened by this expert:";
				stringPointBefore					= "Ïóíêòîâ äî ñðàáàòûâàíèÿ - ";///////////////////////////////

				stringGlobalStop					= "Expert was stopped!";
				stringGlobalStop1					= "Global variable";
				stringGlobalStop2					= "must be >= 0!";
				stringNoBars						= "Ñëèøêîì ìàëî áàðîâ íà ãðàôèêå!";///////////////////////////

				stringInvalidParameters			= "Invalid trade parameters";
				stringInvalidOrderType			= "Invalid OrderType";
				stringInvalidVolume				= " - invalid volume!!!";
				stringIncorrectAbove				= " - Incorrect (above";
				stringIncorrectBelow				= " - Incorrect (below";
				stringIncorrectTooBeside		= " - Incorrect (too beside to";
				stringInvalidExpiration			= " - Äëÿ ìàðêåò-îðäåðà íåëüçÿ óñòàíîâèòü âðåìÿ èñòå÷åíèÿ!!!";//////
				stringIncorrectExpiration		= " - Âðåìÿ èñòå÷åíèÿ íåëüçÿ óñòàíîâèòü â ïðîøëîì!!!";/////////////

				stringSendingOrder				= "Sending ";
				stringSendingOrder1				= "-order...";
				stringSendingPosition			= "Sending ";
				stringSendingPosition1			= " position...";

				stringCheck							= "Checking.....";
				stringCheckError					= "Checking.....Error!";
				stringCheckOK						= "Checking.....OK...";

				stringNoConnection				= "No connection with trade server";
				stringStopped						= "Expert was stopped by user";
				stringTimeOut						= "Limit of waiting time";
				stringSuccessfully				= "Successfully...";
		}
		/////////////////////////////////////////////////////////////////////////////////
//		if (false) { _MagicNumber(1,"",1); _OrderSend("",1,1.1,1.1,1,1.1,1.1); _OrderModify(1,1.1,1.1,1.1,0); _OrderClose(1,1.1,1.1,1); _OrderDelete(1); _Reverse(1); _TrailingStop(1,1); intPeriod(1); }
	int _GetLastError;

//---- ïðè òåñòèðîâàíèè âñå "êðàñèâîñòè" âûêëþ÷àåì
	if ( IsTesting() )
	{
		if ( !IsVisualMode() ) Allow_Info = false;
		Allow_LogFile			= false;
		Allow_TradeLogFile	= false;
		Allow_ErrorMail		= false;
		Allow_ErrorLogFile	= false;
	}

//---- Èíèöèàëèçèðóåì ãëîáàëüíûå ïåðåìåííûå áèáëèîòåêè (îáúÿâëåííûå âíå ô-öèé)
	StartTime	= 0;
	_Symbol		= Symbol();
	_Period		= Period();
	_Digits		= MarketInfo( _Symbol, MODE_DIGITS );
	_Point		= MarketInfo( _Symbol, MODE_POINT );
	_StopLevel	= NormalizeDouble ( ( MarketInfo( _Symbol, MODE_STOPLEVEL ) + 1 ) * _Point, _Digits );
	_Spread		= NormalizeDouble ( MarketInfo ( _Symbol, MODE_SPREAD ) * _Point, _Digits );
	strPeriod	= strPeriod( _Period );
	_MagicNumber= _MagicNumber( TradeInfoLib_ExpertId, _Period );


	if ( TradeInfoLib_ExpertName == "" )
		ExpertName = WindowExpertName();
	else
		ExpertName = TradeInfoLib_ExpertName;

	strComment	= ExpertName + " (" + _Symbol + ", " + strPeriod + ")";
//---- Ñîçäà¸ì ýêñïåðòó ëè÷íóþ ãëîáàëüíóþ ïåðåìåííóþ
	while ( !IsStopped() )
	{
		if ( GlobalVariableSet( strComment + "-return!", 0.0 ) > 0 ) { break; }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{ Print( TradeInfoLib_ExpertId, ", ", TradeInfoLib_ExpertName, " ) - GlobalVariableSet ( \"", strComment, "-return!\", 0.0 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" ); }

		Sleep(100);
	}
	
//---- Óñòàíàâëèâàåì ãëîáàëüíóþ ïåðåìåííóþ TradeIsBusy â 0
	TradeIsNotBusy();

//---- Ñîçäà¸ì îáúåêòû äëÿ âûâîäà èíôîðìàöèè
	int v_shag = 16;
	int h_shag = 350;
	switch ( Font_Size_Variant )
	{
		case 1:	TradeInfoLib_FontSize = 5;		TradeInfoLib_HeadFontSize = 5;	v_shag = 8;		h_shag = 180; break;
		case 2:	TradeInfoLib_FontSize = 6;		TradeInfoLib_HeadFontSize = 7;	v_shag = 9;		h_shag = 200; break;
		case 3:	TradeInfoLib_FontSize = 7;		TradeInfoLib_HeadFontSize = 8;	v_shag = 11;	h_shag = 230; break;
		case 4:	TradeInfoLib_FontSize = 8;		TradeInfoLib_HeadFontSize = 9;	v_shag = 13;	h_shag = 270; break;
		case 5:	TradeInfoLib_FontSize = 9;		TradeInfoLib_HeadFontSize = 11;	v_shag = 15;	h_shag = 310; break;
		case 6:	TradeInfoLib_FontSize = 10;	TradeInfoLib_HeadFontSize = 12;	v_shag = 16;	h_shag = 350; break;
		case 7:	TradeInfoLib_FontSize = 11;	TradeInfoLib_HeadFontSize = 13;	v_shag = 18;	h_shag = 390; break;
		case 8:	TradeInfoLib_FontSize = 12;	TradeInfoLib_HeadFontSize = 14;	v_shag = 20;	h_shag = 430; break;
		case 9:	TradeInfoLib_FontSize = 13;	TradeInfoLib_HeadFontSize = 15;	v_shag = 22;	h_shag = 480; break;
		case 10:	TradeInfoLib_FontSize = 14;	TradeInfoLib_HeadFontSize = 16;	v_shag = 24;	h_shag = 530; break;
		default:	TradeInfoLib_FontSize = 10;	TradeInfoLib_HeadFontSize = 12;	v_shag = 16;	h_shag = 350; break;
	}

	_LabelCreate ( "ExpertLog_00", 4, 15				);
	_LabelCreate ( "ExpertLog_01", 4, 15 + v_shag	);
	_LabelCreate ( "ExpertLog_02", 4, 15 + v_shag*2 );
	_LabelCreate ( "ExpertLog_03", 4, 15 + v_shag*3 );
	_LabelCreate ( "ExpertLog_04", 4, 15 + v_shag*4 );

	_LabelCreate ( "ExpertLog_10", h_shag, 15					);
	_LabelCreate ( "ExpertLog_11", h_shag, 15 + v_shag		);
	_LabelCreate ( "ExpertLog_12", h_shag, 15 + v_shag*2	);
	_LabelCreate ( "ExpertLog_13", h_shag, 15 + v_shag*3	);
	_LabelCreate ( "ExpertLog_14", h_shag, 15 + v_shag*4	);

//---- Âûâîäèì èíôîðìàöèþ îá èíèöèàëèçàöèè è çàïèñûâàåì å¸ â ôàéë
	string	AccountStatus	= stringReal;
	int		AccountColor	= 1;
	if ( IsDemo() )
	{
		AccountStatus	= stringDemo;
		AccountColor	= 0;
	}
	string	TradeStatus	= stringTradeAllow;
	int		TradeColor	= 1;
	if ( !IsTradeAllowed() )
	{
		TradeStatus	= stringTradeNotAllow;
		TradeColor	= 0;
	}
	clear_info ();
	_FileWrite	( 		"\n"																									);
	_FileWrite	( 		"++---------Initialization---------++"														);
	_info			( 1,	stringServer + ServerAddress()											, 0				);
	_info			( 2,	AccountStatus + AccountNumber() + " ( " + AccountName() + " )"	, AccountColor );
	_info			( 3,	TradeStatus																		, TradeColor	);
	_info			( 4,	stringLoaded																	, 0				);
	_FileWrite	( 		"++--------------------------------++\n"													);

//---- Ñïèì ñåêóíäó, ÷òîá ýòó ñàìóþ èíôîðìàöèþ ìîæíî áûëî ïðî÷èòàòü =)
	Sleep(1000);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ bool IsOK()
/////////////////////////////////////////////////////////////////////////////////
// Ïðîâåðêà ëè÷íîé ãëîáàëüíîé ïåðåìåííîé ýêñïåðòà, êîëè÷åñòâà áàðîâ íà ãðàôèêå è Ðàçðåøåíèÿ òîðãîâàòü
//  ñëó÷àå óñïåøíîé ïðîâåðêè âîçâðàùàåò true, èíà÷å - false. Ïðè òåñòèðîâàíèè âîçâðàùàåò true.
// Ðåêîìåíäóåòñÿ â ñëó÷àå IsOK() == false ïðåêðàùàòü ðàáîòó ýêñïåðòà.
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() )
	{
		if ( IsVisualMode() ) clear_info();
		return(true);
	}

	_StopLevel	= NormalizeDouble ( ( MarketInfo( _Symbol, MODE_STOPLEVEL ) + 1 ) * _Point, _Digits );
	_Spread		= NormalizeDouble ( MarketInfo ( _Symbol, MODE_SPREAD ) * _Point, _Digits );

	clear_info();

	if ( GlobalVariableGet ( strComment + "-return!" ) < 0 )
	{
		_info( 1, stringGlobalStop, 1 );
		_info( 2, stringGlobalStop1 + "\"" + strComment + "-return!\" " + stringGlobalStop2, 1 );
		return(false);
	}
	if ( Bars < 100 )
	{
		_info( 1, stringNoBars, 1 );
		return(false);
	}
return(true);
}
/////////////////////////////////////////////////////////////////////////////////
/**/ void TradeInfoLib_Deinitialization()
/////////////////////////////////////////////////////////////////////////////////
// Óäàëåíèå îáúåêòîâ, ñîçäàíûõ áèáëèîòåêîé. Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò true, èíà÷å - false.
//
// Íåîáõîäèìî âñòàâèòü â deinit() ýêñïåðòà.
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;
	
//---- Óäàëÿåì ëè÷íóþ ãëîáàëüíóþ ïåðåìåííóþ ýêñïåðòà
	if( !GlobalVariableDel( strComment + "-return!" ) )
	{
		_GetLastError = GetLastError();
		Print( "SU3D[v5]", strComment, "-return!\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}

	if ( !Allow_Info ) { return(0); }

//---- È âñå îáúåêòû äëÿ âûâîäà èíôîðìàöèè
	if ( !ObjectDelete ( "ExpertLog_00" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "00", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_01" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "01", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_02" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "02", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_03" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "03", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_04" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "04", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_10" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "10", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_11" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "11", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_12" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "12", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_13" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "13", _GetLastError );
	}
	if ( !ObjectDelete ( "ExpertLog_14" ) )
	{
		_GetLastError = GetLastError();
		TradeInfoLib_Deinit_print( "14", _GetLastError );
	}
}
void TradeInfoLib_Deinit_print ( string ExpertLog_Number, int Error )
{
	Print( "SU3D[v5]", ExpertLog_Number, "\" ) - Error #", Error, " ( ", ErrorDescription( Error ), " )" );
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _info ( int LogNumber, string Text = "", int ColorVariant = 0, bool File_Log = true )
/////////////////////////////////////////////////////////////////////////////////
// Âûâîä èíôîðìàöèè íà ýêðàí, çàïèñü å¸ æå â ëîã-ôàéë ýêñïåðòà è â ëîã-ôàéë ÌÒ.
//
// LogNumber - íîìåð ñòðîêè íà ýêðàíå, â êîòîðóþ áóäåò âûâåäåíà èíôîðìàöèÿ:
// îò 1 äî 4 (4 ñòðîêè íà ëåâîé ïîëîâèíå ýêðàíà) è îò 10 äî 14 (5 ñòðîê - íà ïðàâîé) 
//
// Text - ñîáñòâåííî, òåêñò, âûâîäèìûé íà ýêðàí è çàïèñûâàåìûé â ëîã-ôàéëû
//
// ColorVariant - öâåò âûâîäà èíôîðìàöèè íà ýêðàí: 0 - Standart_Color, 1 - Warning_Color,
// 2 - Price_Up_Color, 3 - Price_Down_Color. Âñå 4 öâåòà ïðåäîïðåäåëÿþòñÿ âõîäÿùèìè ïåðåìåííûìè.
//
// File_Log - ôëàã, ðàçðåøàþùèé (çàïðåùàþùèé) çàïèñü èíôîðìàöèè â ëîã-ôàéë ýêñïåðòà:
// 1(true) - çàïèñü ðàçðåøåíà (ïî óìîë÷àíèþ), 0(false) - çàïèñü çàïðåùåíà.
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;

	if ( Allow_Info )
	{
		string _infoLabelName;
		double _infoFontSize = TradeInfoLib_FontSize;
		switch ( LogNumber )
		{
			case 0:  _infoLabelName = "ExpertLog_00";	_infoFontSize = TradeInfoLib_HeadFontSize;	break;
			case 1:  _infoLabelName = "ExpertLog_01";																break;
			case 2:  _infoLabelName = "ExpertLog_02";																break;
			case 3:  _infoLabelName = "ExpertLog_03";																break;
			case 4:  _infoLabelName = "ExpertLog_04";																break;
			case 10: _infoLabelName = "ExpertLog_10";	_infoFontSize = TradeInfoLib_HeadFontSize;	break;
			case 11: _infoLabelName = "ExpertLog_11";																break;
			case 12: _infoLabelName = "ExpertLog_12";																break;
			case 13: _infoLabelName = "ExpertLog_13";																break;
			case 14: _infoLabelName = "ExpertLog_14";																break;
			default: _infoLabelName = "ExpertLog_01";																break;
		}
		color _infoColor;
		switch ( ColorVariant )
		{
			case 1:	_infoColor = Warning_Color;		break;
			case 2:	_infoColor = Price_Up_Color;		break;
			case 3:	_infoColor = Price_Down_Color;	break;
			default:	_infoColor = Standart_Color;		break;
		}

		if ( !ObjectSetText( "ExpertLog_00", "Expert log ( " + TimeToStr( TimeLocal(), TIME_SECONDS) + " )", TradeInfoLib_HeadFontSize, TradeInfoLib_Font, Standart_Color ) )
		{
			_GetLastError = GetLastError();
			Print( "( ", LogNumber, ", \"", Text, "\", ", ColorVariant, ", ", File_Log, " ) - ObjectSetText( \"ExpertLog_00\", \"Expert log ( ", TimeToStr( TimeLocal(), TIME_SECONDS), " )\", ", TradeInfoLib_HeadFontSize, ", ", TradeInfoLib_Font, ", ", Standart_Color, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		}

		if ( !ObjectSetText( _infoLabelName, Text, _infoFontSize, TradeInfoLib_Font, _infoColor) )
		{
			_GetLastError = GetLastError();
			Print( "( ", LogNumber, ", \"", Text, "\", ", ColorVariant, ", ", File_Log, " ) - ObjectSetText( \"", _infoLabelName,"\", \"", Text, "\", ", _infoFontSize, ", ", TradeInfoLib_Font, ", ", _infoColor, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		}
	}

	if ( Text != "" && File_Log ) { _FileWrite ( Text ); }
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void clear_info ()
/////////////////////////////////////////////////////////////////////////////////
// Î÷èñòêà ýêðàíà îò èíôîðìàöèè, âûâåäåííîé áèáëèîòåêîé íà ýêðàí.
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;

	if ( !Allow_Info ) { return(0); }

	if ( !ObjectSetText ( "ExpertLog_00", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "00", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_01", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "01", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_02", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "02", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_03", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "03", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_04", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "04", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_10", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "10", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_11", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "11", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_12", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "12", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_13", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "13", _GetLastError ); }
	if ( !ObjectSetText ( "ExpertLog_14", "", 10 ) ) { _GetLastError = GetLastError(); clear_info_print ( "14", _GetLastError ); }
}
void clear_info_print ( string ExpertLog_Number, int Error )
{ Print( " ", ExpertLog_Number, " \", \"\", 10 ) - Error #", Error, " ( ", ErrorDescription( Error ), " )" ); }

/////////////////////////////////////////////////////////////////////////////////
/**/ void _LabelCreate ( string _LabelName, int _LabelXDistance, int _LabelYDistance, int _LabelCorner = 0 )
/////////////////////////////////////////////////////////////////////////////////
// Ñëóæåáíàÿ ô-öèÿ…
// Ñîçäàíèå îáúåêòà "Òåêñòîâàÿ ìåòêà" ñ èìåíåì _LabelName.
// Êîîðäèíàòû: õ = _LabelXDistance, ó = _LabelYDistance, óãîë - _LabelCorner.
/////////////////////////////////////////////////////////////////////////////////
{
	if ( !Allow_Info ) { return(false); }

	int _GetLastError;

	if ( !ObjectCreate( _LabelName, OBJ_LABEL, 0, 0, 0 ) )
	{
		_GetLastError = GetLastError();
		if ( _GetLastError != 4200 )
		{
			Print( "( \"", _LabelName, "\", ", _LabelXDistance, ", ", _LabelYDistance, ", ", _LabelCorner ," ) - ObjectCreate( \"", _LabelName, "\", OBJ_LABEL,0,0,0 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			return(-1);
		}
	}
	if ( !ObjectSet( _LabelName, OBJPROP_CORNER, _LabelCorner ) )
	{
		_GetLastError = GetLastError();
		Print(_LabelName, "\", ", _LabelXDistance, ", ", _LabelYDistance, ", ", _LabelCorner ," ) - ObjectSet( \"", _LabelName, "\", OBJPROP_CORNER, ", _LabelCorner, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
	if ( !ObjectSet( _LabelName, OBJPROP_XDISTANCE, _LabelXDistance ) )
	{
		_GetLastError = GetLastError();
		Print(_LabelName, "\", ", _LabelXDistance, ", ", _LabelYDistance, ", ", _LabelCorner ," ) - ObjectSet( \"", _LabelName, "\", OBJPROP_XDISTANCE, ", _LabelXDistance, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
	if ( !ObjectSet( _LabelName, OBJPROP_YDISTANCE, _LabelYDistance ) )
	{
		_GetLastError = GetLastError();
		Print(_LabelName, "\", ", _LabelXDistance, ", ", _LabelYDistance, ", ", _LabelCorner ," ) - ObjectSet( \"", _LabelName, "\", OBJPROP_YDISTANCE, ", _LabelYDistance, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
	if ( !ObjectSetText ( _LabelName, "", 10 ) )
	{
		_GetLastError = GetLastError();
		Print(_LabelName, "\", ", _LabelXDistance, ", ", _LabelYDistance, ", ", _LabelCorner ," ) - ObjectSetText( \"", _LabelName, "\", \"\", 10 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _FileWrite ( string text )
/////////////////////////////////////////////////////////////////////////////////
// Çàïèñü text â ëîã-ôàéë.
// (…\MetaTrader 4\experts\files\_ExpertLogs\Èìÿ ýêñïåðòà( Ñèìâîë, Ïåðèîä )\ãîä.ìåñÿö.äåíü.txt )
/////////////////////////////////////////////////////////////////////////////////
{
	if ( !Allow_LogFile ) { return(0); }

	int _GetLastError;

	string file_name = "_ExpertLogs\\" + strComment + "\\" + TimeToStr( TimeLocal(), TIME_DATE ) + ".txt";
	int file_handle = FileOpen ( file_name, FILE_READ | FILE_WRITE, " " );
	
	if ( file_handle > 0 )
	{
		if ( FileSeek ( file_handle, 0, SEEK_END ) )
		{
			if ( text != "\n" && text != "\r\n" ) { text = TimeToStr( TimeLocal(), TIME_SECONDS ) + " - - - " + text; }
			if ( FileWrite ( file_handle, text ) < 0 )
			{
				_GetLastError = GetLastError();
				Print( " _FileWrite( \"" + text + "\" ) - FileWrite ( ", file_handle, ", ", text, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			}
		}
		else
		{
			_GetLastError = GetLastError();
			Print( " _FileWrite( \"" + text + "\" ) - FileSeek ( " + file_handle + ", 0, SEEK_END ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		}
		FileClose ( file_handle );
	}
	else
	{
		_GetLastError = GetLastError();
		Print( " _FileWrite( \"" + text + "\" ) - FileOpen( ", file_name, ", FILE_READ | FILE_WRITE, \" \" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _MagicNumber( int Expert_Id, int _Period )
/////////////////////////////////////////////////////////////////////////////////
// Ô-öèÿ ãåíåðèðóåò MagicNumber, óíèêàëüíûé äëÿ ñâÿçêè Expert_Id - _Period.
// 
// Òàêèì îáðàçîì, äàæå ñ îäèíàêîâûì Expert_Id ýêñïåðòû, ðàáîòàþùèå íà ðàçíûõ ÒÔ áóäóò èñïîëüçîâàòü ðàçíûå MagicNumber.
// Íàïðèìåð, ïðè Expert_Id = 1230 è _Period = PERIOD_H1,  MagicNumber áóäåò 12305
// À ýòîò æå ýêñïåðò, íî íà ãðàôèêå ñ ïåðèîäîì PERIOD_W1 áóäåò èìåòü MagicNumber = 12308
/////////////////////////////////////////////////////////////////////////////////
{
	return( Expert_Id );

	// ñòàðûé òåêñò ôóíêöèè:
	int Period_Id = 0;
	switch ( _Period )
	{
		case PERIOD_MN1: Period_Id = 9; break;
		case PERIOD_W1:  Period_Id = 8; break;
		case PERIOD_D1:  Period_Id = 7; break;
		case PERIOD_H4:  Period_Id = 6; break;
		case PERIOD_H1:  Period_Id = 5; break;
		case PERIOD_M30: Period_Id = 4; break;
		case PERIOD_M15: Period_Id = 3; break;
		case PERIOD_M5:  Period_Id = 2; break;
		case PERIOD_M1:  Period_Id = 1; break;
		default: Print( " _MagicNumber( ", Expert_Id, ", ", _Period, " ) - Invalid Period!" );
	}
	return(Expert_Id * 10 + Period_Id);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ bool _IsExpertOrder ( int _MagicNumber )
/////////////////////////////////////////////////////////////////////////////////
// Ïîèñê ïîçèöèè/îðäåðà ñ çàäàííûì _MagicNumber è ñ òåêóùèì Ñèìâîëîì.
// Åñëè òàêîé åñòü, âûâîäèò èíôîðìàöèþ è âîçâðàùàåò true, åñëè íåò - âîçâðàùàåò false.
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;

	int _OrdersTotal = OrdersTotal();
	for ( int z = _OrdersTotal - 1; z >= 0; z -- )
	{
		if ( !OrderSelect( z, SELECT_BY_POS ) )
		{
			_GetLastError = GetLastError();
			Print( " _IsExpertOrder( ", _MagicNumber, " ) - OrderSelect( ", z, ", SELECT_BY_POS ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			continue;
		}
		if ( OrderMagicNumber() == _MagicNumber && OrderSymbol() == _Symbol )
		{
			if ( !Allow_Info ) { return(true); }

			int		_OrderTicket			= OrderTicket();
			int		_OrderType				= OrderType();
			string	_OrderSymbol			= OrderSymbol();
			double	_OrderLots				= NormalizeDouble( OrderLots(), 2 );
			double	_OrderOpenPrice		= NormalizeDouble( OrderOpenPrice(), _Digits );
			double	_OrderStopLoss			= NormalizeDouble( OrderStopLoss(), _Digits );
			double	_OrderProfit			= OrderProfit();

			_info ( 10, "" );
			_info ( 11, "" );
			_info ( 12, "" );
			_info ( 13, "" );
			_info ( 14, "" );

			if ( _OrderType <= OP_SELL )
			{
				double ProfitLoss = _OrderProfit + OrderSwap() + OrderCommission();
				double Point_Cost = LotCost( _OrderSymbol ) * _OrderLots;

				int _profit_color = 0;
				if ( ProfitLoss > 0 ) { _profit_color = 2; }
				if ( ProfitLoss < 0 ) { _profit_color = 3; }

				double ProfitLossPoints = MathAbs( _OrderProfit / Point_Cost );

				double MaxLossPoints;
				if ( _OrderType == OP_BUY )
				{ MaxLossPoints = ( _OrderStopLoss - _OrderOpenPrice ) / _Point; }
				else
				{ MaxLossPoints = ( _OrderOpenPrice - _OrderStopLoss ) / _Point; }
				double MaxLoss = MaxLossPoints * Point_Cost + OrderSwap() + OrderCommission();

				string ifNoStopLoss = DoubleToStr( MaxLoss, 2 ) + " " + AccountCurrency() + " (" + DoubleToStr( MathAbs( MaxLossPoints ), 0 ) + " points)";
				int _maxloss_color = 0;
				if ( MaxLossPoints > 0 ) { _maxloss_color = 2; }
				if ( MaxLossPoints < 0 ) { _maxloss_color = 3; }
				if ( _OrderStopLoss <= 0 ) { _maxloss_color = 1; ifNoStopLoss = "Ñòîï Ëîññ ÍÅ ÓÑÒÀÍÎÂËÅÍ!"; }
				
				_info ( 1, stringOpenedPosition, 0, 0 );
				_info ( 2, "#" + _OrderTicket + " - " + strOrderType ( _OrderType )	+ ",  " + DoubleToStr( _OrderLots, 2 ) + " lot(s)", 0, 0 );
				_info ( 3, "Ïðèáûëü/Óáûòîê:  " + DoubleToStr( ProfitLoss, 2 ) + " " + AccountCurrency() + " (" + DoubleToStr( ProfitLossPoints, 0 ) + " points)"		, _profit_color	, 0 );
				_info ( 4, "Äî ÑòîïËîññà:  " + " " + " " + " " + " " + ifNoStopLoss, _maxloss_color	, 0 );
			}
			else
			{
				int		_before_color	= 0;
				double	Price				= NormalizeDouble( MarketInfo( _OrderSymbol, MODE_BID ), _Digits );
				string	tmp_str			= ", Bid = " + DoubleToStr( Price, _Digits );
				if ( _OrderType == OP_BUYLIMIT || _OrderType == OP_BUYSTOP )
				{
					Price = NormalizeDouble( MarketInfo( _OrderSymbol, MODE_ASK ), _Digits );
					tmp_str = ", Ask = " + DoubleToStr( Price, _Digits );
				}

				if ( MathAbs( _OrderOpenPrice - Price ) / _Point <= 10 ) { _before_color = 1; }
			
				_info ( 1, _OrderSymbol + stringOpenedOrder																	, 0				, 0 );	
				_info ( 2, "¹ " + _OrderTicket + " - " + strOrderType ( _OrderType )								, 0				, 0 );
				_info ( 3, "Open Price = " + DoubleToStr( _OrderOpenPrice, _Digits )  + tmp_str					, 0				, 0 );
				_info	( 4, stringPointBefore + DoubleToStr( MathAbs( _OrderOpenPrice - Price ) / _Point, 0 ) , _before_color, 0 );
			}
			return(true);
		}
	}
return(false);
}

int _ExpertOrders = 0; int _MarketOrders = 0; int _PendingOrders = 0;
int _BuyTicket = 0; double _BuyLots = 0.0; double _BuyOpenPrice = 0.0; double _BuyStopLoss = 0.0; double _BuyTakeProfit = 0.0; datetime _BuyOpenTime = -1; double _BuyProfit = 0.0; double _BuySwap = 0.0; double _BuyCommission = 0.0; string _BuyComment = ""; 
int _SellTicket = 0; double _SellLots = 0.0; double _SellOpenPrice = 0.0; double _SellStopLoss = 0.0; double _SellTakeProfit = 0.0; datetime _SellOpenTime = -1; double _SellProfit = 0.0; double _SellSwap = 0.0; double _SellCommission = 0.0; string _SellComment = ""; 
int _BuyStopTicket = 0; double _BuyStopLots = 0.0; double _BuyStopOpenPrice = 0.0; double _BuyStopStopLoss = 0.0; double _BuyStopTakeProfit = 0.0; datetime _BuyStopOpenTime = -1; string _BuyStopComment = ""; datetime _BuyStopExpiration = -1;
int _SellStopTicket = 0; double _SellStopLots = 0.0; double _SellStopOpenPrice = 0.0; double _SellStopStopLoss = 0.0; double _SellStopTakeProfit = 0.0; datetime _SellStopOpenTime = -1; string _SellStopComment = ""; datetime _SellStopExpiration = -1;
int _BuyLimitTicket = 0; double _BuyLimitLots = 0.0; double _BuyLimitOpenPrice = 0.0; double _BuyLimitStopLoss = 0.0; double _BuyLimitTakeProfit = 0.0; datetime _BuyLimitOpenTime = -1; string _BuyLimitComment = ""; datetime _BuyLimitExpiration = -1;
int _SellLimitTicket = 0; double _SellLimitLots = 0.0; double _SellLimitOpenPrice = 0.0; double _SellLimitStopLoss = 0.0; double _SellLimitTakeProfit = 0.0; datetime _SellLimitOpenTime = -1; string _SellLimitComment = ""; datetime _SellLimitExpiration = -1;

/////////////////////////////////////////////////////////////////////////////////
/**/ void _ExpertOrdersInit( int _MagicNumber )
/////////////////////////////////////////////////////////////////////////////////
// Ìîæíî èñïîëüçîâàòü, åñëè ýêñïåðò óñòàíàâëèâàåò ìàêñèìóì ÎÄÈÍ îðäåð îäíîãî òèïà (OP_BUY, OP_SELL, è ò.ä.)
// Ïðèñâàèâàåò çíà÷åíèÿ ïåðåìåííûì, ïåðå÷èñëåííûì âûøå. Èõ ìîæíî èñïîëüçîâàòü èç ýêñïåðòà äëÿ óïðîùåíèÿ êîäà.
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;

	_ExpertOrders = 0; _MarketOrders = 0; _PendingOrders = 0;
	_BuyTicket = 0; _BuyLots = 0.0; _BuyOpenPrice = 0.0; _BuyStopLoss = 0.0; _BuyTakeProfit = 0.0; _BuyOpenTime = -1; _BuyProfit = 0.0; _BuySwap = 0.0; _BuyCommission = 0.0; _BuyComment = "";
	_SellTicket = 0; _SellLots = 0.0; _SellOpenPrice = 0.0; _SellStopLoss = 0.0; _SellTakeProfit = 0.0; _SellOpenTime = -1; _SellProfit = 0.0; _SellSwap = 0.0; _SellCommission = 0.0; _SellComment = "";
	_BuyStopTicket = 0; _BuyStopLots = 0.0; _BuyStopOpenPrice = 0.0; _BuyStopStopLoss = 0.0; _BuyStopTakeProfit = 0.0; _BuyStopOpenTime = -1; _BuyStopComment = ""; _BuyStopExpiration = -1;
	_SellStopTicket = 0; _SellStopLots = 0.0; _SellStopOpenPrice = 0.0; _SellStopStopLoss = 0.0; _SellStopTakeProfit = 0.0; _SellStopOpenTime = -1; _SellStopComment = ""; _SellStopExpiration = -1;
	_BuyLimitTicket = 0; _BuyLimitLots = 0.0; _BuyLimitOpenPrice = 0.0; _BuyLimitStopLoss = 0.0; _BuyLimitTakeProfit = 0.0; _BuyLimitOpenTime = -1; _BuyLimitComment = ""; _BuyLimitExpiration = -1;
	_SellLimitTicket = 0; _SellLimitLots = 0.0; _SellLimitOpenPrice = 0.0; _SellLimitStopLoss = 0.0; _SellLimitTakeProfit = 0.0; _SellLimitOpenTime = -1; _SellLimitComment = ""; _SellLimitExpiration = -1;

	int _OrdersTotal = OrdersTotal();
	for ( int z = _OrdersTotal - 1; z >= 0; z -- )
	{
		if ( !OrderSelect( z, SELECT_BY_POS ) )
		{
			_GetLastError = GetLastError();
			Print( " _ExpertOrdersInit( ", _MagicNumber, " ) - OrderSelect( ", z, ", SELECT_BY_POS ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			continue;
		}
		if ( OrderMagicNumber() == _MagicNumber && OrderSymbol() == _Symbol )
		{
			int		_OrderType			= OrderType();
			int		_OrderTicket		= OrderTicket();
			double	_OrderLots			= NormalizeDouble( OrderLots(), 2 );
			double	_OrderOpenPrice	= NormalizeDouble( OrderOpenPrice(), _Digits );
			double	_OrderStopLoss		= NormalizeDouble( OrderStopLoss(), _Digits );
			double	_OrderTakeProfit	= NormalizeDouble( OrderTakeProfit(), _Digits );
			datetime	_OrderOpenTime		= OrderOpenTime();
			double	_OrderProfit		= NormalizeDouble( OrderProfit(), 2 );
			double	_OrderSwap			= NormalizeDouble( OrderSwap(), 2 );
			double	_OrderCommission	= NormalizeDouble( OrderCommission(), 2 );
			string	_OrderComment		= OrderComment();
			datetime	_OrderExpiration	= OrderExpiration();

			if ( _OrderType == OP_BUY			) { _MarketOrders ++; _BuyTicket = _OrderTicket; _BuyLots = _OrderLots; _BuyOpenPrice = _OrderOpenPrice; _BuyStopLoss = _OrderStopLoss; _BuyTakeProfit = _OrderTakeProfit; _BuyOpenTime = _OrderOpenTime; _BuyProfit = _OrderProfit; _BuySwap = _OrderSwap; _BuyCommission = _OrderCommission; _BuyComment = _OrderComment; }
			if ( _OrderType == OP_SELL			) { _MarketOrders ++; _SellTicket = _OrderTicket; _SellLots = _OrderLots; _SellOpenPrice = _OrderOpenPrice; _SellStopLoss = _OrderStopLoss; _SellTakeProfit = _OrderTakeProfit; _SellOpenTime = _OrderOpenTime; _SellProfit = _OrderProfit; _SellSwap = _OrderSwap; _SellCommission = _OrderCommission; _SellComment = _OrderComment; }
			if ( _OrderType == OP_BUYSTOP		) { _PendingOrders ++; _BuyStopTicket = _OrderTicket; _BuyStopLots = _OrderLots; _BuyStopOpenPrice = _OrderOpenPrice; _BuyStopStopLoss = _OrderStopLoss; _BuyStopTakeProfit = _OrderTakeProfit; _BuyStopOpenTime = _OrderOpenTime; _BuyStopComment = _OrderComment; _BuyStopExpiration = _OrderExpiration; }
			if ( _OrderType == OP_SELLSTOP	) { _PendingOrders ++; _SellStopTicket = _OrderTicket; _SellStopLots = _OrderLots; _SellStopOpenPrice = _OrderOpenPrice; _SellStopStopLoss = _OrderStopLoss; _SellStopTakeProfit = _OrderTakeProfit; _SellStopOpenTime = _OrderOpenTime; _SellStopComment = _OrderComment; _SellStopExpiration = _OrderExpiration; }
			if ( _OrderType == OP_BUYLIMIT	) { _PendingOrders ++; _BuyLimitTicket = _OrderTicket; _BuyLimitLots = _OrderLots; _BuyLimitOpenPrice = _OrderOpenPrice; _BuyLimitStopLoss = _OrderStopLoss; _BuyLimitTakeProfit = _OrderTakeProfit; _BuyLimitOpenTime = _OrderOpenTime; _BuyLimitComment = _OrderComment; _BuyLimitExpiration = _OrderExpiration; }
			if ( _OrderType == OP_SELLLIMIT	) { _PendingOrders ++; _SellLimitTicket = _OrderTicket; _SellLimitLots = _OrderLots; _SellLimitOpenPrice = _OrderOpenPrice; _SellLimitStopLoss = _OrderStopLoss; _SellLimitTakeProfit = _OrderTakeProfit; _SellLimitOpenTime = _OrderOpenTime; _SellLimitComment = _OrderComment; _SellLimitExpiration = _OrderExpiration; }
		}
	}
	_ExpertOrders = _MarketOrders + _PendingOrders;
}

// ô-öèÿ minri, äîðàáîòàííàÿ ìíîé
/////////////////////////////////////////////////////////////////////////////////
/**/ double LotCost ( string _Symbol )
/////////////////////////////////////////////////////////////////////////////////
{
	if ( MarketInfo ( _Symbol, MODE_BID ) <= 0 ) { return(-1.0); }
	double Cost = -1.0;

	string FirstPart  = StringSubstr( _Symbol, 0, 3 );
	string SecondPart = StringSubstr( _Symbol, 3, 3 );

	double Base = MarketInfo ( _Symbol, MODE_LOTSIZE ) * MarketInfo ( _Symbol, MODE_POINT );
	if ( SecondPart == "USD" )
	{ Cost = Base; }
	else
	{
		if ( FirstPart == "USD" )
		{ Cost = Base / MarketInfo ( _Symbol, MODE_BID ); }
		else
		{
			if ( MarketInfo( "USD" + SecondPart, MODE_BID ) > 0 )
			{ Cost = Base / MarketInfo( "USD" + SecondPart, MODE_BID ); }
			else
			{ Cost = Base * MarketInfo( SecondPart + "USD", MODE_BID ); }
		}
	}
	return( NormalizeDouble(Cost, 2) );
}

string	Send_Symbol = "", Send_Comment = "";
int		Send_OrderType = 0, Send_Slippage = 0, Send_MagicNumber = 0, Send_StartTickCount = 0, Send_GetLastError = 0;
double	Send_Volume = 0.0, Send_OpenPrice = 0.0, Send_StopLoss = 0.0, Send_TakeProfit = 0.0;
datetime	Send_Expiration = 0;
color		Send_Color = CLR_NONE;
int		Send_Result = -1;

/////////////////////////////////////////////////////////////////////////////////
/**/ int _OrderSend ( string _Symbol, int _OrderType, double _Volume, double _OpenPrice, int _Slippage = -1, double _StopLoss = 0.0, double _TakeProfit = 0.0, string _Comment = "", int _MagicNumber = 0, datetime _Expiration = 0, color _Color = -2 )
/////////////////////////////////////////////////////////////////////////////////
// Ñòàíäàðòíàÿ ô-öèÿ OrderSend + ïðîâåðêà çíà÷åíèé.
// Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò OrderTicket, ïðè îøèáêå óñòàíîâêè âîçâðàùàåò "-1",
// ïðè îøèáêå ïðîâåðêè âîçâðàùàåò "-2". Åñëè ýêñïåðòó çàïðåùåíà òîðãîâëÿ, âîçâðàùàåò "-3".
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Send_Symbol = _Symbol; Send_Comment = _Comment;
	Send_OrderType = _OrderType; Send_Slippage = _Slippage; Send_MagicNumber = _MagicNumber; Send_StartTickCount = GetTickCount();
	Send_Volume = _Volume; Send_OpenPrice = _OpenPrice; Send_StopLoss = _StopLoss; Send_TakeProfit = _TakeProfit;
	Send_Expiration = _Expiration;
	Send_Color = _Color;
	Send_Result = -1;
	StartTime = TimeLocal();

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ
	_OrderSend_SetValue();

//---- Âûâîäèì èíôîðìàöèþ
	_OrderSend_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	if ( _OrderSend_Check() == false ) { return(-2); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(1);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû,
	if ( GetTickCount() - Send_StartTickCount > 1000 )
	{
//---- îáíîâëÿåì ïåðåìåííûå
		_OrderSend_RefreshValue();
//---- è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
		if ( _OrderSend_Check() == false ) { TradeIsNotBusy(); return(-2); }
	}

//---- Ñîáñòâåííî, îòêðûâàåìñÿ
	Send_Result = OrderSend ( Send_Symbol, Send_OrderType, Send_Volume, Send_OpenPrice, Send_Slippage, Send_StopLoss, Send_TakeProfit, Send_Comment, Send_MagicNumber, Send_Expiration, Send_Color );
	Send_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( Send_Result < 0 || Send_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Send_GetLastError, "OrderSend" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê,
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 1, "Error", Send_GetLastError, ErrorDescription( Send_GetLastError ), "OrderSend(...)", "Error #" + Send_GetLastError + " ( " + ErrorDescription( Send_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}
//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê,
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè îòêðûëàñü ïîçèöèÿ è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -4.
	int _GetLastError;
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( OrderSelect( Send_Result, SELECT_BY_TICKET ) ) { break; }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 ) { _Print_ ( 1, "OrderSelect( " + Send_Result + ", SELECT_BY_TICKET )", "Error #" + _GetLastError + " ( " + ErrorDescription( _GetLastError ) + " )" ); continue; }
		Processing_Error ( 0, "OrderSend" );
		_Return_ ( 1, "Error", 0, "Îðäåð íå áûë óñòàíîâëåí/Ïîçèöèÿ íå áûëà îòêðûòà", "OrderSend(...)", "Îðäåð íå áûë óñòàíîâëåí/Ïîçèöèÿ íå áûëà îòêðûòà" );
		return(-4);
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_OrderSend_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 1, "OK", 0, "", "OrderSend(...)", "OK. Ticket " + Send_Result );
//---- è âûõîäèì, âîçâðàùàÿ ¹ òèêåòà.
return(Send_Result);
}

void _OrderSend_SetValue ()
{
//---- Ïðîâåðÿåì _Slippage
	if ( Send_Slippage < 0 ) { Send_Slippage = Slippage; }
//---- Åñëè _Comment íå çàäàâàëñÿ, íàïèøåì "Èìÿ_Ýêñïåðòà( Ñèìâîë, Òàéìôðåéì )"
	if ( Send_Comment == "" ) { Send_Comment = strComment; }
//---- Åñëè öâåò íå çàäàâàëñÿ, óñòàíàâëèâàåì OrderSellColor(äëÿ "êîðîòêèõ" ïîçèöèé) èëè OrderBuyColor(äëÿ "äëèííûõ" ïîçèöèé)
	if ( Send_Color < -1 )
	{
		Send_Color = OrderSellColor;
		if ( Send_OrderType == OP_BUY || Send_OrderType == OP_BUYLIMIT || Send_OrderType == OP_BUYSTOP )
		{ Send_Color = OrderBuyColor; }
	}
	else
	{
		if ( Send_Color < 0 ) Send_Color = CLR_NONE;
	}

//---- Âûñòàâëÿåì öåíó îòêðûòèÿ è óäàëÿåì âðåìÿ èñòå÷åíèÿ äëÿ BUY è SELL ïîçèöèé
	if ( Send_OrderType == OP_BUY ) { Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits ); Send_Expiration = 0; }
	if ( Send_OrderType == OP_SELL ) { Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits ); Send_Expiration = 0; }

//	Send_Volume = NormalizeDouble( Send_Volume, 2 );
	Send_OpenPrice = NormalizeDouble( Send_OpenPrice, _Digits );
	Send_StopLoss = NormalizeDouble( Send_StopLoss, _Digits );
	Send_TakeProfit = NormalizeDouble( Send_TakeProfit, _Digits );
}
void _OrderSend_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }
	string str_tmp = stringSendingOrder + strOrderType ( Send_OrderType ) + stringSendingOrder1;
	if ( Send_OrderType <= OP_SELL )
	{ str_tmp = stringSendingPosition + strOrderType ( Send_OrderType ) + stringSendingPosition1; }
	int _OrderType_ColorVariant = 3;
	if ( Send_OrderType == OP_BUY || Send_OrderType == OP_BUYLIMIT || Send_OrderType == OP_BUYSTOP ) { _OrderType_ColorVariant = 2; }

	_FileWrite ( "- - - - - - - - - - - - - - - - - OrderSend Start- - - - - - - - - - - - - - - - - - -" );
	_info ( 10, str_tmp, _OrderType_ColorVariant );
	_info ( 1, "Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
	_info ( 2, "Stop Loss = " + DoubleToStr( Send_StopLoss, _Digits ) );
	_info ( 3, "Take Profit = " + DoubleToStr( Send_TakeProfit, _Digits ) );
	_info ( 4, "Lot(s) = " + DoubleToStr( Send_Volume, 2 ) );

	_info ( 11, "Comment = " + Send_Comment, 0, 0 );
	_info ( 12, "MagicNumber = " + Send_MagicNumber, 0, 0 );
	_info ( 13, "" );
	_info ( 14, "" );
	
	if ( Send_Expiration > 0 ) { _FileWrite ( "Expiration Time = " + TimeToStr( Send_Expiration, TIME_DATE | TIME_SECONDS ) ); }
}
bool _OrderSend_Check ()
{
	if ( Allow_Info )	{ _info ( 13, stringCheck, 0, 0 ); }

	if ( _OrderCheck( Send_Symbol, Send_OrderType, Send_Volume, Send_OpenPrice, Send_StopLoss, Send_TakeProfit, Send_Expiration ) < 0 )
	{
		if ( Allow_Info )	{ _info ( 13, stringCheckError, 1, 0 ); }
		if ( Allow_LogFile ) { _FileWrite( "Îøèáêà ïðè ïðîâåðêå ïàðàìåòðîâ!" ); }
		_Return_ ( 1, "Error", 0, stringInvalidParameters, "_OrderSend_Check()", stringInvalidParameters );
		return(false);
	}

	if ( Allow_Info ) { _info ( 13, stringCheckOK, 0, 0 ); }

return(true);
}
void _OrderSend_RefreshValue ()
{
	bool refreshed = false;
//---- Îáíîâëÿåì öåíó îòêðûòèÿ äëÿ BUY è SELL ïîçèöèé
	if ( Send_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Send_OpenPrice, _Digits ) != NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits ) )
		{
			Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - OrderSend Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
			}
		}
	}
	if ( Send_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Send_OpenPrice, _Digits ) != NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits ) )
		{
			Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - OrderSend Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
			}
		}
	}
}
void _OrderSend_SetArrow ()
{
	if ( Send_Color == CLR_NONE ) { return(0); }
	string arrow_description = Send_Comment + "\nId " + Send_MagicNumber;
	string end_name;
	switch ( Send_OrderType )
	{
		case OP_BUY:			end_name = " buy "; break;
		case OP_SELL:			end_name = " sell "; break;
		case OP_BUYLIMIT:		end_name = " buy limit "; break;
		case OP_SELLLIMIT:	end_name = " sell limit "; break;
		case OP_BUYSTOP:		end_name = " buy stop "; break;
		case OP_SELLSTOP:		end_name = " sell stop "; break;
	}
	string open_name = "#" + Send_Result + end_name + DoubleToStr( Send_Volume, 2 ) + " " + Send_Symbol + " at " + DoubleToStr( Send_OpenPrice, _Digits );
	string sl_name = open_name + " stop loss at " + DoubleToStr( Send_StopLoss, _Digits );
	string tp_name = open_name + " take profit at " + DoubleToStr( Send_TakeProfit, _Digits );

	ObjectSetText( open_name, arrow_description, 10 );
	if ( NormalizeDouble( Send_StopLoss		, _Digits ) > 0 ) ObjectSetText( sl_name, arrow_description, 10 );
	if ( NormalizeDouble( Send_TakeProfit	, _Digits ) > 0 ) ObjectSetText( tp_name, arrow_description, 10 );
	GetLastError();
}

string	Modify_Symbol = "", Modify_OrderComment = "";
int		Modify_OrderTicket = 0, Modify_OrderType = 0, Modify_OrderMagicNumber = 0, Modify_StartTickCount = 0, Modify_GetLastError = 0;
double	Modify_OrderLots = 0.0, Modify_OrderOpenPrice = 0.0, Modify_OrderStopLoss = 0.0, Modify_OrderTakeProfit = 0.0;
double	Modify_New_OpenPrice = 0.0, Modify_New_StopLoss = 0.0, Modify_New_TakeProfit = 0.0;
datetime	Modify_OrderExpiration = 0, Modify_New_Expiration = 0;
color		Modify_Color = CLR_NONE;
bool		Modify_Result = false;

/////////////////////////////////////////////////////////////////////////////////
/**/ int _OrderModify ( int _OrderTicket, double New_OpenPrice = 0.0, double New_StopLoss = 0.0, double New_TakeProfit = 0.0, datetime New_Expiration = 0, color _Color = -2 )
/////////////////////////////////////////////////////////////////////////////////
// Ñòàíäàðòíàÿ ô-öèÿ OrderModify + ïðîâåðêè.
// Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò "1", ïðè îøèáêå ìîäèôèêàöèè âîçâðàùàåò "-1",
// ïðè îøèáêå âûáîðà îðäåðà âîçâðàùàåò "-2", ïðè îøèáêå ïðîâåðêè âîçâðàùàåò "-3".
// Åñëè ýêñïåðòó çàïðåùåíà òîðãîâëÿ, âîçâðàùàåò "-4", åñëè íåò ïàðàìåòðîâ äëÿ ìîäèôèêàöèè, âîçâðàùàåò "0".
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Modify_Symbol = ""; Modify_OrderComment = "";
	Modify_OrderTicket = _OrderTicket; Modify_OrderType = 0; Modify_OrderMagicNumber = 0; Modify_StartTickCount = GetTickCount();
	Modify_OrderLots = 0.0; Modify_OrderOpenPrice = 0.0; Modify_OrderStopLoss = 0.0; Modify_OrderTakeProfit = 0.0;
	Modify_New_OpenPrice = NormalizeDouble( New_OpenPrice, _Digits ); Modify_New_StopLoss = NormalizeDouble( New_StopLoss, _Digits ); Modify_New_TakeProfit = NormalizeDouble( New_TakeProfit, _Digits );
	Modify_OrderExpiration = 0; Modify_New_Expiration = New_Expiration;
	Modify_Color = _Color;
	Modify_Result = false;
	StartTime = TimeLocal();

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ, åñëè îøèáêà ïðè âûáîðå îðäåðà - âûõîäèì
	if ( _OrderModify_SetValue() == false ) { return(-2); }

//---- Âûâîäèì èíôîðìàöèþ
	_OrderModify_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	int Check = _OrderModify_Check();
	if ( Check < 0 ) { return(Check); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(2);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû, îáíîâëÿåì ïåðåìåííûå è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
	if ( GetTickCount() - Modify_StartTickCount > 1000 )
	{
		if ( _OrderModify_RefreshValue() == false ) { TradeIsNotBusy(); return(-2); }
		Check = _OrderModify_Check();
		if ( Check < 0 ) { TradeIsNotBusy(); return(Check); }
	}

//---- Ñîáñòâåííî, ìîäèôèêàöèÿ
	Modify_Result = OrderModify( Modify_OrderTicket, Modify_New_OpenPrice, Modify_New_StopLoss, Modify_New_TakeProfit, Modify_New_Expiration, Modify_Color );
	Modify_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( !Modify_Result || Modify_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Modify_GetLastError, "OrderModify" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 2, "Error", Modify_GetLastError, ErrorDescription( Modify_GetLastError ), "OrderModify(...)", "Error #" + Modify_GetLastError + " ( " + ErrorDescription( Modify_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}
//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè èçìåíèëèñü ïàðàìåòðû ïîçèöèè è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -4.
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( !OrderSelect( Modify_OrderTicket, SELECT_BY_TICKET ) )
		{
			Modify_GetLastError = GetLastError();
			_Print_ ( 2, "OrderSelect( " + Modify_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Modify_GetLastError + " ( " + ErrorDescription( Modify_GetLastError ) + " )" );
			continue;
		}
		if ( 	NormalizeDouble( Modify_OrderOpenPrice,  _Digits ) != NormalizeDouble( OrderOpenPrice(),  _Digits ) ||
				NormalizeDouble( Modify_OrderStopLoss,   _Digits ) != NormalizeDouble( OrderStopLoss(),   _Digits ) ||
				NormalizeDouble( Modify_OrderTakeProfit, _Digits ) != NormalizeDouble( OrderTakeProfit(), _Digits ) ||
				Modify_OrderExpiration != OrderExpiration() )
		{ break; }
		else
		{
			Processing_Error ( 0, "OrderModify" );
			_Return_ ( 2, "Error", 0, "Îðäåð íå áûë ìîäèôèöèðîâàí/Ïîçèöèÿ íå áûëà ìîäèôèöèðîâàíà", "OrderModify(...)", "Îðäåð íå áûë ìîäèôèöèðîâàí/Ïîçèöèÿ íå áûëà ìîäèôèöèðîâàíà" );
			return(-4);
		}
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_OrderModify_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 2, "OK", 0, "", "OrderModify(...)", "OK" );

//---- è âûõîäèì, âîçâðàùàÿ 1.
return(1);
}

bool _OrderModify_SetValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Modify_OrderTicket, SELECT_BY_TICKET ) )
	{
		Modify_GetLastError = GetLastError();
		_Return_ ( 2,  "Error", Modify_GetLastError, ErrorDescription( Modify_GetLastError ), "OrderSelect( " + Modify_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Modify_GetLastError + " ( " + ErrorDescription( Modify_GetLastError ) + " )" );
		return(false);
	}

	Modify_Symbol				= OrderSymbol();
	Modify_OrderType			= OrderType();
	Modify_OrderLots			= NormalizeDouble ( OrderLots(), 2 );
	Modify_OrderOpenPrice	= NormalizeDouble ( OrderOpenPrice(), _Digits );
	Modify_OrderStopLoss		= NormalizeDouble ( OrderStopLoss(), _Digits );
	Modify_OrderTakeProfit	= NormalizeDouble ( OrderTakeProfit(), _Digits );
	Modify_OrderExpiration	= OrderExpiration();
	Modify_OrderMagicNumber = OrderMagicNumber();
	Modify_OrderComment		= OrderComment();

//---- Åñëè öâåò íå çàäàâàëñÿ, óñòàíàâëèâàåì OrderSellColor(äëÿ "êîðîòêèõ" ïîçèöèé) èëè OrderBuyColor(äëÿ "äëèííûõ" ïîçèöèé)
	if ( Modify_Color < -1 )
	{
		Modify_Color = OrderSellColor;
		if ( Modify_OrderType == OP_BUY || Modify_OrderType == OP_BUYLIMIT || Modify_OrderType == OP_BUYSTOP )
		{ Modify_Color = OrderBuyColor; }
	}
	else
	{
		if ( Modify_Color < 0 ) Modify_Color = CLR_NONE;
	}

//---- Åñëè ïàðàìåòðû äëÿ èçìåíåíèÿ íå çàäàâàëèñü, çàïîëíÿåì èõ ïàðàìåòðàìè îðäåðà
	if ( Modify_New_OpenPrice  < 0 )	{ Modify_New_OpenPrice	= NormalizeDouble( Modify_OrderOpenPrice, _Digits ); }
	if ( Modify_New_StopLoss   < 0 )	{ Modify_New_StopLoss	= NormalizeDouble( Modify_OrderStopLoss, 	_Digits ); }
	if ( Modify_New_TakeProfit < 0 )	{ Modify_New_TakeProfit	= NormalizeDouble( Modify_OrderTakeProfit, _Digits ); }
	if ( Modify_New_Expiration < 0 )	{ Modify_New_Expiration	= Modify_OrderExpiration; }

	if ( Modify_OrderType <= OP_SELL )
	{ Modify_New_OpenPrice = NormalizeDouble( Modify_OrderOpenPrice, _Digits ); Modify_New_Expiration = 0; }
	
return(true);
}
void _OrderModify_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }

	string str_tmp = "Ìîäèôèöèðóåì îðäåð ¹ ";
	if ( Modify_OrderType <= OP_SELL ) { str_tmp = "Ìîäèôèöèðóåì ïîçèöèþ ¹ "; }

	int _OpenPrice_ColorVariant = 0;
	bool _OpenPrice_FileWrite = false;
	if ( Modify_New_OpenPrice > Modify_OrderOpenPrice ) { _OpenPrice_ColorVariant = 2; _OpenPrice_FileWrite = true; }
	if ( Modify_New_OpenPrice < Modify_OrderOpenPrice ) { _OpenPrice_ColorVariant = 3; _OpenPrice_FileWrite = true; }
	int _StopLoss_ColorVariant = 0;
	bool _StopLoss_FileWrite = false;
	if ( Modify_New_StopLoss > Modify_OrderStopLoss ) { _StopLoss_ColorVariant = 2; _StopLoss_FileWrite = true; }
	if ( Modify_New_StopLoss < Modify_OrderStopLoss ) { _StopLoss_ColorVariant = 3; _StopLoss_FileWrite = true; }
	int _TakeProfit_ColorVariant = 0;
	bool _TakeProfit_FileWrite = false;
	if ( Modify_New_TakeProfit > Modify_OrderTakeProfit ) { _TakeProfit_ColorVariant = 2; _TakeProfit_FileWrite = true; }
	if ( Modify_New_TakeProfit < Modify_OrderTakeProfit ) { _TakeProfit_ColorVariant = 3; _TakeProfit_FileWrite = true; }

	_FileWrite ( " - - - - - - - - - - - - - - - - OrderModify Start - - - - - - - - - - - - - - - - - -" );
	_info ( 10, str_tmp + Modify_OrderTicket + ", " +  strOrderType( Modify_OrderType ) + "..." );
	_info ( 1, "Old Open Price = " + DoubleToStr( Modify_OrderOpenPrice, _Digits ), _OpenPrice_ColorVariant, _OpenPrice_FileWrite );
	_info ( 2, "Old Stop Loss = " + DoubleToStr( Modify_OrderStopLoss, _Digits ), _StopLoss_ColorVariant, _StopLoss_FileWrite );
	_info ( 3, "Old Take Profit = " + DoubleToStr( Modify_OrderTakeProfit, _Digits ), _TakeProfit_ColorVariant, _TakeProfit_FileWrite );
	_info ( 4, "" );

	_info ( 11, "New Open Price = " + DoubleToStr( Modify_New_OpenPrice, _Digits ), _OpenPrice_ColorVariant, _OpenPrice_FileWrite );
	_info ( 12, "New Stop Loss = " + DoubleToStr( Modify_New_StopLoss, _Digits ), _StopLoss_ColorVariant, _StopLoss_FileWrite );
	_info ( 13, "New Take Profit = " + DoubleToStr( Modify_New_TakeProfit, _Digits ), _TakeProfit_ColorVariant, _TakeProfit_FileWrite );
	_info ( 14, "" );

	if ( Modify_New_Expiration > 0 ) { _FileWrite ( "New Expiration Time = " + TimeToStr( Modify_New_Expiration, TIME_DATE | TIME_SECONDS ) ); }
}
int _OrderModify_Check ()
{
	if ( Allow_Info )	{ _info ( 14, stringCheck, 0, 0 ); }

//---- Åñëè íå÷åãî ìåíÿòü - âûõîäèì
	if ( 	NormalizeDouble( Modify_New_OpenPrice, _Digits ) == NormalizeDouble( Modify_OrderOpenPrice, _Digits ) &&
			NormalizeDouble( Modify_New_StopLoss, _Digits ) == NormalizeDouble( Modify_OrderStopLoss, _Digits ) &&
			NormalizeDouble( Modify_New_TakeProfit, _Digits ) == NormalizeDouble( Modify_OrderTakeProfit, _Digits ) &&
			Modify_New_Expiration == Modify_OrderExpiration )
	{
		if ( Allow_Info ) { _info ( 14, "Ïðîâåðÿåì ïàðàìåòðû.....Íåò íè îäíîãî ïàðàìåòðà äëÿ èçìåíåíèÿ. Ìîäèôèêàöèÿ îòìåíåíà..." ); }
		if ( Allow_LogFile ) { _FileWrite( "Íåò íè îäíîãî ïàðàìåòðà äëÿ èçìåíåíèÿ. Ìîäèôèêàöèÿ îòìåíåíà..." ); }
		_Return_ ( 2,  "Error", 0, "Íåò íè îäíîãî ïàðàìåòðà äëÿ èçìåíåíèÿ", "_OrderModify_Check()", "Íåò íè îäíîãî ïàðàìåòðà äëÿ èçìåíåíèÿ" );
		return(-1);
	}

//---- Ïðîâåðÿåì âñå ïàðàìåòðû OrderModify ( êðîìå _OrderTicket è _Color ),
//---- è åñëè åñòü îøèáêà - âûõîäèì
/*	if ( _OrderCheck( Modify_Symbol, Modify_OrderType, Modify_OrderLots, Modify_New_OpenPrice, Modify_New_StopLoss, Modify_New_TakeProfit, Modify_New_Expiration ) < 0 )
	{
		if ( Allow_Info )	{ _info ( 14, stringCheckError, 1, 0 ); }
		if ( Allow_LogFile ) { _FileWrite( "Îøèáêà ïðè ïðîâåðêå ïàðàìåòðîâ!" ); }
		_Return_ ( 2,  "Error", 0, "Îøèáêà ïðè ïðîâåðêå ïàðàìåòðîâ!", "_OrderModify_Check()", "Îøèáêà ïðè ïðîâåðêå ïàðàìåòðîâ!" );
		return(-3);
	}
*/
	if ( Allow_Info ) { _info ( 14, stringCheckOK, 0, 0 ); }

return(1);
}
bool _OrderModify_RefreshValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Modify_OrderTicket, SELECT_BY_TICKET ) )
	{
		Modify_GetLastError = GetLastError();
		_Return_ ( 2,  "Error", Modify_GetLastError, ErrorDescription( Modify_GetLastError ), "OrderSelect( " + Modify_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Modify_GetLastError + " ( " + ErrorDescription( Modify_GetLastError ) + " )" );
		return(false);
	}

	Modify_OrderLots			= NormalizeDouble ( OrderLots(), 2 );
	Modify_OrderOpenPrice	= NormalizeDouble ( OrderOpenPrice(), _Digits );
	Modify_OrderStopLoss		= NormalizeDouble ( OrderStopLoss(), _Digits );
	Modify_OrderTakeProfit	= NormalizeDouble ( OrderTakeProfit(), _Digits );
	Modify_OrderExpiration	= OrderExpiration();

	if ( Modify_New_OpenPrice  < 0 )	{ Modify_New_OpenPrice	= NormalizeDouble( Modify_OrderOpenPrice, _Digits ); }
	if ( Modify_New_StopLoss   < 0 )	{ Modify_New_StopLoss	= NormalizeDouble( Modify_OrderStopLoss, _Digits ); }
	if ( Modify_New_TakeProfit < 0 )	{ Modify_New_TakeProfit	= NormalizeDouble( Modify_OrderTakeProfit, _Digits ); }
	if ( Modify_New_Expiration < 0 )	{ Modify_New_Expiration	= Modify_OrderExpiration; }

return(true);
}
void _OrderModify_SetArrow ()
{
	if ( Modify_Color == CLR_NONE ) { return(0); }

	string arrow_description = Modify_OrderComment + "\nId " + Modify_OrderMagicNumber;
	string end_name;
	switch ( Modify_OrderType )
	{
		case OP_BUY:			end_name = " buy"; break;
		case OP_SELL:			end_name = " sell"; break;
		case OP_BUYLIMIT:		end_name = " buy limit"; break;
		case OP_SELLLIMIT:	end_name = " sell limit"; break;
		case OP_BUYSTOP:		end_name = " buy stop"; break;
		case OP_SELLSTOP:		end_name = " sell stop"; break;
	}
	end_name = end_name + " modified " + TimeToStr( CurTime() );
	
	string open_name = "#" + Modify_OrderTicket + end_name;
	string sl_name = "#" + Modify_OrderTicket + " sl modified ";
	string tp_name = "#" + Modify_OrderTicket + " tp modified ";

	if ( NormalizeDouble( Modify_New_OpenPrice, _Digits ) != NormalizeDouble( Modify_OrderOpenPrice, _Digits ) )
	{
		sl_name = sl_name + TimeToStr( CurTime() );
		tp_name = tp_name + TimeToStr( CurTime() );
	
		ObjectSetText( open_name, arrow_description, 10 );
	}
	if ( NormalizeDouble( Modify_New_StopLoss, _Digits ) != NormalizeDouble( Modify_OrderStopLoss, _Digits ) )
	{
		ObjectSetText( sl_name, arrow_description, 10 );
	}
	if ( NormalizeDouble( Modify_New_TakeProfit, _Digits ) != NormalizeDouble( Modify_OrderTakeProfit, _Digits ) )
	{
		ObjectSetText( tp_name, arrow_description, 10 );
	}
	GetLastError();
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _OrderCheck ( string _Symbol, int _OrderType, double _Volume, double _OpenPrice, double _StopLoss, double _TakeProfit, datetime _Expiration )
/////////////////////////////////////////////////////////////////////////////////
// Ïðîâåðÿåò ðàññòîÿíèÿ OP,SL,TP, îáú¸ì è âðåìÿ èñòå÷åíèÿ äëÿ ô-öèé _OrderSend è _OrderModify.
// Ïðè óñïåøíîé ïðîâåðêå âîçâðàùàåò "1", ïðè îøèáêå âîçâðàùàåò "-1".
/////////////////////////////////////////////////////////////////////////////////
{
	int		_return				= 1;
	double	_Ask					= NormalizeDouble( MarketInfo( _Symbol, MODE_ASK ), _Digits );
	double	_Bid					= NormalizeDouble( MarketInfo( _Symbol, MODE_BID ), _Digits );
	
	string	_Ask_str				= DoubleToStr( _Ask, _Digits );
	string	_Bid_str				= DoubleToStr( _Bid, _Digits );
	string	_OpenPrice_str		= DoubleToStr( _OpenPrice, _Digits );
	string	_StopLoss_str		= DoubleToStr( _StopLoss, _Digits );
	string	_TakeProfit_str	= DoubleToStr( _TakeProfit, _Digits );
	string	_Expiration_str	= TimeToStr( _Expiration, TIME_DATE|TIME_SECONDS );

// _OrderType äîëæåí áûòü îò 0 äî 5
	if ( _OrderType < 0 || _OrderType > 5 )
	{
		_info ( 4, stringInvalidOrderType + " ( " + _OrderType + " )!!!", 1 );
		Send_GetLastError = 3;
		_return = -1;
	}

// Îáü¸ì äîëæåí áûòü >= 0.1
	if ( NormalizeDouble( MarketInfo( _Symbol, MODE_MINLOT ) - _Volume, 4 ) > 0.0 || NormalizeDouble( _Volume - MarketInfo( _Symbol, MODE_MAXLOT ), 4 ) > 0.0 )
	{
		_info ( 4, "Lot(s) = " + DoubleToStr( _Volume, 4 ) + stringInvalidVolume, 1 );
		Send_GetLastError = 131;
		_return = -1;
	}



// Ïðîâåðêè âñåõ "äëèííûõ" îðäåðîâ/ïîçèöèé
	if ( _OrderType == OP_BUY || _OrderType == OP_BUYLIMIT || _OrderType == OP_BUYSTOP )
	{
// - _StopLoss (åñëè åñòü) äîëæåí áûòü íèæå _OpenPrice
		if ( NormalizeDouble( _StopLoss, _Digits ) > 0 && NormalizeDouble( (_OpenPrice - _Spread) - _StopLoss, _Digits ) < NormalizeDouble( _StopLevel, _Digits )  )
		{
			if ( NormalizeDouble( _OpenPrice - _StopLoss, _Digits ) < 0 )
			{
				_info ( 2, "Stop Loss = " + _StopLoss_str + stringIncorrectAbove + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
// - - ìèíèìàëüíûé îòñòóï - _StopLevel
			else
			{
				_info ( 2, "Stop Loss = " + _StopLoss_str + stringIncorrectTooBeside + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
			Send_GetLastError = 130;
			_return = -1;
		}
// - _TakeProfit (åñëè åñòü) äîëæåí áûòü âûøå _OpenPrice
		if ( NormalizeDouble( _TakeProfit, _Digits ) > 0 && NormalizeDouble( _TakeProfit - (_OpenPrice - _Spread), _Digits ) < NormalizeDouble( _StopLevel, _Digits )  )
		{
			if ( NormalizeDouble( _TakeProfit - _OpenPrice, _Digits ) < 0 )
			{
				_info ( 3, "Take Profit = " + _TakeProfit_str + stringIncorrectBelow + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
// - - ìèíèìàëüíûé îòñòóï - _StopLevel
			else
			{
				_info ( 3, "Take Profit = " + _TakeProfit_str + stringIncorrectTooBeside + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
			Send_GetLastError = 130;
			_return = -1;
		}
	}

// Ïðîâåðêè âñåõ "êîðîòêèõ" îðäåðîâ/ïîçèöèé
	if ( _OrderType == OP_SELL || _OrderType == OP_SELLLIMIT || _OrderType == OP_SELLSTOP )
	{
// - _StopLoss (åñëè åñòü) äîëæåí áûòü âûøå _OpenPrice
		if ( NormalizeDouble( _StopLoss, _Digits ) > 0 && NormalizeDouble( _StopLoss - (_OpenPrice + _Spread), _Digits ) < NormalizeDouble( _StopLevel, _Digits )  )
		{
			if ( NormalizeDouble( _StopLoss - _OpenPrice, _Digits ) < 0 )
			{
				_info ( 2, "Stop Loss = " + _StopLoss_str + stringIncorrectBelow + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
// - - ìèíèìàëüíûé îòñòóï - _StopLevel
			else
			{
				_info ( 2, "Stop Loss = " + _StopLoss_str + stringIncorrectTooBeside + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
			Send_GetLastError = 130;
			_return = -1;
		}
// - _TakeProfit (åñëè åñòü) äîëæåí áûòü íèæå _OpenPrice
		if ( NormalizeDouble( _TakeProfit, _Digits ) > 0 && NormalizeDouble( (_OpenPrice + _Spread) - _TakeProfit, _Digits ) < NormalizeDouble( _StopLevel, _Digits )  )
		{
			if ( NormalizeDouble( _OpenPrice - _TakeProfit, _Digits ) < 0 )
			{
				_info ( 3, "Take Profit = " + _TakeProfit_str + stringIncorrectAbove + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
// - - ìèíèìàëüíûé îòñòóï - _StopLevel
			else
			{
				_info ( 3, "Take Profit = " + _TakeProfit_str + stringIncorrectTooBeside + " OpenPrice = " + _OpenPrice_str + ")!!!", 1 );
			}
			Send_GetLastError = 130;
			_return = -1;
		}
	}

// - Âðåìÿ èñòå÷åíèÿ
// - - Ìàðêåò-îðäåðà - âðåìÿ èñòå÷åíèÿ äîëæíî áûòü = 0
	if ( _OrderType <= OP_SELL )
	{
		if ( _Expiration != 0 )
		{
			_info ( 4, "Expiration Time = " + _Expiration_str + stringInvalidExpiration, 1 );
			Send_GetLastError = 3;
			_return = -1;
		}
	}
// - - Îòëîæåííûå îðäåðà - âðåìÿ èñòå÷åíèÿ (åñëè åñòü) äîëæíî áûòü > òåêóùåãî ñåðâåðíîãî âðåìåíè
	else
	{
		if ( _Expiration > 0 && _Expiration <= CurTime() )
		{
			_info ( 4, "Expiration Time = " + _Expiration_str + stringIncorrectExpiration, 1 );
			Send_GetLastError = 3;
			_return = -1;
		}
	}

// åñëè åñòü õîòü îäíà îøèáêà, âîçâðàùàåì -1
// åñëè âñå ïðîâåðêè ïðîøëè óñïåøíî, âîçâðàùàåì 1
return(_return);
}

string	Close_OrderSymbol = "", Close_ProfitLoss = "", Close_OrderComment = "";
int		Close_OrderTicket = 0, Close_OrderType = 0, Close_OrderMagicNumber = 0, Close_Slippage = 0, Close_StartTickCount = 0, Close_GetLastError = 0;
double	Close_Volume = 0.0, Close_OrderLots = 0.0, Close_OrderOpenPrice = 0.0, Close_ClosePrice = 0.0;
color		Close_Color = CLR_NONE;
bool		Close_Result = false;

/////////////////////////////////////////////////////////////////////////////////
/**/ int _OrderClose ( int _OrderTicket, double _Volume = 0.0, double ClosePrice = 0.0, int _Slippage = -1, color _Color = -2 )
/////////////////////////////////////////////////////////////////////////////////
// Ñòàíäàðòíàÿ ô-öèÿ OrderClose + ïðîâåðêè.
//
// Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò "1", ïðè îøèáêå çàêðûòèÿ âîçâðàùàåò "-1",
// ïðè îøèáêå âûáîðà îðäåðà âîçâðàùàåò "-2", ïðè îøèáêå ïðîâåðêè âîçâðàùàåò "-3".
// Åñëè ýêñïåðòó çàïðåùåíà òîðãîâëÿ, âîçâðàùàåò "-4".
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Close_OrderSymbol = ""; Close_ProfitLoss = ""; Close_OrderComment = "";
	Close_OrderTicket = _OrderTicket; Close_OrderType = 0; Close_OrderMagicNumber = 0; Close_Slippage = _Slippage; Close_StartTickCount = GetTickCount();
	Close_Volume = _Volume; Close_OrderLots = 0.0; Close_OrderOpenPrice = 0.0; Close_ClosePrice = ClosePrice;
	Close_Color = _Color;
	Close_Result = false;
	StartTime = TimeLocal();

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ, åñëè îøèáêà ïðè âûáîðå îðäåðà - âûõîäèì
	if ( _OrderClose_SetValue() == false ) { return(-2); }

//---- Âûâîäèì èíôîðìàöèþ
	_OrderClose_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	if ( _OrderClose_Check() == false ) { return(-3); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(3);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû, îáíîâëÿåì ïåðåìåííûå è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
	if ( GetTickCount() - Close_StartTickCount > 1000 )
	{
		if ( _OrderClose_RefreshValue() == false ) { TradeIsNotBusy(); return(-2); }
		if ( _OrderClose_Check() == false ) { TradeIsNotBusy(); return(-3); }
	}

//---- Ñîáñòâåííî, çàêðûâàåìñÿ
	Close_Result = OrderClose( Close_OrderTicket, Close_Volume, Close_ClosePrice, Close_Slippage, Close_Color );
	Close_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( !Close_Result || Close_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Close_GetLastError, "OrderClose" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 3, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "OrderClose(...)", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}

//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè çàêðûëàñü ïîçèöèÿ è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -5
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
		{
			if ( OrderCloseTime() <= 0 )
			{
				Processing_Error ( 0, "OrderClose" );
				_Return_ ( 3, "Error", 0, "Ïîçèöèÿ íå áûëà çàêðûòà", "OrderClose(...)", "Ïîçèöèÿ íå áûëà çàêðûòà" );
				return(-5);
			}
			else
			{ break; }
		}
		Close_GetLastError = GetLastError();
		_Print_ ( 3, "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_OrderClose_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 3, "OK", 0, "", "OrderClose(...)", "OK" );

//---- è âûõîäèì, âîçâðàùàÿ 1.
return(1);
}

bool _OrderClose_SetValue ()
{
//---- Ïðîâåðÿåì _Slippage
	if ( Close_Slippage < 0 ) { Close_Slippage = Slippage; }

//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
	{
		Close_GetLastError = GetLastError();
		_Return_ ( 3, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
		return(false);
	}

	Close_OrderSymbol			= OrderSymbol();
	Close_OrderType			= OrderType();
	Close_ProfitLoss			= DoubleToStr( OrderProfit() + OrderSwap() + OrderCommission(), 2 );
	Close_OrderComment		= OrderComment();
	Close_OrderMagicNumber	= OrderMagicNumber();

Close_OrderOpenPrice = OrderOpenPrice();
//---- Ïðîâåðÿåì Close_Volume - åñëè áîëüøå OrderLots èëè ìåíüøå 0.1, ñòàâèì OrderLots.
	Close_OrderLots = NormalizeDouble( OrderLots(), _Digits );
	if ( NormalizeDouble( Close_Volume, 2 ) > NormalizeDouble( Close_OrderLots, 2 ) || NormalizeDouble( Close_Volume, 2 ) < NormalizeDouble( MarketInfo( _Symbol, MODE_MINLOT ), 2 ) )
	{ Close_Volume = NormalizeDouble( Close_OrderLots, 2 ); }

//---- Âûñòàâëÿåì Close_ClosePrice
	if ( Close_OrderType == OP_SELL ) { Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_ASK ), _Digits ); }
	if ( Close_OrderType == OP_BUY ) { Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_BID ), _Digits ); }

//---- Íîðìàëèçóåì ïåðåìåííûå
	Close_Volume = NormalizeDouble( Close_Volume, 2 );

//---- Åñëè öâåò íå çàäàâàëñÿ, óñòàíàâëèâàåì OrderSellColor(äëÿ "êîðîòêèõ" ïîçèöèé) èëè OrderBuyColor(äëÿ "äëèííûõ" ïîçèöèé)
	if ( Close_Color < -1 )
	{
		Close_Color = OrderSellColor;
		if ( Close_OrderType == OP_BUY || Close_OrderType == OP_BUYLIMIT || Close_OrderType == OP_BUYSTOP )
		{ Close_Color = OrderBuyColor; }
	}
	else
	{
		if ( Close_Color < 0 ) Close_Color = CLR_NONE;
	}
	return(true);
}
void _OrderClose_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }
	int _OrderType_ColorVariant = 3;
	if ( Close_OrderType == OP_BUY || Close_OrderType == OP_BUYLIMIT || Close_OrderType == OP_BUYSTOP ) { _OrderType_ColorVariant = 2; }

	_FileWrite ( "- - - - - - - - - - - - - - - - - OrderClose Start - - - - - - - - - - - - - - - - - -" );
	_info ( 10, "Çàêðûâàåì ïîçèöèþ ¹ " + Close_OrderTicket + ", " + strOrderType ( Close_OrderType ) + "...", _OrderType_ColorVariant );
	_info ( 1, "Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
	_info ( 2, "Lot(s) = " + DoubleToStr( Close_Volume, 2 ) );
	_info ( 3, "Profit/Loss = " + Close_ProfitLoss );
	_info ( 4, "" );

	_info ( 11, "Comment = " + Close_OrderComment, 0, 0 );
	_info ( 12, "MagicNumber = " + Close_OrderMagicNumber, 0, 0 );
	_info ( 13, "" );
	_info ( 14, "" );
}
bool _OrderClose_Check ()
{
	if ( Allow_Info )	{ _info ( 13, stringCheck, 0, 0 ); }

	if ( Close_OrderType > OP_SELL )
	{
		if ( Allow_Info || Allow_LogFile )
		{
			_info ( 13, stringCheckError, 1, 0 );
			_info ( 4, "Îøèáî÷íûé OrderType() - " + Close_OrderType + ". Çàêðûòà ìîæåò áûòü òîëüêî OP_BUY èëè OP_SELL ïîçèöèÿ.", 1 );
		}
		_Return_ ( 3, "Error", 0, "Îøèáî÷íûé OrderType()", "_OrderClose_Check()", "Îøèáî÷íûé OrderType()" );
		return(false);
	}

	if ( Allow_Info ) { _info ( 13, stringCheckOK, 0, 0 ); }
return(true);
}
bool _OrderClose_RefreshValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
	{
		Close_GetLastError = GetLastError();
		_Return_ ( 3, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
		return(false);
	}

	bool refreshed = false;
	Close_OrderType = OrderType();
	Close_OrderLots = NormalizeDouble( OrderLots(), _Digits );

//---- Îáíîâëÿåì Close_ClosePrice
	if ( Close_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Close_ClosePrice, _Digits ) != NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_ASK ), _Digits ) )
		{
			Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_ASK ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - OrderClose Refresh - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
			}
		}
	}
	if ( Close_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Close_ClosePrice, _Digits ) != NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_BID ), _Digits ) )
		{
			Close_ClosePrice = NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_BID ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - OrderClose Refresh - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
			}
		}
	}

//---- Ïðîâåðÿåì Close_Volume - åñëè áîëüøå OrderLots èëè ìåíüøå 0.1, ñòàâèì OrderLots.
	if ( NormalizeDouble( Close_Volume, 2 ) > NormalizeDouble( Close_OrderLots, 2 ) || NormalizeDouble( Close_Volume, 2 ) < NormalizeDouble( MarketInfo( _Symbol, MODE_MINLOT ), 2 ) )
	{
		Close_Volume = NormalizeDouble( Close_OrderLots, 2 );
		if ( Allow_Info || Allow_LogFile )
		{
			if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - OrderClose Refresh - - - - - - - - - - - - - - - - -" ); refreshed = true; }
			_info ( 2, "Refreshed Lot(s) = " + DoubleToStr( Close_Volume, 2 ) );
		}
	}
return(true);
}
void _OrderClose_SetArrow ()
{
	if ( Close_Color == CLR_NONE ) { return(0); }
	string arrow_description = Close_OrderComment + "\nId " + Close_OrderMagicNumber;
	string end_name;
	switch ( Close_OrderType )
	{
		case OP_BUY:	end_name = " buy "; break;
		case OP_SELL:	end_name = " sell "; break;
	}
	string close_name = "#" + Close_OrderTicket + end_name + DoubleToStr( Close_Volume, 2 ) + " " + Close_OrderSymbol + " at " + DoubleToStr( Close_OrderOpenPrice, _Digits ) + " close at " + DoubleToStr( Close_ClosePrice, _Digits );

	ObjectSetText( close_name, arrow_description, 10 );
	GetLastError();
}

string	Delete_OrderComment = "";
int		Delete_OrderTicket = 0, Delete_OrderType = 0, Delete_OrderMagicNumber = 0, Delete_StartTickCount = 0, Delete_GetLastError = 0;
bool		Delete_Result = false;

/////////////////////////////////////////////////////////////////////////////////
/**/ int _OrderDelete ( int _OrderTicket )
/////////////////////////////////////////////////////////////////////////////////
// Ñòàíäàðòíàÿ ô-öèÿ OrderDelete + ïðîâåðêè.
//
// Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò "1", ïðè îøèáêå óäàëåíèÿ âîçâðàùàåò "-1",
// ïðè îøèáêå âûáîðà îðäåðà âîçâðàùàåò "-2", ïðè îøèáêå ïðîâåðêè âîçâðàùàåò "-3".
// Åñëè ýêñïåðòó çàïðåùåíà òîðãîâëÿ, âîçâðàùàåò "-4".
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Delete_OrderComment = "";
	Delete_OrderTicket = _OrderTicket; Delete_OrderType = 0; Delete_OrderMagicNumber = 0; Delete_StartTickCount = GetTickCount();
	Delete_Result = false;
	StartTime = TimeLocal();

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ, åñëè îøèáêà ïðè âûáîðå îðäåðà - âûõîäèì
	if ( _OrderDelete_SetValue() == false ) { return(-2); }

//---- Âûâîäèì èíôîðìàöèþ
	_OrderDelete_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	if ( _OrderDelete_Check() == false ) { return(-3); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(3);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû, îáíîâëÿåì ïåðåìåííûå è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
	if ( GetTickCount() - Delete_StartTickCount > 1000 )
	{
		if ( _OrderDelete_RefreshValue() == false ) { TradeIsNotBusy(); return(-2); }
		if ( _OrderDelete_Check() == false ) { TradeIsNotBusy(); return(-3); }
	}

//---- Ñîáñòâåííî, óäàëÿåì
	Delete_Result = OrderDelete( Delete_OrderTicket );
	Delete_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( !Delete_Result || Delete_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Delete_GetLastError, "OrderDelete" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 4, "Error", Delete_GetLastError, ErrorDescription( Delete_GetLastError ), "OrderDelete(...)", "Error #" + Delete_GetLastError + " ( " + ErrorDescription( Delete_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}

//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè óäàë¸í îðäåð è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -5
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		int _OrdersTotal = OrdersTotal();
		for ( int z = _OrdersTotal - 1; z >= 0; z -- )
		{
			if ( OrderSelect( z, SELECT_BY_POS ) )
			{
				if ( OrderTicket() == Delete_OrderTicket )
				{
					Processing_Error ( 0, "OrderDelete" );
					_Return_ ( 4, "Error", 0, "Îðäåð íå áûë óäàë¸í", "OrderDelete(...)", "Îðäåð íå áûë óäàë¸í" );
					return(-5);
				}
				if ( z == 0 ) { x = 5; break; }
			}
			else
			{
				Delete_GetLastError = GetLastError();
				_Print_ ( 4, "OrderSelect( " + z + ", SELECT_BY_POS )", "Error #" + Delete_GetLastError + " ( " + ErrorDescription( Delete_GetLastError ) + " )" );
			}
		}
	}

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 4, "OK", 0, "", "OrderDelete(...)", "OK" );
//---- è âûõîäèì, âîçâðàùàÿ 1.
return(1);
}

bool _OrderDelete_SetValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Delete_OrderTicket, SELECT_BY_TICKET ) )
	{
		Delete_GetLastError = GetLastError();
		_Print_ ( 4, "OrderSelect( " + Delete_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Delete_GetLastError + " ( " + ErrorDescription( Delete_GetLastError ) + " )" );
		return(false);
	}

	Delete_OrderType			= OrderType();
	Delete_OrderComment		= OrderComment();
	Delete_OrderMagicNumber	= OrderMagicNumber();

return(true);
}
void _OrderDelete_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }
	int _OrderType_ColorVariant = 3;
	if ( Delete_OrderType == OP_BUY || Delete_OrderType == OP_BUYLIMIT || Delete_OrderType == OP_BUYSTOP ) { _OrderType_ColorVariant = 2; }

	_FileWrite ( " - - - - - - - - - - - - - - - - OrderDelete Start - - - - - - - - - - - - - - - - - -" );
	_info ( 10, "Óäàëÿåì îðäåð ¹ " + Delete_OrderTicket + ", " + strOrderType ( Delete_OrderType ) + "...", _OrderType_ColorVariant );
	_info ( 1, "" );
	_info ( 2, "" );
	_info ( 3, "" );
	_info ( 4, "" );

	_info ( 11, "Comment = " + Delete_OrderComment, 0, 0 );
	_info ( 12, "MagicNumber = " + Delete_OrderMagicNumber, 0, 0 );
	_info ( 13, "" );
	_info ( 14, "" );
}
bool _OrderDelete_Check ()
{
	if ( Allow_Info )	{ _info ( 13, stringCheck, 0, 0 ); }

//---- Ïðîâåðÿåì _OrderType
	if ( Delete_OrderType <= OP_SELL )
	{
		if ( Allow_Info || Allow_LogFile )
		{
			_info ( 13, stringCheckError, 1, 0 );
			_info ( 14, "Îøèáî÷íûé OrderType() - " + Delete_OrderType + ". Óäàë¸í ìîæåò áûòü òîëüêî îòëîæåííûé îðäåð.", 1 );
		}
		_Return_ ( 4, "Error", 0, "Îøèáî÷íûé OrderType", "_OrderDelete_Check()", "Îøèáî÷íûé OrderType" );
		return(false);
	}

	if ( Allow_Info ) { _info ( 13, stringCheckOK, 0, 0 ); }

return(true);
}
bool _OrderDelete_RefreshValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Delete_OrderTicket, SELECT_BY_TICKET ) )
	{
		Delete_GetLastError = GetLastError();
		_Print_ ( 4, "OrderSelect( " + Delete_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Delete_GetLastError + " ( " + ErrorDescription( Delete_GetLastError ) + " )" );
		return(false);
	}

	Delete_OrderType = OrderType();
return(true);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _Reverse ( int _OrderTicket, int _Slippage = -1, color _CloseColor = CLR_NONE, color _SendColor = CLR_NONE )
/////////////////////////////////////////////////////////////////////////////////
// Ïåðåâîðîò. Ïîçèöèÿ ñ _OrderTicket çàêðûâàåòñÿ è îòêðûâàåòñÿ íîâàÿ ñ òàêèì æå ëîòîì íàâñòðå÷ó + ïðîâåðêè.
//
// Ïðè óñïåøíîì âûïîëíåíèè âîçâðàùàåò "1", ïðè òîðãîâîé îøèáêå âîçâðàùàåò "-1",
// ïðè îøèáêå âûáîðà îðäåðà âîçâðàùàåò "-2", ïðè îøèáêå ïðîâåðêè âîçâðàùàåò "-3".
// Åñëè ýêñïåðòó çàïðåùåíà òîðãîâëÿ, âîçâðàùàåò "-4".
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Close_OrderSymbol = ""; Close_ProfitLoss = ""; Close_OrderComment = "";
	Close_OrderTicket = _OrderTicket; Close_OrderType = 0; Close_OrderMagicNumber = 0; Close_Slippage = _Slippage; Close_StartTickCount = GetTickCount();
	Close_Volume = 0.0; Close_OrderLots = 0.0; Close_ClosePrice = 0.0;
	Close_Color = _CloseColor;
	Close_Result = false;

	Send_Symbol = ""; Send_Comment = "";
	Send_OrderType = 0; Send_Slippage = _Slippage; Send_MagicNumber = 0;
	Send_Volume = 0.0; Send_OpenPrice = 0.0; Send_StopLoss = 0.0; Send_TakeProfit = 0.0;
	Send_Expiration = 0;
	Send_Color = _SendColor;
	Send_Result = -1;

	StartTime = TimeLocal();

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ, åñëè îøèáêà ïðè âûáîðå îðäåðà - âûõîäèì
	if ( _Reverse_SetValue() == false ) { return(-2); }

//---- Âûâîäèì èíôîðìàöèþ
	_Reverse_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	if ( _Reverse_Check() == false ) { return(-3); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(5);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû, îáíîâëÿåì ïåðåìåííûå è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
	if ( GetTickCount() - Close_StartTickCount > 1000 )
	{
		if ( _Reverse_RefreshValue() == false ) { TradeIsNotBusy(); return(-2); }
		if ( _Reverse_Check() == false ) { TradeIsNotBusy(); return(-3); }
	}

//---- Ñîáñòâåííî, çàêðûâàåìñÿ
	Close_Result = OrderClose( Close_OrderTicket, Close_Volume, Close_ClosePrice, Close_Slippage, Close_Color );
	Close_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( !Close_Result || Close_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Close_GetLastError, "Reverse" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 5, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "Reverse(...)", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}
//---- Åñëè âñ¸ õîðîøî,
//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè çàêðûëàñü ïîçèöèÿ è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -5
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
		{
			if ( OrderCloseTime() <= 0 )
			{
				Processing_Error ( 0, "OrderClose" );
				_Return_ ( 5, "Error", 0, "Ïîçèöèÿ íå áûëà çàêðûòà", "Reverse(...)", "Ïîçèöèÿ íå áûëà çàêðûòà" );
				return(-5);
			}
			else
			{ break; }
		}
		Close_GetLastError = GetLastError();
		_Print_ ( 5, "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_OrderClose_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_Return_ ( 5, "OK", 0, "", "OrderClose(...)", "OK" );

//---- è îòêðûâàåìñÿ íàâñòðå÷ó
	Send_Result = OrderSend ( Send_Symbol, Send_OrderType, Send_Volume, Send_OpenPrice, Send_Slippage, Send_StopLoss, Send_TakeProfit, Send_Comment, Send_MagicNumber, Send_Expiration, Send_Color );
	Send_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( Send_Result < 0 || Send_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Send_GetLastError, "Reverse" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê,
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 5, "Error", Send_GetLastError, ErrorDescription( Send_GetLastError ), "Revers(...)", "Error #" + Send_GetLastError + " ( " + ErrorDescription( Send_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}
//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê,
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè îòêðûëàñü ïîçèöèÿ è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -4.
	int _GetLastError;
	for ( x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( OrderSelect( Send_Result, SELECT_BY_TICKET ) ) { break; }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 ) { _Print_ ( 6, "OrderSelect( " + Send_Result + ", SELECT_BY_TICKET )", "Error #" + _GetLastError + " ( " + ErrorDescription( _GetLastError ) + " )" ); continue; }
		Processing_Error ( 0, "Reverse" );
		_Return_ ( 6, "Error", 0, "Îðäåð íå áûë óñòàíîâëåí/Ïîçèöèÿ íå áûëà îòêðûòà", "Reverse(...)", "Îðäåð íå áûë óñòàíîâëåí/Ïîçèöèÿ íå áûëà îòêðûòà" );
		return(-4);
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_OrderSend_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 6, "OK", 0, "", "OrderSend(...)", "OK. Ticket " + Send_Result );
//---- è âûõîäèì, âîçâðàùàÿ ¹ òèêåòà.
return(Send_Result);
}

bool _Reverse_SetValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
	{
		Close_GetLastError = GetLastError();
		_Return_ ( 5, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
		return(false);
	}
	Close_OrderSymbol			= OrderSymbol();
	Close_OrderType			= OrderType();
	Close_Volume				= NormalizeDouble( OrderLots(), _Digits );
	Close_ProfitLoss			= DoubleToStr( OrderProfit() + OrderSwap() + OrderCommission(), 2 );
	Close_OrderComment		= OrderComment();
	Close_OrderMagicNumber	= OrderMagicNumber();

//---- Âûñòàâëÿåì Close_ClosePrice
	if ( Close_OrderType == OP_SELL ) { Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_ASK ), _Digits ); }
	if ( Close_OrderType == OP_BUY ) { Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_BID ), _Digits ); }

	Send_Symbol			= Close_OrderSymbol;
	Send_Comment		= Close_OrderComment;
	Send_MagicNumber	= Close_OrderMagicNumber;
	Send_Volume			= Close_Volume;
	Send_StopLoss		= 0.0;
	Send_TakeProfit	= 0.0;
	Send_Expiration	= 0;

	if ( Close_OrderType == OP_BUY ) { Send_OrderType = OP_SELL; }
	if ( Close_OrderType == OP_SELL ) { Send_OrderType = OP_BUY; }

//---- Âûñòàâëÿåì öåíó îòêðûòèÿ è óäàëÿåì âðåìÿ èñòå÷åíèÿ äëÿ BUY è SELL ïîçèöèé
	if ( Send_OrderType == OP_BUY ) { Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits ); }
	if ( Send_OrderType == OP_SELL ) { Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits ); }


//---- Ïðîâåðÿåì _Slippage
	if ( Send_Slippage < 0 ) { Send_Slippage = Slippage; }
	if ( Close_Slippage < 0 ) { Close_Slippage = Slippage; }
//---- Åñëè _Comment íå çàäàâàëñÿ, íàïèøåì "Èìÿ_Ýêñïåðòà( Ñèìâîë, Òàéìôðåéì )"
	if ( Send_Comment == "" ) { Send_Comment = strComment; }
//---- Åñëè öâåò íå çàäàâàëñÿ, óñòàíàâëèâàåì OrderSellColor(äëÿ "êîðîòêèõ" ïîçèöèé) èëè OrderBuyColor(äëÿ "äëèííûõ" ïîçèöèé)
	if ( Send_Color < -1 )
	{
		Send_Color = OrderSellColor;
		if ( Send_OrderType == OP_BUY || Send_OrderType == OP_BUYLIMIT || Send_OrderType == OP_BUYSTOP )
		{ Send_Color = OrderBuyColor; }
	}
	else
	{
		if ( Send_Color < 0 ) Send_Color = CLR_NONE;
	}
	if ( Close_Color < -1 )
	{
		Close_Color = OrderSellColor;
		if ( Close_OrderType == OP_BUY || Close_OrderType == OP_BUYLIMIT || Close_OrderType == OP_BUYSTOP )
		{ Close_Color = OrderBuyColor; }
	}
	else
	{
		if ( Close_Color < 0 ) Close_Color = CLR_NONE;
	}
	return(true);
}
void _Reverse_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }

	_FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Start  - - - - - - - - - - - - - - - - - -" );
	_info ( 10, "Ïåðåâîðîò ïîçèöèè ¹ " + Close_OrderTicket + ", " + strOrderType ( Close_OrderType ) + "..." );
	_info ( 1, "Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
	_info ( 2, "Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
	_info ( 3, "Lot(s) = " + DoubleToStr( Close_Volume, 1 ) );
	_info ( 4, "" );

	_info ( 11, "Comment = " + Close_OrderComment, 0, 0 );
	_info ( 12, "MagicNumber = " + Close_OrderMagicNumber, 0, 0 );
	_info ( 13, "" );
	_info ( 14, "" );
}

bool _Reverse_Check ()
{
	if ( Allow_Info )	{ _info ( 13, stringCheck, 0, 0 ); }

//---- Ïðîâåðÿåì _OrderType
	if ( Close_OrderType > OP_SELL )
	{
		if ( Allow_Info || Allow_LogFile )
		{
			_info ( 13, stringCheckError, 1, 0 );
			_info ( 4, "Îøèáî÷íûé OrderType() - " + Close_OrderType + ". Çàêðûòà ìîæåò áûòü òîëüêî OP_BUY èëè OP_SELL ïîçèöèÿ.", 1 );
		}
		_Return_ ( 5, "Error", 0, "Îøèáî÷íûé OrderType()", "_Reverse_Check()", "Îøèáî÷íûé OrderType()" );
		return(false);
	}

//---- Ïðîâåðÿåì âñå ïàðàìåòðû OrderSend ( êðîìå Send_Symbol, _Slippage, _Comment, Send_MagicNumber è Send_Color ),
//---- è åñëè åñòü îøèáêà - âûõîäèì
	if ( _OrderCheck( Send_Symbol, Send_OrderType, Send_Volume, Send_OpenPrice, Send_StopLoss, Send_TakeProfit, Send_Expiration ) < 0 )
	{
		if ( Allow_Info )	{ _info ( 13, stringCheckError, 1, 0 ); }
		if ( Allow_LogFile ) { _FileWrite( "Îøèáêà ïðè ïðîâåðêå ïàðàìåòðîâ!" ); }
		_Return_ ( 6, "Error", 0, stringInvalidParameters, "_Reverse_Check()", "Error" );
		return(false);
	}

	if ( Allow_Info ) { _info ( 13, stringCheckOK, 0, 0 ); }
return(true);
}
bool _Reverse_RefreshValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Close_OrderTicket, SELECT_BY_TICKET ) )
	{
		Close_GetLastError = GetLastError();
		_Return_ ( 5, "Error", Close_GetLastError, ErrorDescription( Close_GetLastError ), "OrderSelect( " + Close_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Close_GetLastError + " ( " + ErrorDescription( Close_GetLastError ) + " )" );
		return(false);
	}

	bool refreshed = false;
	Close_OrderType = OrderType();
	Close_Volume	 = NormalizeDouble( OrderLots(), _Digits );

//---- Îáíîâëÿåì Close_ClosePrice
	if ( Close_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Close_ClosePrice, _Digits ) != NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_ASK ), _Digits ) )
		{
			Close_ClosePrice = NormalizeDouble( MarketInfo ( Close_OrderSymbol, MODE_ASK ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
			}
		}
	}
	if ( Close_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Close_ClosePrice, _Digits ) != NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_BID ), _Digits ) )
		{
			Close_ClosePrice = NormalizeDouble( MarketInfo( Close_OrderSymbol, MODE_BID ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 1, "Refreshed Ñlose Price = " + DoubleToStr( Close_ClosePrice, _Digits ) );
			}
		}
	}

	Send_Volume = NormalizeDouble( Close_Volume, 2 );
	if ( Close_OrderType == OP_BUY ) { Send_OrderType = OP_SELL; }
	if ( Close_OrderType == OP_SELL ) { Send_OrderType = OP_BUY; }

//---- Îáíîâëÿåì öåíó îòêðûòèÿ äëÿ BUY è SELL ïîçèöèé
	if ( Send_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Send_OpenPrice, _Digits ) != NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits ) )
		{
			Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_ASK ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 2, "Refreshed Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
			}
		}
	}
	if ( Send_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Send_OpenPrice, _Digits ) != NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits ) )
		{
			Send_OpenPrice = NormalizeDouble( MarketInfo( Send_Symbol, MODE_BID ), _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 2, "Refreshed Open Price = " + DoubleToStr( Send_OpenPrice, _Digits ) );
			}
		}
	}
return(true);
}

string	Trailing_Symbol = "", Trailing_OrderComment = "";
int		Trailing_OrderTicket = 0, Trailing_TrailingStop = 0, Trailing_BreakEven_After = 0, Trailing_OrderType = 0, Trailing_OrderMagicNumber = 0, Trailing_StartTickCount = 0, Trailing_GetLastError = 0;
double	Trailing_OrderOpenPrice = 0.0, Trailing_OrderStopLoss = 0.0, Trailing_OrderTakeProfit = 0.0, Trailing_New_StopLoss = 0.0, Trailing_Bid = 0.0, Trailing_Ask = 0.0;
datetime	Trailing_OrderExpiration = 0;
color		Trailing_Color = CLR_NONE;
bool		Trailing_Result = false;

double Trailing_Luft = 0.0;

/////////////////////////////////////////////////////////////////////////////////
/**/ int _TrailingStop ( int _OrderTicket, int TrailingStop, color _Color = -2, int BreakEven_After = 0, int LuftPoints = -1 )
/////////////////////////////////////////////////////////////////////////////////
// TrailingStop + âûâîä èíôîðìàöèè
// Ïðè óñïåøíîì ñìåù¸íèè âîçâðàùàåò "1", ïðè îòñòóòñòâèè íåîáõîäèìîñòè äâèãàòü - "0", ïðè îøèáêå "-1", ïðè îøèáêå ¹ îðäåðà, âîçâðàùàåò "-2"
/////////////////////////////////////////////////////////////////////////////////
{
//---- Èíèöèàëèçàöèÿ ïåðåìåííûõ
	Trailing_Symbol = ""; Trailing_OrderComment = "";
	Trailing_OrderTicket = _OrderTicket; Trailing_TrailingStop = TrailingStop; Trailing_BreakEven_After = BreakEven_After; Trailing_OrderType = 0; Trailing_OrderMagicNumber = 0; Trailing_StartTickCount = GetTickCount();
	Trailing_OrderOpenPrice = 0.0; Trailing_OrderStopLoss = 0.0; Trailing_OrderTakeProfit = 0.0; Trailing_New_StopLoss = 0.0; Trailing_Bid = 0.0; Trailing_Ask = 0.0;
	Trailing_OrderExpiration = 0;
	Trailing_Color = _Color;
	Trailing_Result = false;
	StartTime = TimeLocal();

	if ( Trailing_TrailingStop <= 0 ) { return(0); }

	if ( LuftPoints < 0 ) { Trailing_Luft = _Spread; } else { Trailing_Luft = LuftPoints * _Point; }

//---- Èçìåíÿåì òå ïåðåìåííûå, êîòîðûå ìîæíî ìåíÿòü è íîðìàëèçóåì èõ, åñëè îøèáêà ïðè âûáîðå îðäåðà - âûõîäèì
	if ( _TrailingStop_SetValue() == false ) { return(-2); }

//---- Åñëè ïîçèöèÿ íå ïðèáûëüíàÿ, èëè ñòîïëîññ íå äîñòàòî÷íî äàëåêî îò öåíû äëÿ èçìåíåíèÿ, âûõîäèì
	if ( _TrailingStop_NoChange() == false ) { return(0); }

//---- Âûâîäèì èíôîðìàöèþ
	_TrailingStop_Info();

//---- Ïðîâåðÿåì ïàðàìåòðû. Åñëè åñòü îøèáêà - âûõîäèì
	if ( _TrailingStop_Check() == false ) { return(-1); }

//---- Âñå íåîáõîäèìûå ïðîâåðêè, ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè, etc... Åñëè åñòü îøèáêà - âûõîäèì
	int _Check_ = _Check_(7);
	if ( _Check_ < 0 ) { return(_Check_); }

//---- Åñëè ô-öèÿ ðàáîòàåò áîëüøå ñåêóíäû, îáíîâëÿåì ïåðåìåííûå è ïðîâåðÿåì èõ. Åñëè åñòü îøèáêà - âûõîäèì
	if ( GetTickCount() - Trailing_StartTickCount > 1000 )
	{
		if ( _TrailingStop_RefreshValue() == false ) { TradeIsNotBusy(); return(-2); }
		if ( _TrailingStop_Check() == false ) { TradeIsNotBusy(); return(-1); }
	}

//---- Ñîáñòâåííî, äâèãàåì
	Trailing_Result = OrderModify( Trailing_OrderTicket, Trailing_OrderOpenPrice, Trailing_New_StopLoss, Trailing_OrderTakeProfit, Trailing_OrderExpiration, Trailing_Color );
	Trailing_GetLastError = GetLastError();

//---- Åñëè åñòü îøèáêà,
	if ( !Trailing_Result || Trailing_GetLastError > 0 )
	{
//---- îòäà¸ì íà îòðàáîòêó êîä îøèáêè,
		Processing_Error ( Trailing_GetLastError, "TrailingStop" );
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
		TradeIsNotBusy();
//---- âûâîäèì èíôîðìàöèþ â _TradeLog, â æóðíàë,
		_Return_ ( 7, "Error", Trailing_GetLastError, ErrorDescription( Trailing_GetLastError ), "OrderModify(...)", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
//---- è âûõîäèì, âîçâðàùàÿ -1.
		return(-1);
	}
//---- Åñëè âñ¸ õîðîøî,
//---- îñâîáîæäàåì òîðãîâûé ïîòîê
	TradeIsNotBusy();

//---- ïðîâåðÿåì - äåéñòâèòåëüíî ëè èçìåíèëñÿ ñòîïëîññ è, åñëè íåò, âûâîäèì èíôîðìàöèþ è âûõîäèì, âîçâðàùàÿ -4.
	for ( int x = 0; x < 5; x ++ )
	{
		Sleep(1000);
		if ( !OrderSelect( Trailing_OrderTicket, SELECT_BY_TICKET ) )
		{
			Trailing_GetLastError = GetLastError();
			_Print_ ( 7, "OrderSelect( " + Trailing_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
			continue;
		}
		if ( NormalizeDouble( Trailing_OrderStopLoss, _Digits ) != NormalizeDouble( OrderStopLoss(), _Digits ) )
		{ break; }
		else
		{
			Processing_Error ( 0, "TrailingStop" );
			_Return_ ( 7, "Error", 0, "Ñòîïëîññ íå áûë ìîäèôèöèðîâàí", "OrderModify(...)", "Ñòîïëîññ íå áûë ìîäèôèöèðîâàí" );
			return(-4);
		}
	}

//---- ñîçäà¸ì îïèñàíèÿ ê ñòðåëî÷êàì,
	_TrailingStop_SetArrow();

//---- âûâîäèì èíôîðìàöèþ,
	_info ( 14, stringSuccessfully );
	_Return_ ( 7, "OK", 0, "", "OrderModify(...)", "OK" );

//---- è âûõîäèì, âîçâðàùàÿ 1.
return(1);
}

bool _TrailingStop_SetValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Trailing_OrderTicket, SELECT_BY_TICKET ) )
	{
		Trailing_GetLastError = GetLastError();
		_Return_ ( 7,  "Error", Trailing_GetLastError, ErrorDescription( Trailing_GetLastError ), "OrderSelect( " + Trailing_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
		return(false);
	}

	Trailing_Symbol				= OrderSymbol();
	Trailing_OrderComment		= OrderComment();
	Trailing_OrderType			= OrderType();
	Trailing_OrderMagicNumber	= OrderMagicNumber();
	Trailing_OrderOpenPrice		= NormalizeDouble ( OrderOpenPrice(), _Digits );
	Trailing_OrderStopLoss		= NormalizeDouble ( OrderStopLoss(), _Digits );
	Trailing_OrderTakeProfit	= NormalizeDouble ( OrderTakeProfit(), _Digits );
	Trailing_OrderExpiration	= OrderExpiration();

	Trailing_Bid					= NormalizeDouble( MarketInfo ( Trailing_Symbol, MODE_BID ), _Digits );
	Trailing_Ask					= NormalizeDouble( MarketInfo ( Trailing_Symbol, MODE_ASK ), _Digits );

//---- Åñëè öâåò íå çàäàâàëñÿ, óñòàíàâëèâàåì OrderSellColor(äëÿ "êîðîòêèõ" ïîçèöèé) èëè OrderBuyColor(äëÿ "äëèííûõ" ïîçèöèé)
	if ( Trailing_Color < -1 )
	{
		Trailing_Color = OrderSellColor;
		if ( Trailing_OrderType == OP_BUY || Trailing_OrderType == OP_BUYLIMIT || Trailing_OrderType == OP_BUYSTOP )
		{ Trailing_Color = OrderBuyColor; }
	}
	else
	{
		if ( Trailing_Color < 0 ) Trailing_Color = CLR_NONE;
	}

//---- Ñ÷èòàåì êóäà óñòàíàâëèâàòü íîâûé ñòîïëîññ
	if ( Trailing_OrderType == OP_BUY ) { Trailing_New_StopLoss = NormalizeDouble( Trailing_Bid - Trailing_TrailingStop * _Point, _Digits ); }
	if ( Trailing_OrderType == OP_SELL ) { Trailing_New_StopLoss = NormalizeDouble( Trailing_Ask + Trailing_TrailingStop * _Point, _Digits ); }

return(true);
}
bool _TrailingStop_NoChange ()
{
	if ( Trailing_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Trailing_Bid - Trailing_OrderOpenPrice, _Digits ) <= NormalizeDouble( Trailing_BreakEven_After * _Point, _Digits ) ) { return(false); }
		if ( NormalizeDouble( Trailing_OrderStopLoss, _Digits ) > 0 && NormalizeDouble( Trailing_New_StopLoss - Trailing_OrderStopLoss, _Digits ) <= NormalizeDouble( Trailing_Luft, _Digits ) ) { return(false); }
	}
	if ( Trailing_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Trailing_OrderOpenPrice - Trailing_Ask, _Digits ) <= NormalizeDouble( Trailing_BreakEven_After * _Point, _Digits ) ) { return(false); }
		if ( NormalizeDouble( Trailing_OrderStopLoss, _Digits ) > 0 && NormalizeDouble( Trailing_OrderStopLoss - Trailing_New_StopLoss, _Digits ) <= NormalizeDouble( Trailing_Luft, _Digits ) ) { return(false); }
	}
return(true);
}
void _TrailingStop_Info ()
{
	if ( !Allow_Info && !Allow_LogFile ) { return(0); }

	_FileWrite ( "- - - - - - - - - - - - - - - - TrailingStop Start - - - - - - - - - - - - - - - - - -" );

	_info ( 10, "Trailing Stop (" + Trailing_TrailingStop + " points) äëÿ ïîçèöèè ¹ " + Trailing_OrderTicket + ", " + strOrderType ( Trailing_OrderType ) + "..." );
	_info ( 1, "Old Stop Loss = " + DoubleToStr( Trailing_OrderStopLoss, _Digits ) );
	_info ( 2, "New Stop Loss = " + DoubleToStr( Trailing_New_StopLoss, _Digits ) );
	_info ( 3, "" );
	_info ( 4, "" );

	_info ( 11, "Comment = " + Trailing_OrderComment, 0, 0 );
	_info ( 12, "MagicNumber = " + Trailing_OrderMagicNumber, 0, 0 );
	_info ( 13, "" );
	_info ( 14, "" );
}
bool _TrailingStop_Check ()
{
	if ( Allow_Info )	{ _info ( 13, stringCheck, 0, 0 ); }

//---- Åñëè TrailingStop õî÷åò óñòàíîâèòü ÑË íà ðàññòîÿíèå, ìåíüøåå ìèíèìàëüíî âîçìîæíîãî, âûõîäèì.
	if ( Trailing_TrailingStop < MarketInfo( Trailing_Symbol, MODE_STOPLEVEL ) )
	{
		if ( Allow_Info ) { _info ( 13, "Ïðîâåðÿåì ïàðàìåòðû.....Íåëüçÿ óñòàíîâèòü ÑòîïËîññ òàê áëèçêî!", 1, 0 ); }
		if ( Allow_LogFile ) { _FileWrite( "Íåëüçÿ óñòàíîâèòü ÑòîïËîññ òàê áëèçêî! TrailingStop îòìåíåí..." ); }
		_Return_ ( 7, "Error", 0, "Íåëüçÿ óñòàíîâèòü ÑòîïËîññ òàê áëèçêî", "_TrailingStop_Check()", "Íåëüçÿ óñòàíîâèòü ÑòîïËîññ òàê áëèçêî" );
		return(false);
	}

	if ( Trailing_OrderType > OP_SELL )
	{
		if ( Allow_Info || Allow_LogFile )
		{
			_info ( 13, stringCheckError, 1, 0 );
			_info ( 14, "Îøèáî÷íûé OrderType() - " + Trailing_OrderType + ". Ô-öèÿ TrailingStop ïðåäíàçíà÷åíà òîëüêî äëÿ OP_BUY èëè OP_SELL ïîçèöèé.", 1 );
		}
		_Return_ ( 7, "Error", 0, "Îøèáî÷íûé OrderType()", "_TrailingStop_Check()", "Îøèáî÷íûé OrderType()" );
		return(false);
	}

	if ( Allow_Info ) { _info ( 13, stringCheckOK, 0, 0 ); }

return(true);
}
bool _TrailingStop_RefreshValue ()
{
//---- âûáèðàåì îðäåð, è åñëè âîçíèêàåò îøèáêà - âûõîäèì
	if ( !OrderSelect( Trailing_OrderTicket, SELECT_BY_TICKET ) )
	{
		Trailing_GetLastError = GetLastError();
		_Return_ ( 7,  "Error", Trailing_GetLastError, ErrorDescription( Trailing_GetLastError ), "OrderSelect( " + Trailing_OrderTicket + ", SELECT_BY_TICKET )", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
		return(false);
	}

	Trailing_Symbol				= OrderSymbol();
	Trailing_OrderComment		= OrderComment();
	Trailing_OrderType			= OrderType();
	Trailing_OrderMagicNumber	= OrderMagicNumber();
	Trailing_OrderOpenPrice		= NormalizeDouble ( OrderOpenPrice(), _Digits );
	Trailing_OrderStopLoss		= NormalizeDouble ( OrderStopLoss(), _Digits );
	Trailing_OrderTakeProfit	= NormalizeDouble ( OrderTakeProfit(), _Digits );
	Trailing_OrderExpiration	= OrderExpiration();

	Trailing_Bid					= NormalizeDouble( MarketInfo ( Trailing_Symbol, MODE_BID ), _Digits );
	Trailing_Ask					= NormalizeDouble( MarketInfo ( Trailing_Symbol, MODE_ASK ), _Digits );

	bool refreshed = false;
//---- Îáíîâëÿåì íîâûé óðîâåíü ñòîïëîññà
	if ( Trailing_OrderType == OP_BUY )
	{
		if ( NormalizeDouble( Trailing_New_StopLoss, _Digits ) != NormalizeDouble( Trailing_Bid - Trailing_TrailingStop * _Point, _Digits ) )
		{
			Trailing_New_StopLoss = NormalizeDouble( Trailing_Bid - Trailing_TrailingStop * _Point, _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - TrailingStop Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 2, "Refreshed New Stop Loss = " + DoubleToStr( Trailing_New_StopLoss, _Digits ) );
			}
		}
	}
	if ( Trailing_OrderType == OP_SELL )
	{
		if ( NormalizeDouble( Trailing_New_StopLoss, _Digits ) != NormalizeDouble( Trailing_Ask + Trailing_TrailingStop * _Point, _Digits ) )
		{
			Trailing_New_StopLoss = NormalizeDouble( Trailing_Ask + Trailing_TrailingStop * _Point, _Digits );
			if ( Allow_Info || Allow_LogFile )
			{
				if ( !refreshed ) { _FileWrite ( "- - - - - - - - - - - - - - - - TrailingStop Refresh  - - - - - - - - - - - - - - - - -" ); refreshed = true; }
				_info ( 2, "Refreshed New Stop Loss = " + DoubleToStr( Trailing_New_StopLoss, _Digits ) );
			}
		}
	}
return(true);
}
void _TrailingStop_SetArrow ()
{
	if ( Trailing_Color == CLR_NONE ) { return(0); }

	string arrow_description = Trailing_OrderComment + "\nId " + Trailing_OrderMagicNumber + "\nModified by TrailingStop";

	string sl_name = "#" + Trailing_OrderTicket + " sl modified ";
	string new_arrow = "#" + Trailing_OrderTicket + " old sl" + TimeToStr( Time[1] );

	ObjectSetText( sl_name, arrow_description, 10 );
	GetLastError();
/*	if ( ObjectCreate( new_arrow, OBJ_ARROW, 0, Time[1], Trailing_OrderStopLoss ) )
	{
		if ( !ObjectSet( new_arrow, OBJPROP_ARROWCODE, 4 ) )
		{
			Trailing_GetLastError = GetLastError();
			_Print_ ( 7, "ObjectSet( " + new_arrow + ", OBJPROP_ARROWCODE, 4 )", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
		}
		if ( !ObjectSetText( new_arrow, arrow_description, 10 ) )
		{
			Trailing_GetLastError = GetLastError();
			_Print_ ( 7, "ObjectSetText( " + new_arrow + ", " + arrow_description + ", 10 )", "Error #" + Trailing_GetLastError + " ( " + ErrorDescription( Trailing_GetLastError ) + " )" );
		}
	}*/
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _Check_( int FunctionId )
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(0); }
	int _return = 0;
//---- Ïðîâåðÿåì ñîåäèíåíèå ñ ñåðâåðîì. Åñëè IsConnected == false - âûõîäèì
	int _IsConnected = _IsConnected();
	if ( _IsConnected < 0 )
	{
		if ( _IsConnected == -1 ) { _return = -300; _Return_( FunctionId, "Error", 0, stringNoConnection, "_IsConnected()", stringNoConnection ); }
		if ( _IsConnected == -2 ) { _return = -302; _Return_( FunctionId, "Error", 0, stringStopped, "_IsConnected()", stringStopped ); }
		if ( _IsConnected == -3 ) { _return = -303; _Return_( FunctionId, "Error", 0, stringTimeOut, "_IsConnected()", stringTimeOut ); }
		return(_return);
	}

//---- Ïðîâåðÿåì IsTradeAllowed. Åñëè IsTradeAllowed == false - âûõîäèì
	int _IsTradeAllowed = _IsTradeAllowed();
	if ( _IsTradeAllowed < 0 )
	{
		if ( _IsTradeAllowed == -1 ) { _return = -301; _Return_( FunctionId, "Error", 0, stringTradeNotAllow, "_IsTradeAllowed()", stringTradeNotAllow ); }
		if ( _IsTradeAllowed == -2 ) { _return = -302; _Return_( FunctionId, "Error", 0, stringStopped, "_IsTradeAllowed()", stringStopped ); }
		if ( _IsTradeAllowed == -3 ) { _return = -303; _Return_( FunctionId, "Error", 0, stringTimeOut, "_IsTradeAllowed()", stringTimeOut ); }
		return(_return);
	}

//---- Æä¸ì îñâîáîæäåíèÿ òîðãîâîãî ïîòîêà è çàíèìàåì åãî
	int _TradeIsBusy = TradeIsBusy();
	if ( _TradeIsBusy < 0 )
	{
		if ( _TradeIsBusy == -2 ) { _return = -302; _Return_( FunctionId, "Error", 0, stringStopped, "TradeIsBusy()", stringStopped ); }
		if ( _TradeIsBusy == -3 ) { _return = -303; _Return_( FunctionId, "Error", 0, stringTimeOut, "TradeIsBusy()", stringTimeOut ); }
		return(_return);
	}

//---- Ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè
	int _PauseBeforeTrade = _PauseBeforeTrade();
	if ( _PauseBeforeTrade < 0 )
	{
		if ( _PauseBeforeTrade == -2 ) { _return = -302; _Return_( FunctionId, "Error", 0, stringStopped, "_PauseBeforeTrade()", stringStopped ); }
		if ( _PauseBeforeTrade == -3 ) { _return = -303; _Return_( FunctionId, "Error", 0, stringTimeOut, "_PauseBeforeTrade()", stringTimeOut ); }
		TradeIsNotBusy();
		return(_return);
	}
return(_return);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _Return_ ( int FunctionId, string TradeLog_Result, int TradeLog_GetLastError, string TradeLog_ErrorDescription, string SubFunction, string SubFunctionResult )
/////////////////////////////////////////////////////////////////////////////////
{
	_TradeLog_ 	( FunctionId, TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription );
	_Print_ 		( FunctionId, SubFunction, SubFunctionResult );

	switch ( FunctionId )
	{
		case 1:  _FileWrite ( "- - - - - - - - - - - - - - - - - OrderSend Finish - - - - - - - - - - - - - - - - - -" ); break;
		case 2:  _FileWrite ( "- - - - - - - - - - - - - - - - - OrderModify Finish - - - - - - - - - - - - - - - - -" ); break;
		case 3:  _FileWrite ( "- - - - - - - - - - - - - - - - - OrderClose Finish  - - - - - - - - - - - - - - - - -" ); break;
		case 4:  _FileWrite ( "- - - - - - - - - - - - - - - - - OrderDelete Finish - - - - - - - - - - - - - - - - -" ); break;
		case 5:	break;
		case 6:  _FileWrite ( "- - - - - - - - - - - - - - - - - - Reverse Finish - - - - - - - - - - - - - - - - - -" ); break;
		case 7:  _FileWrite ( "- - - - - - - - - - - - - - - - - TrailingStop Finish  - - - - - - - - - - - - - - - -" ); break;
		default: Print( " _Return_( ", FunctionId, ", ", TradeLog_Result, ", ", TradeLog_GetLastError, ", ", TradeLog_ErrorDescription, ", ", SubFunction, ", ", SubFunctionResult, " ) - Unknown function with Id ", FunctionId );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _TradeLog_( int FunctionId, string TradeLog_Result, int TradeLog_GetLastError, string TradeLog_ErrorDescription )
/////////////////////////////////////////////////////////////////////////////////
{
	switch ( FunctionId )
	{
		case 1:  _TradeLog ( Send_Result, Send_MagicNumber, Send_Comment, "OrderSend ( \"" + Send_Symbol + "\", " + Send_OrderType + ", " + DoubleToStr( Send_Volume, 2 ) + ", " + DoubleToStr( Send_OpenPrice, _Digits ) + ", " + Send_Slippage + ", " + DoubleToStr( Send_StopLoss, _Digits ) + ", " + DoubleToStr( Send_TakeProfit, _Digits ) + ", " + Send_Comment + ", " + Send_MagicNumber + ", " + Send_Expiration + ", " + Send_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Send_StartTickCount ) / 1000 ); break;
		case 2:  _TradeLog ( Modify_OrderTicket, Modify_OrderMagicNumber, Modify_OrderComment, "OrderModify ( " + Modify_OrderTicket + ", " + DoubleToStr( Modify_New_OpenPrice, _Digits ) + ", " + DoubleToStr( Modify_New_StopLoss, _Digits ) + ", " + DoubleToStr( Modify_New_TakeProfit, _Digits ) + ", " + Modify_New_Expiration + ", " + Modify_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Modify_StartTickCount ) / 1000 ); break;
		case 3:  _TradeLog ( Close_OrderTicket, Close_OrderMagicNumber, Close_OrderComment, "OrderClose( " + Close_OrderTicket + ", " + DoubleToStr( Close_Volume, 2 ) + ", " + Close_Slippage + ", " + Close_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Close_StartTickCount ) / 1000 ); break;
		case 4:  _TradeLog ( Delete_OrderTicket, Delete_OrderMagicNumber, Delete_OrderComment, "OrderDelete( " + Delete_OrderTicket + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Delete_StartTickCount ) / 1000 ); break;
		case 5:  _TradeLog ( Close_OrderTicket, Close_OrderMagicNumber, Close_OrderComment, "Reverse( " + Close_OrderTicket + ", " + Close_Slippage + ", " + Close_Color + ", " + Send_Color + " )" + " - - - " + "OrderClose( " + Close_OrderTicket + ", " + DoubleToStr( Close_Volume, 2 ) + ", " + Close_Slippage + ", " + Close_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Close_StartTickCount ) / 1000 ); break;
		case 6:  _TradeLog ( Send_Result, Send_MagicNumber, Send_Comment, "Reverse( " + Close_OrderTicket + ", " + Close_Slippage + ", " + Close_Color + ", " + Send_Color + " )" + " - - - " + "OrderSend ( \"" + Send_Symbol + "\", " + Send_OrderType + ", " + DoubleToStr( Send_Volume, 2 ) + ", " + DoubleToStr( Send_OpenPrice, _Digits ) + ", " + Send_Slippage + ", " + DoubleToStr( Send_StopLoss, _Digits ) + ", " + DoubleToStr( Send_TakeProfit, _Digits ) + ", " + Send_Comment + ", " + Send_MagicNumber + ", " + Send_Expiration + ", " + Send_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Close_StartTickCount ) / 1000 ); break;
		case 7:  _TradeLog ( Trailing_OrderTicket, Trailing_OrderMagicNumber, Trailing_OrderComment, "TrailingStop ( " + Trailing_OrderTicket + ", " + Trailing_TrailingStop + ", " + Trailing_Color + " )", TradeLog_Result, TradeLog_GetLastError, TradeLog_ErrorDescription, ( GetTickCount() - Trailing_StartTickCount ) / 1000 ); break;
		default: Print( " _TradeLog_( ", FunctionId, ", ", TradeLog_Result, ", ", TradeLog_GetLastError, ", ", TradeLog_ErrorDescription, " ) - Unknown function with Id ", FunctionId );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _Print_( int FunctionId, string SubFunction, string SubFunctionResult )
/////////////////////////////////////////////////////////////////////////////////
{
	switch ( FunctionId )
	{
		
		case 1:  Print( "OrderSend - ",SubFunctionResult,". Account ", AccountNumber()," - OK" ); break;
		case 2:  Print( "OrderModify ( ", Modify_OrderTicket, ", ", DoubleToStr( Modify_New_OpenPrice, _Digits ), ", ", DoubleToStr( Modify_New_StopLoss, _Digits ), ", ", DoubleToStr( Modify_New_TakeProfit, _Digits ), ", ", Modify_New_Expiration, ", ", Modify_Color, " ) - ", SubFunction, " - ", SubFunctionResult, ". Work time: ", ( GetTickCount() - Modify_StartTickCount ) / 1000, " sec." ); break;
		case 3:  Print( "OrderClose( ",Close_OrderTicket, " )" ); break;
		case 4:  Print( "OrderDelete( ", Delete_OrderTicket, " ) - ", SubFunction, " - ", SubFunctionResult, ". Work time: ", ( GetTickCount() - Delete_StartTickCount ) / 1000, " sec." ); break;
		case 5:  Print( "Reverse( " + Close_OrderTicket + ", " + Close_Slippage + ", " + Close_Color + ", " + Send_Color + " ) - - - " + "OrderClose( ", Close_OrderTicket, ", ", Close_Volume, ", ", Close_Slippage, ", ", Close_Color, " ) - ", SubFunction, " - ", SubFunctionResult, ". Work time: ", ( GetTickCount() - Close_StartTickCount ) / 1000, " sec." ); break;
		case 6:  Print( "Reverse( " + Close_OrderTicket + ", " + Close_Slippage + ", " + Close_Color + ", " + Send_Color + " ) - - - " + "OrderSend ( ", Send_Symbol, ", ", Send_OrderType, ", ", DoubleToStr( Send_Volume, 2 ), ", ", DoubleToStr( Send_OpenPrice, _Digits ), ", ", Send_Slippage, ", ", DoubleToStr( Send_StopLoss, _Digits ), ", ", DoubleToStr( Send_TakeProfit, _Digits ), ", ", Send_Comment, ", ", Send_MagicNumber, ", ", Send_Expiration, ", ", Send_Color, " ) - ", SubFunction, " - ", SubFunctionResult, ". Work time: ", ( GetTickCount() - Close_StartTickCount ) / 1000, " sec." ); break;
		case 7:  Print( "TrailingStop ( " + Trailing_OrderTicket + ", " + Trailing_TrailingStop + ", " + Trailing_Color + " ) - ", SubFunction, " - ", SubFunctionResult, ". Work time: ", ( GetTickCount() - Trailing_StartTickCount ) / 1000, " sec." ); break;
		default: Print( "Print_( ", FunctionId, ", ", SubFunction, ", ", SubFunctionResult, " ) - Unknown function with Id ", FunctionId );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int TradeIsBusy()
/////////////////////////////////////////////////////////////////////////////////
// Óñòàíàâëèâàåì ãëîáàëüíóþ ïåðåìåííóþ TradeIsBusy â 1
// Åñëè óñïåøíî, âîçâðàùàåì 1
// Åñëè _IsStopped(), âîçâðàùàåì -2
// Åñëè _IsTimeOut(), âîçâðàùàåì -3
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(1); }
	int _GetLastError;

	while( true )
	{
		if ( _IsStopped() ) { return(-2); }
		if ( _IsTimeOut() ) { return(-3); }
		if ( GlobalVariableCheck( "TradeIsBusy" ) ) { break; }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " TradeIsBusy() - GlobalVariableCheck ( \"TradeIsBusy\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			Sleep(100);
			continue;
		}

		if ( GlobalVariableSet ( "TradeIsBusy", 1.0 ) > 0 ) { return(1); }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " TradeIsBusy() - GlobalVariableSet ( \"TradeIsBusy\", 0.0 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			Sleep(100);
			continue;
		}
		Sleep(100);
	}
	while( true )
	{
		if ( _IsStopped() ) { return(-2); }
		if ( _IsTimeOut() ) { return(-3); }
		if ( GlobalVariableSetOnCondition( "TradeIsBusy", 1.0, 0.0 ) ) { return(1); }
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " TradeIsBusy() - GlobalVariableSetOnCondition ( \"TradeIsBusy\", 1.0, 0.0 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			continue;
		}

		_info ( 14, "Æä¸ì, ïîêà äðóãîé ýêñïåðò çàêîí÷èò òîðãîâàòü...", 0, 0 );
		Sleep(1000);
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _PauseBeforeTrade ()
/////////////////////////////////////////////////////////////////////////////////
// Åñëè ñî âðåìåíè ïîñëåäíåé òîðãîâîé îïåðàöèè ïðîøëî ìåíüøå PauseBeforeTrade ñåê, æä¸ì...
// Óñòàíàâëèâàåì ãëîáàëüíóþ ïåðåìåííóþ LastTradeTime â ëîêàëüíîå âðåìÿ
// Åñëè óñïåøíî, âîçâðàùàåì 1
// Åñëè IsStopped(), âîçâðàùàåì -2
// Åñëè _IsTimeOut(), âîçâðàùàåì -3
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(1); }
	int _GetLastError;
	GetLastError();

	while( true )
	{
		if ( _IsStopped() ) { TradeIsNotBusy(); return(-2); }
		if ( _IsTimeOut() ) { TradeIsNotBusy(); return(-3); }
		if ( GlobalVariableCheck( "LastTradeTime" ) ) break;
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " _PauseBeforeTrade() - GlobalVariableCheck ( \"LastTradeTime\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			continue;
		}

		if ( GlobalVariableSet ( "LastTradeTime", TimeLocal() ) > 0 )
		{
			_info ( 14, "" );
			return(1);
		}
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 ) Print( " _PauseBeforeTrade() - GlobalVariableSet ( \"LastTradeTime\", ", TimeLocal(), " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	
		Sleep(100);
	}

	double _LastTradeTime, RealPauseBeforeTrade, RequirementPauseBeforeTrade;

	while( true )
	{
		if ( _IsStopped() ) { TradeIsNotBusy(); return(-2); }
		if ( _IsTimeOut() ) { TradeIsNotBusy(); return(-3); }

		_LastTradeTime = GlobalVariableGet ( "LastTradeTime" );
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " _PauseBeforeTrade() - GlobalVariableGet ( \"LastTradeTime\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			continue;
		}

		RealPauseBeforeTrade				= TimeLocal() - _LastTradeTime;
		RequirementPauseBeforeTrade	= PauseBeforeTrade;
		if ( RealPauseBeforeTrade < RequirementPauseBeforeTrade )
		{
			_info ( 14, "Ïàóçà ìåæäó òîðãîâûìè îïåðàöèÿìè. Îñòàëîñü " + DoubleToStr( RequirementPauseBeforeTrade - RealPauseBeforeTrade, 0 ) + " ñåê.", 0, 0 );
			Sleep(1000);
		}
		else
		{
			break;
		}
	}

	while( true )
	{
		if ( _IsStopped() ) { TradeIsNotBusy(); return(-2); }
		if ( _IsTimeOut() ) { TradeIsNotBusy(); return(-3); }
		if ( GlobalVariableSet ( "LastTradeTime", TimeLocal() ) > 0 )
		{
			_info( 14, "" );
			return(1);
		}

		_GetLastError = GetLastError();
		if ( _GetLastError != 0 ) Print( " _PauseBeforeTrade() - GlobalVariableSet ( \"LastTradeTime\", ", TimeLocal(), " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );

		Sleep(100);
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void TradeIsNotBusy ()
/////////////////////////////////////////////////////////////////////////////////
// Óñòàíàâëèâàåì ãëîáàëüíóþ ïåðåìåííóþ TradeIsBusy â 0
// Ðàáîòàåì "äî óïîðà", ò.å. ïîêà íå âûïîëíèì
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(0); }
	int _GetLastError;
	GetLastError();
	while( true )
	{
		if ( GlobalVariableCheck( "TradeIsBusy" ) )
		{
			if ( GlobalVariableGet( "TradeIsBusy" ) == 0.0 ) return(1);
			_GetLastError = GetLastError();
			if ( _GetLastError != 0 )
			{
				Print( " TradeIsNotBusy() - GlobalVariableGet ( \"TradeIsBusy\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
				continue;
			}

			if ( GlobalVariableSet( "TradeIsBusy", 0.0 ) > 0 ) return(1);
			_GetLastError = GetLastError();
			if ( _GetLastError != 0 )
			{ Print( " TradeIsNotBusy() - GlobalVariableSet ( \"TradeIsBusy\", 0.0 ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" ); }

			Sleep(100);
		}
		else
		{
			_GetLastError = GetLastError();
			if ( _GetLastError != 0 )
			{
				Print( " TradeIsNotBusy() - GlobalVariableCheck ( \"TradeIsBusy\" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
				continue;
			}
			return(1);
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _IsConnected ()
/////////////////////////////////////////////////////////////////////////////////
// Åñëè IsConnected() == true, âîçâðàùàåì 1
// Åñëè IsConnected() == false, âîçâðàùàåì -1
// Åñëè IsStopped(), âîçâðàùàåì -2
// Åñëè _IsTimeOut(), âîçâðàùàåì -3
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(1); }
	for ( int z = 0; z < 50; z ++ )
	{
		if ( IsConnected() ) { return(1); }
		if ( _IsStopped() ) { return(-2); }
		if ( _IsTimeOut() ) { return(-3); }
		Sleep(100);
	}
	_info ( 14, stringNoConnection + "!", 1 );
return(-1);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int _IsTradeAllowed ()
/////////////////////////////////////////////////////////////////////////////////
// Åñëè IsTradeAllowed() == true, âîçâðàùàåì 1
// Åñëè IsTradeAllowed() == false, âîçâðàùàåì -1
// Åñëè IsStopped(), âîçâðàùàåì -2
// Åñëè _IsTimeOut(), âîçâðàùàåì -3
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsTesting() ) { return(1); }
	for ( int z = 0; z < 50; z ++ )
	{
		if ( IsTradeAllowed() ) { return(1); }
		if ( _IsStopped() ) { return(-2); }
		if ( _IsTimeOut() ) { return(-3); }
		Sleep(100);
	}
	_info ( 14, stringTradeNotAllow + "!", 1 );
return(-1);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ bool _IsStopped ()
/////////////////////////////////////////////////////////////////////////////////
{
	if ( IsStopped() )
	{
		_info ( 14, stringStopped + "!", 1 );
		return(true);
	}
	return(false);
}
/////////////////////////////////////////////////////////////////////////////////
/**/ bool _IsTimeOut ()
/////////////////////////////////////////////////////////////////////////////////
{
	if ( TimeLocal() - StartTime > MaxWaitingTime && MaxWaitingTime > 0 && StartTime > 0 )
	{
		_info ( 4, stringTimeOut + "!", 1 );
		return(true);
	}
	return(false);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void Processing_Error ( int ErrorCode, string Function )
/////////////////////////////////////////////////////////////////////////////////
{
	int _GetLastError;

/*ERR_ORDER_LOCKED - â îáðàáîòêå íàõîäÿòñÿ äðóãèå îðäåðû, ñåðâåð íå ïðèíèìàåò íîâûõ çàÿâîê
ERR_OFF_QUOTES - íåò öåí, èìååò ñìûñë ïîâòîðèòü îïåðàöèþ ÷åðåç íåêîòîðîå ïðîäîëæèòåëüíîå âðåìÿ
ERR_PRICE_CHANGED - öåíà ÿâíî èçìåíèëàñü, íóæíî âçÿòü ïîñëåäíþþ ðûíî÷íóþ è ïîïðîáîâàòü ñíîâà
ERR_INVALID_PRICE - ÿâíàÿ îøèáêà â ýêñïåðòå ñ íåïðàâèëüíûìè öåíàìè, íè î êàêîé òîðãîâëå ðå÷ü íå ìîæåò èäòè. íóæíî îñòàíàâëèâàòüñÿ è ïðîâåðÿòü êîä ýêñïåðòà
ERR_REQUOTE - ÷èñòûé ðåêâîò, íåîáõîäèìî òóò æå áåç çàäåðæåê âçÿòü ðûíî÷íóþ öåíó è ñíîâà ïðîâåñòè òðåéä

*/	string ErrorDescription = ErrorDescription( ErrorCode );
	int ErrorAction = 0;
	if ( ErrorCode == 4   ||
		  ErrorCode == 6	 ||
		  ErrorCode == 8	 ||
		  ErrorCode == 132  ||
		  ErrorCode == 137  ||
		  ErrorCode == 141  ||
		  ErrorCode == 146 ) ErrorAction = 1;

	if ( ErrorCode == 5   ||
		  ErrorCode == 64  ||
		  ErrorCode == 65 ) ErrorAction = 2;

	string ActionStr = "Ýêñïåðò ïðîäîëæàåò ðàáîòó...";

	switch ( ErrorAction )
	{
		case 1:
		{
/*			ActionStr = "Ýêñïåðòû íå áóäóò òîðãîâàòü 5 ìèíóò...";
			while ( !IsStopped() )
			{
				if ( GlobalVariableSet ( "LastTradeTime", TimeLocal() + 300 ) > 0 ) { break; }
				_GetLastError = GetLastError();
				Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - GlobalVariableSet ( \"LastTradeTime\", ", TimeLocal() + 300, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
				Sleep(100);
			}
*/			break;
		}
		case 2:
		{
			ActionStr = "Ýêñïåðò ïðåêðàùàåò ðîáîòó...";
			while ( !IsStopped() )
			{
				if ( GlobalVariableSet ( strComment + "-return!", -ErrorCode ) > 0 ) { break; }
				_GetLastError = GetLastError();
				Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - GlobalVariableSet ( \"", strComment, "-return!\", ", -ErrorCode, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
				Sleep(100);
			}
			break;
		}
	}

	clear_info();
	_info ( 1, Function + " Error!!!", 1 );
	_info ( 2, "GetLastError = " + ErrorCode, 1 );
	_info ( 3, ErrorDescription, 1 );
	_info ( 4, ActionStr, 1 );

	string subject = strComment + " - Error #" + ErrorCode + " ( " + ErrorDescription + " )!";
	string mail_text = "Account#" + AccountNumber() + "  " + strComment + " - " + Function + "() Error #" + ErrorCode;
	string log_text =
	"+--------------------Expert-Information----------------------------+\n" +
	"+ ExpertName		= " + ExpertName + "\n" +
	"+ ChartSymbol		= " + _Symbol + "\n" +
	"+ ChartPeriod		= " + strPeriod + "\n" +
	"+------------------------------------------------------------------+\n" +
	"\n" +
	"+--------------------Error-Information-----------------------------+\n" +
	"+ LocalTime		= " + TimeToStr( TimeLocal(), TIME_DATE | TIME_SECONDS ) + "\n" +
	"+ Function		= " + Function + "\n" +
	"+ GetLastError		= " + ErrorCode + "\n" +
	"+ ErrorDescription	= " + ErrorDescription + "\n" +
	"+ Action		= " + ActionStr + "\n" +
	"+------------------------------------------------------------------+\n" +
	"\n" +
	"+--------------------Market-Information----------------------------+\n" +
	"+ Bid			= " + DoubleToStr( MarketInfo( _Symbol, MODE_BID ), _Digits ) + "\n" +
	"+ Ask			= " + DoubleToStr( MarketInfo( _Symbol, MODE_ASK ), _Digits ) + "\n" +
	"+ Spread		= " + DoubleToStr( _Spread, _Digits ) + "\n" +
	"+ StopLevel		= " + DoubleToStr( _StopLevel, _Digits ) + "\n" +
	"+------------------------------------------------------------------+\n" +
	"\n" +
	"+-------------------LastBar-Information----------------------------+\n" +
	"+ Time [0]		= " + TimeToStr( iTime( _Symbol, _Period, 0 ) )  + "\n" +
	"+ Open [0]		= " + DoubleToStr( iOpen( _Symbol, _Period, 0 ), _Digits ) + "\n" +
	"+ High [0]		= " + DoubleToStr( iHigh( _Symbol, _Period, 0 ), _Digits ) + "\n" +
	"+ Low  [0]		= " + DoubleToStr( iLow ( _Symbol, _Period, 0 ), _Digits ) + "\n" +
	"+ Close[0]		= " + DoubleToStr( iClose( _Symbol, _Period, 0 ), _Digits ) + "\n" +
	"+------------------------------------------------------------------+\n" +
	"\n" +
	"+--------------------Server-Information----------------------------+\n" +
	"+ ServerAddress		= " + ServerAddress()		+ "\n" +
	"+ ServerTime		= " + TimeToStr( CurTime(), TIME_DATE | TIME_SECONDS ) + "\n" +
	"+------------------------------------------------------------------+\n" +
	"\n" +
	"+--------------------Account-Information---------------------------+\n" +
	"+ AccountNumber		= " + AccountNumber()								+ "\n" +
	"+ AccountName		= " + AccountName()										+ "\n" +
	"+ AccountEquity		= " + DoubleToStr( AccountEquity(), 2 )		+ "\n" +
	"+ AccountFreeMargin	= " + DoubleToStr( AccountFreeMargin(), 2 )	+ "\n" +
	"+ AccountMargin		= " + DoubleToStr( AccountMargin(), 2 )		+ "\n" +
	"+ \n" +
	"+ AccountBalance	= " + DoubleToStr( AccountBalance(), 2 )			+ "\n" +
	"+ AccountProfit		= " + DoubleToStr( AccountProfit(), 2 )		+ "\n" +
	"+ AccountCredit		= " + DoubleToStr( AccountCredit(), 2 )		+ "\n" +
	"+ AccountCurrency	= " + AccountCurrency()								+ "\n" +
	"+ AccountLeverage	= " + AccountLeverage()								+ "\n" +
	"+------------------------------------------------------------------+\n";

	if ( Allow_ErrorMail && !IsTesting() )
	{
		if ( IsConnected() )
		{
			SendMail( mail_text, "" );
			_GetLastError = GetLastError();
			if ( _GetLastError > 0 )
			{ Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - SendMail ( ", subject, ", ", mail_text, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" ); }
		}
		else
		{
			Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - No connection with server. SendMail canceled" );
		}
	}
	
	if ( Allow_ErrorLogFile )
	{
		string file_name = "_ErrorLogs\\" + strComment + "\\" + TimeToStr( TimeLocal(), TIME_DATE ) + ".txt";
		int file_handle = FileOpen ( file_name, FILE_READ | FILE_WRITE, " " );
	
		if ( file_handle > 0 )
		{
			if ( FileSeek ( file_handle, 0, SEEK_END ) )
			{
				if ( FileWrite ( file_handle, subject + "\n", log_text, "\n\n" ) < 0 )
				{
					_GetLastError = GetLastError();
					Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - FileWrite (...) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
				}
			}
			else
			{
				_GetLastError = GetLastError();
				Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - FileSeek ( " + file_handle + ", 0, SEEK_END ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			}
			FileClose ( file_handle );
		}
		else
		{
			_GetLastError = GetLastError();
			Print( " Processing_Error( ", ErrorCode, ", ", Function, " ) - FileOpen( ", file_name, ", FILE_READ | FILE_WRITE, \" \" ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void _TradeLog ( int Ticket, int MagicNumber, string _Comment, string Action, string Result = "OK", int Error = 0, string ErrorDescription = "", int WorkTime = 0 )
/////////////////////////////////////////////////////////////////////////////////
// Çàïèñü â ëîã-ôàéë èíôîðìàöèè î òîðãîâîé îïåðàöèè.
//
// Èìÿ ïðîåêòèðóåòñÿ ñ èñïîëüçîâàíèåì òåêóùåé äàòû.
// È âûãëÿäèò òàê ( äëÿ ïðèìåðà: äàòà çàïèñè - 2005.08.03):
// ...\MetaTrader 4\experts\files\_TradeLog\2005.08.03.csv
// Äëÿ óäîáî÷èòàåìîñòè ëîãîâ ìîæíî èñïîëüçîâàòü ìàêðîñ TradeLog_Format, ïðèâîäÿùèé ëîã â "ïðèëè÷íûé" âèä.
// Èíñòðóêöèè ïî èñïîëüçîâàíèþ â ñîîòâåòñòâóþùåé ãëàâå.
/////////////////////////////////////////////////////////////////////////////////
{
	if ( !Allow_TradeLogFile ) { return(0); }

	int _GetLastError;

	string file_name = "_TradeLogs\\" + TimeToStr( TimeLocal(), TIME_DATE ) + ".csv";
	int file_handle = FileOpen ( file_name, FILE_READ | FILE_WRITE );
	if ( file_handle > 0 )
	{
		if ( FileSeek ( file_handle, 0, SEEK_END ) )
		{
			string Error_str = DoubleToStr( Error, 0 );
			if ( FileWrite ( file_handle, TimeToStr( TimeLocal(), TIME_SECONDS ), ExpertName, _Symbol, _Period, "( " + strPeriod + " )", Ticket, MagicNumber, _Comment, Action, Result, ErrorDescription, Error_str, WorkTime ) < 0 )
			{
				_GetLastError = GetLastError();
				Print( " _TradeLog ( ", Ticket, ", ", MagicNumber, ", ", _Comment, ", ", Action, ", ", Result, ", ", Error, " ) - FileWrite ( ", TimeToStr( TimeLocal(), TIME_SECONDS ), ", ", ExpertName, ", ", _Symbol, ", ", _Period, ", ( " + strPeriod + " ), ", Ticket, ", ", MagicNumber, ", ", _Comment, ", ", Action, ", ", Result, ", ", Error, ", ", ErrorDescription, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			}
		}
		else
		{
			_GetLastError = GetLastError();
			Print( " _TradeLog ( ", Ticket, ", ", MagicNumber, ", ", _Comment, ", ", Action, ", ", Result, ", ", Error, " ) - FileSeek ( " + file_handle + ", 0, SEEK_END ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		}
		FileClose ( file_handle );
	}
	else
	{
		_GetLastError = GetLastError();
		Print( " _TradeLog ( ", Ticket, ", ", MagicNumber, ", ", _Comment, ", ", Action, ", ", Result, ", ", Error, " ) - FileOpen( \"", file_name, "\", FILE_READ | FILE_WRITE ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ void ReportToCSV( string file_name = "", int magic = -1, string comment = "-1", string symbol = "-1", int magic1 = -1 )
/////////////////////////////////////////////////////////////////////////////////
{
	int Tickets[], _HistoryTotal = OrdersHistoryTotal(), _HistoryValidate = 0, _GetLastError;
	ArrayResize( Tickets, _HistoryTotal );

	for ( int i = 0; i < _HistoryTotal; i++ )
	{
		if ( !OrderSelect( i, SELECT_BY_POS, MODE_HISTORY ) ) continue;
		if ( symbol != "-1" && OrderSymbol() != _Symbol ) continue;
		if ( comment != "-1" && StringFind( OrderComment(), comment, 0 ) < 0 ) continue;
		if ( magic != -1 && OrderMagicNumber() != magic )
		{
			if ( magic1 != -1 && OrderMagicNumber() != magic1 ) continue;
		}

		Tickets[_HistoryValidate] = OrderTicket();
		_HistoryValidate ++;
	}

	if ( _HistoryValidate <= 0 )
	{
		Print( "ReportToCSV: Íåò îðäåðîâ, îòâå÷àþùèõ óñëîâèÿì!" );
		return;
	}

	ArrayResize( Tickets, _HistoryValidate );
	ArraySort( Tickets );

	if ( file_name == "" ) file_name = "_Reports\\" + strComment + ".csv";
	int file_handle = FileOpen ( file_name, FILE_WRITE );
	if ( file_handle < 0 )
	{
		_GetLastError = GetLastError();
		Print( " ReportToCSV ( ", magic, ", ", comment, " ) - FileOpen( \"", file_name, "\", FILE_WRITE ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		return(-1);
	}

	FileWrite( file_handle, 
		"Ticket", 
		"OpenTime", 
		"Type", 
		"Lots", 
		"Symbol", 
		"OpenPrice", 
		"StopLoss", 
		"TakeProfit", 
		"CloseTime", 
		"ClosePrice", 
		"Swap", 
		"Profit", 
		"Comment" );

	for ( i = 0; i < _HistoryValidate; i++ )
	{
		if ( !OrderSelect( Tickets[i], SELECT_BY_TICKET ) ) continue;
		FileWrite( file_handle, 
			Tickets[i], 
			TimeToStr( OrderOpenTime() ), 
			strOrderType( OrderType() ), 
			DoubleToStr( OrderLots(), 2 ), 
			Symbol(), 
			DoubleToStr( OrderOpenPrice()	, _Digits ), 
			DoubleToStr( OrderStopLoss()	, _Digits ), 
			DoubleToStr( OrderTakeProfit(), _Digits ), 
			TimeToStr( OrderCloseTime() ), 
			DoubleToStr( OrderClosePrice(), _Digits ), 
			DoubleToStr( OrderSwap(), 2 ), 
			DoubleToStr( OrderProfit(), 2 ), 
			OrderComment() );
	}
	FileClose( file_handle );
}

/////////////////////////////////////////////////////////////////////////////////
/**/ string strOrderType( int intOrderType )
/////////////////////////////////////////////////////////////////////////////////
// âîçâðàùàåò OrderType â âèäå òåêñòà
/////////////////////////////////////////////////////////////////////////////////
{
	switch ( intOrderType )
	{
		case OP_BUY:			return("Buy"					);
		case OP_SELL:			return("Sell"					);
		case OP_BUYLIMIT:		return("BuyLimit"				);
		case OP_BUYSTOP:		return("BuyStop"				);
		case OP_SELLLIMIT:	return("SellLimit"			);
		case OP_SELLSTOP:		return("SellStop"				);
		default:					return("UnknownOrderType"	);
	}
}
/////////////////////////////////////////////////////////////////////////////////
/**/ int intOrderType( string strOrderType )
/////////////////////////////////////////////////////////////////////////////////
// âîçâðàùàåò OrderType â âèäå òåêñòà
/////////////////////////////////////////////////////////////////////////////////
{
	if ( strOrderType == "Buy"			) { return(OP_BUY			); }
	if ( strOrderType == "Sell"		) { return(OP_SELL		); }
	if ( strOrderType == "BuyLimit"	) { return(OP_BUYLIMIT	); }
	if ( strOrderType == "BuyStop"	) { return(OP_BUYSTOP	); }
	if ( strOrderType == "SellLimit"	) { return(OP_SELLLIMIT	); }
	if ( strOrderType == "SellStop"	) { return(OP_SELLSTOP	); }
	return(-1);
}
/////////////////////////////////////////////////////////////////////////////////
/**/ int intOrderType2( string strOrderType )
/////////////////////////////////////////////////////////////////////////////////
// âîçâðàùàåò OrderType â âèäå òåêñòà
/////////////////////////////////////////////////////////////////////////////////
{
	if ( strOrderType == "Buy"			) { return(OP_BUY			); }
	if ( strOrderType == "Sell"		) { return(OP_SELL		); }
	if ( strOrderType == "Buy-limit"	) { return(OP_BUYLIMIT	); }
	if ( strOrderType == "Buy-stop"	) { return(OP_BUYSTOP	); }
	if ( strOrderType == "Sell-limit") { return(OP_SELLLIMIT	); }
	if ( strOrderType == "Sell-stop"	) { return(OP_SELLSTOP	); }
	return(-1);
}

/////////////////////////////////////////////////////////////////////////////////
/**/ string strPeriod( int intPeriod )
/////////////////////////////////////////////////////////////////////////////////
// âîçâðàùàåò Period â âèäå òåêñòà
/////////////////////////////////////////////////////////////////////////////////
{
	switch ( intPeriod )
	{
		case PERIOD_MN1: return("Monthly");
		case PERIOD_W1:  return("Weekly");
		case PERIOD_D1:  return("Daily");
		case PERIOD_H4:  return("H4");
		case PERIOD_H1:  return("H1");
		case PERIOD_M30: return("M30");
		case PERIOD_M15: return("M15");
		case PERIOD_M5:  return("M5");
		case PERIOD_M1:  return("M1");
		default:		     return("UnknownPeriod");
	}
}

/////////////////////////////////////////////////////////////////////////////////
/**/ int intPeriod( string strPeriod )
/////////////////////////////////////////////////////////////////////////////////
// âîçâðàùàåò Period â âèäå öåëîãî ÷èñëà
/////////////////////////////////////////////////////////////////////////////////
{
	if ( strPeriod == "Monthly"	)	{ return(PERIOD_MN1	); }
	if ( strPeriod == "Weekly"		)	{ return(PERIOD_W1	); }
	if ( strPeriod == "Daily"		)	{ return(PERIOD_D1	); }
	if ( strPeriod == "H4"			)	{ return(PERIOD_H4	); }
	if ( strPeriod == "H1"			)	{ return(PERIOD_H1	); }
	if ( strPeriod == "M30"			)	{ return(PERIOD_M30	); }
	if ( strPeriod == "M15"			)	{ return(PERIOD_M15	); }
	if ( strPeriod == "M5"			)	{ return(PERIOD_M5	); }
	if ( strPeriod == "M1"			)	{ return(PERIOD_M1	); }
	return(-1);
}


//---- ô-öèÿ èç stdlib.mq4 ñêîïèðîâàíà 10.08.2006 (build 208)
string ErrorDescription(int error_code)
  {
   string error_string;
//----
   switch(error_code)
     {
      //---- codes returned from trade server
      case 0:
      case 1:   error_string="no error";                                                  break;
      case 2:   error_string="common error";                                              break;
      case 3:   error_string="invalid trade parameters";                                  break;
      case 4:   error_string="trade server is busy";                                      break;
      case 5:   error_string="old version of the client terminal";                        break;
      case 6:   error_string="no connection with trade server";                           break;
      case 7:   error_string="not enough rights";                                         break;
      case 8:   error_string="too frequent requests";                                     break;
      case 9:   error_string="malfunctional trade operation (never returned error)";      break;
      case 64:  error_string="account disabled";                                          break;
      case 65:  error_string="invalid account";                                           break;
      case 128: error_string="trade timeout";                                             break;
      case 129: error_string="invalid price";                                             break;
      case 130: error_string="invalid stops";                                             break;
      case 131: error_string="invalid trade volume";                                      break;
      case 132: error_string="market is closed";                                          break;
      case 133: error_string="trade is disabled";                                         break;
      case 134: error_string="not enough money";                                          break;
      case 135: error_string="price changed";                                             break;
      case 136: error_string="off quotes";                                                break;
      case 137: error_string="broker is busy (never returned error)";                     break;
      case 138: error_string="requote";                                                   break;
      case 139: error_string="order is locked";                                           break;
      case 140: error_string="long positions only allowed";                               break;
      case 141: error_string="too many requests";                                         break;
      case 145: error_string="modification denied because order too close to market";     break;
      case 146: error_string="trade context is busy";                                     break;
      case 147: error_string="expirations are denied by broker";                          break;
      case 148: error_string="amount of open and pending orders has reached the limit";   break;
      //---- mql4 errors
      case 4000: error_string="no error (never generated code)";                                                 break;
      case 4001: error_string="wrong function pointer";                                   break;
      case 4002: error_string="array index is out of range";                              break;
      case 4003: error_string="no memory for function call stack";                        break;
      case 4004: error_string="recursive stack overflow";                                 break;
      case 4005: error_string="not enough stack for parameter";                           break;
      case 4006: error_string="no memory for parameter string";                           break;
      case 4007: error_string="no memory for temp string";                                break;
      case 4008: error_string="not initialized string";                                   break;
      case 4009: error_string="not initialized string in array";                          break;
      case 4010: error_string="no memory for array\' string";                             break;
      case 4011: error_string="too long string";                                          break;
      case 4012: error_string="remainder from zero divide";                               break;
      case 4013: error_string="zero divide";                                              break;
      case 4014: error_string="unknown command";                                          break;
      case 4015: error_string="wrong jump (never generated error)";                       break;
      case 4016: error_string="not initialized array";                                    break;
      case 4017: error_string="dll calls are not allowed";                                break;
      case 4018: error_string="cannot load library";                                      break;
      case 4019: error_string="cannot call function";                                     break;
      case 4020: error_string="expert function calls are not allowed";                    break;
      case 4021: error_string="not enough memory for temp string returned from function"; break;
      case 4022: error_string="system is busy (never generated error)";                   break;
      case 4050: error_string="invalid function parameters count";                        break;
      case 4051: error_string="invalid function parameter value";                         break;
      case 4052: error_string="string function internal error";                           break;
      case 4053: error_string="some array error";                                         break;
      case 4054: error_string="incorrect series array using";                             break;
      case 4055: error_string="custom indicator error";                                   break;
      case 4056: error_string="arrays are incompatible";                                  break;
      case 4057: error_string="global variables processing error";                        break;
      case 4058: error_string="global variable not found";                                break;
      case 4059: error_string="function is not allowed in testing mode";                  break;
      case 4060: error_string="function is not confirmed";                                break;
      case 4061: error_string="send mail error";                                          break;
      case 4062: error_string="string parameter expected";                                break;
      case 4063: error_string="integer parameter expected";                               break;
      case 4064: error_string="double parameter expected";                                break;
      case 4065: error_string="array as parameter expected";                              break;
      case 4066: error_string="requested history data in update state";                   break;
      case 4099: error_string="end of file";                                              break;
      case 4100: error_string="some file error";                                          break;
      case 4101: error_string="wrong file name";                                          break;
      case 4102: error_string="too many opened files";                                    break;
      case 4103: error_string="cannot open file";                                         break;
      case 4104: error_string="incompatible access to a file";                            break;
      case 4105: error_string="no order selected";                                        break;
      case 4106: error_string="unknown symbol";                                           break;
      case 4107: error_string="invalid price parameter for trade function";               break;
      case 4108: error_string="invalid ticket";                                           break;
      case 4109: error_string="trade is not allowed in the expert properties";            break;
      case 4110: error_string="longs are not allowed in the expert properties";           break;
      case 4111: error_string="shorts are not allowed in the expert properties";          break;
      case 4200: error_string="object is already exist";                                  break;
      case 4201: error_string="unknown object property";                                  break;
      case 4202: error_string="object is not exist";                                      break;
      case 4203: error_string="unknown object type";                                      break;
      case 4204: error_string="no object name";                                           break;
      case 4205: error_string="object coordinates error";                                 break;
      case 4206: error_string="no specified subwindow";                                   break;
      default:   error_string="unknown error";
     }
//----
   return(error_string);
  }

//+------------------------------------------------------------------+
//| ÎÒÑËÅÆÈÂÀÍÈÅ ÑÎÁÛÒÈÉ
//+------------------------------------------------------------------+

// ìàññèâ îòêðûòûõ ïîçèöèé ñîñòîÿíèåì íà ïðåäûäóùèé òèê
int pre_OrdersArray[][2]; // [êîëè÷åñòâî ïîçèöèé][¹ òèêåòà, òèï ïîçèöèè]

// ïåðåìåííûå ñîáûòèé
int eventBuyClosed_SL  = 0, eventBuyClosed_TP  = 0;
int eventSellClosed_SL = 0, eventSellClosed_TP = 0;
int eventBuyLimitDeleted_Exp  = 0, eventBuyStopDeleted_Exp  = 0;
int eventSellLimitDeleted_Exp = 0, eventSellStopDeleted_Exp = 0;
int eventBuyLimitOpened  = 0, eventBuyStopOpened  = 0;
int eventSellLimitOpened = 0, eventSellStopOpened = 0;

void CheckEvents( int magic = 0 )
{
	// ôëàã ïåðâîãî çàïóñêà
	static bool first = true;
	// êîä ïîñëåäíåé îøèáêè
	int _GetLastError = 0;
	// îáùåå êîëè÷åñòâî ïîçèöèé
	int _OrdersTotal = OrdersTotal();
	// êîë-âî ïîçèöèé, ñîîòâåòñòâóþùèõ êðèòåðèÿì (òåêóùèé èíñòðóìåíò è çàäàííûé MagicNumber),
	// ñîñòîÿíèåì íà òåêóùèé òèê
	int now_OrdersTotal = 0;
	// êîë-âî ïîçèöèé, ñîîòâåòñòâóþùèõ êðèòåðèÿì, ñîñòîÿíèåì íà ïðåäûäóùèé òèê
	static int pre_OrdersTotal = 0;
	// ìàññèâ îòêðûòûõ ïîçèöèé ñîñòîÿíèåì íà òåêóùèé òèê
	int now_OrdersArray[][2]; // [¹ â ñïèñêå][¹ òèêåòà, òèï ïîçèöèè]
	// òåêóùèé íîìåð ïîçèöèè â ìàññèâå now_OrdersArray (äëÿ ïåðåáîðà)
	int now_CurOrder = 0;
	// òåêóùèé íîìåð ïîçèöèè â ìàññèâå pre_OrdersArray (äëÿ ïåðåáîðà)
	int pre_CurOrder = 0;

	// ìàññèâ äëÿ õðàíåíèÿ êîëè÷åñòâà çàêðûòûõ ïîçèöèé êàæäîãî òèïà
	int now_ClosedOrdersArray[6][3]; // [òèï îðäåðà][òèï çàêðûòèÿ]
	// ìàññèâ äëÿ õðàíåíèÿ êîëè÷åñòâà ñðàáîòàâøèõ îòëîæåííûõ îðäåðîâ
	int now_OpenedPendingOrders[4]; // [òèï îðäåðà]

	// âðåìåííûå ôëàãè
	bool OrderClosed = true, PendingOrderOpened = false;
	// âðåìåííûå ïåðåìåííûå
	int ticket = 0, type = -1, close_type = -1;

	//îáíóëÿåì ïåðåìåííûå ñîáûòèé
	eventBuyClosed_SL  = 0; eventBuyClosed_TP  = 0;
	eventSellClosed_SL = 0; eventSellClosed_TP = 0;
	eventBuyLimitDeleted_Exp  = 0; eventBuyStopDeleted_Exp  = 0;
	eventSellLimitDeleted_Exp = 0; eventSellStopDeleted_Exp = 0;
	eventBuyLimitOpened  = 0; eventBuyStopOpened  = 0;
	eventSellLimitOpened = 0; eventSellStopOpened = 0;

	// èçìåíÿåì ðàçìåð ìàññèâà îòêðûòûõ ïîçèöèé ïîä òåêóùåå êîë-âî
	ArrayResize( now_OrdersArray, MathMax( _OrdersTotal, 1 ) );
	// îáíóëÿåì ìàññèâ
	ArrayInitialize( now_OrdersArray, 0.0 );

	// îáíóëÿåì ìàññèâû çàêðûòûõ ïîçèöèé è ñðàáîòàâøèõ îðäåðîâ
	ArrayInitialize( now_ClosedOrdersArray, 0.0 );
	ArrayInitialize( now_OpenedPendingOrders, 0.0 );

	//+------------------------------------------------------------------+
	//| Ïåðåáèðàåì âñå ïîçèöèè è çàïèñûâàåì â ìàññèâ òîëüêî òå, êîòîðûå
	//| ñîîòâåòñòâóþò êðèòåðèÿì
	//+------------------------------------------------------------------+
	for ( int z = _OrdersTotal - 1; z >= 0; z -- )
	{
		if ( !OrderSelect( z, SELECT_BY_POS ) )
		{
			_GetLastError = GetLastError();
			Print( "OrderSelect( ", z, ", SELECT_BY_POS ) - Error #", _GetLastError );
			continue;
		}
		// Ñ÷èòàåì êîëè÷åñòâî îðäåðîâ ïî òåêóùåìó ñèìâîëó è ñ çàäàííûì MagicNumber
		if ( OrderMagicNumber() == magic && OrderSymbol() == Symbol() )
		{
			now_OrdersArray[now_OrdersTotal][0] = OrderTicket();
			now_OrdersArray[now_OrdersTotal][1] = OrderType();
			now_OrdersTotal ++;
		}
	}
	// èçìåíÿåì ðàçìåð ìàññèâà îòêðûòûõ ïîçèöèé ïîä êîë-âî ïîçèöèé, ñîîòâåòñòâóþùèõ êðèòåðèÿì
	ArrayResize( now_OrdersArray, MathMax( now_OrdersTotal, 1 ) );

	//+------------------------------------------------------------------+
	//| Ïåðåáèðàåì ñïèñîê ïîçèöèé ïðåäûäóùåãî òèêà, è ñ÷èòàåì ñêîëüêî çàêðûëîñü ïîçèöèé è
	//| ñðàáîòàëî îòëîæåííûõ îðäåðîâ
	//+------------------------------------------------------------------+
	for ( pre_CurOrder = 0; pre_CurOrder < pre_OrdersTotal; pre_CurOrder ++ )
	{
		// çàïîìèíàåì òèêåò è òèï îðäåðà
		ticket = pre_OrdersArray[pre_CurOrder][0];
		type   = pre_OrdersArray[pre_CurOrder][1];
		// ïðåäïîëîãàåì, ÷òî åñëè ýòî ïîçèöèÿ, òî îíà çàêðûëàñü
		OrderClosed = true;
		// ïðåäïîëàãàåì, ÷òî åñëè ýòî áûë îòëîæåííûé îðäåð, òî îí íå ñðàáîòàë
		PendingOrderOpened = false;

		// ïåðåáèðàåì âñå ïîçèöèè èç òåêóùåãî ñïèñêà îòêðûòûõ ïîçèöèé
		for ( now_CurOrder = 0; now_CurOrder < now_OrdersTotal; now_CurOrder ++ )
		{
			// åñëè ïîçèöèÿ ñ òàêèì òèêåòîì åñòü â ñïèñêå,
			if ( ticket == now_OrdersArray[now_CurOrder][0] )
			{
				// çíà÷èò ïîçèöèÿ íå áûëà çàêðûòà (îðäåð íå áûë óäàë¸í)
				OrderClosed = false;

				// åñëè å¸ òèï ïîìåíÿëñÿ,
				if ( type != now_OrdersArray[now_CurOrder][1] )
				{
					// çíà÷èò ýòî áûë îòëîæåííûé îðäåð, è îí ñðàáîòàë
					PendingOrderOpened = true;
				}
				break;
			}
		}
		// åñëè áûëà çàêðûòà ïîçèöèÿ (óäàë¸í îðäåð),
		if ( OrderClosed )
		{
			// âûáèðàåì å¸
			if ( !OrderSelect( ticket, SELECT_BY_TICKET ) )
			{
				_GetLastError = GetLastError();
				Print( "OrderSelect( ", ticket, ", SELECT_BY_TICKET ) - Error #", _GetLastError );
				continue;
			}
			// è îïðåäåëÿåì, ÊÀÊ çàêðûëàñü ïîçèöèÿ (óäàëèëñÿ îðäåð):
			if ( type < 2 )
			{
				// Áàé è Ñåëë: 0 - âðó÷íóþ, 1 - ÑË, 2 - ÒÏ
				close_type = 0;
				if ( StringFind( OrderComment(), "[sl]" ) >= 0 ) close_type = 1;
				if ( StringFind( OrderComment(), "[tp]" ) >= 0 ) close_type = 2;
			}
			else
			{
				// Îòëîæåííûå îðäåðà: 0 - âðó÷íóþ, 1 - âðåìÿ èñòå÷åíèÿ
				close_type = 0;
				if ( StringFind( OrderComment(), "expiration" ) >= 0 ) close_type = 1;
			}
			
			// è çàïèñûâàåì â ìàññèâ çàêðûòûõ îðäåðîâ, ÷òî îðäåð ñ òèïîì type 
			// çàêðûëñÿ ïðè îáñòîÿòåëüñòâàõ close_type
			now_ClosedOrdersArray[type][close_type] ++;
			continue;
		}
		// åñëè ñðàáîòàë îòëîæåííûé îðäåð,
		if ( PendingOrderOpened )
		{
			// çàïèñûâàåì â ìàññèâ ñðàáîòàâøèõ îðäåðîâ, ÷òî îðäåð ñ òèïîì type ñðàáîòàë
			now_OpenedPendingOrders[type-2] ++;
			continue;
		}
	}

	//+------------------------------------------------------------------+
	//| Âñþ íåîáõîäèìóþ èíôîðìàöèþ ñîáðàëè - íàçíà÷àåì ïåðåìåííûì ñîáûòèé íóæíûå çíà÷åíèÿ
	//+------------------------------------------------------------------+
	// åñëè ýòî íå ïåðâûé çàïóñê ýêñïåðòà
	if ( !first )
	{
		// ïåðåáèðàåì âñå ýëåìåíòû ìàññèâà ñðàáàòûâàíèÿ îòëîæåííûõ îðäåðîâ
		for ( type = 2; type < 6; type ++ )
		{
			// è åñëè ýëåìåíò íå ïóñòîé (îðäåð òàêîãî òèïà ñðàáîòàë), ìåíÿåì çíà÷åíèå ïåðåìåííîé
			if ( now_OpenedPendingOrders[type-2] > 0 )
				SetOpenEvent( type );
		}

		// ïåðåáèðàåì âñå ýëåìåíòû ìàññèâà çàêðûòûõ ïîçèöèé
		for ( type = 0; type < 6; type ++ )
		{
			for ( close_type = 0; close_type < 3; close_type ++ )
			{
				// è åñëè ýëåìåíò íå ïóñòîé (áûëà çàêðûòà ïîçèöèÿ), ìåíÿåì çíà÷åíèå ïåðåìåííîé
				if ( now_ClosedOrdersArray[type][close_type] > 0 )
					SetCloseEvent( type, close_type );
			}
		}
	}
	else
	{
		first = false;
	}

	//---- ñîõðàíÿåì ìàññèâ òåêóùèõ ïîçèöèé â ìàññèâ ïðåäûäóùèõ ïîçèöèé
	ArrayResize( pre_OrdersArray, MathMax( now_OrdersTotal, 1 ) );
	for ( now_CurOrder = 0; now_CurOrder < now_OrdersTotal; now_CurOrder ++ )
	{
		pre_OrdersArray[now_CurOrder][0] = now_OrdersArray[now_CurOrder][0];
		pre_OrdersArray[now_CurOrder][1] = now_OrdersArray[now_CurOrder][1];
	}
	pre_OrdersTotal = now_OrdersTotal;
}
void SetOpenEvent( int SetOpenEvent_type )
{
	switch ( SetOpenEvent_type )
	{
		case OP_BUYLIMIT: eventBuyLimitOpened ++; return(0);
		case OP_BUYSTOP: eventBuyStopOpened ++; return(0);
		case OP_SELLLIMIT: eventSellLimitOpened ++; return(0);
		case OP_SELLSTOP: eventSellStopOpened ++; return(0);
	}
}
void SetCloseEvent( int SetCloseEvent_type, int SetCloseEvent_close_type )
{
	switch ( SetCloseEvent_type )
	{
		case OP_BUY:
		{
			if ( SetCloseEvent_close_type == 1 ) eventBuyClosed_SL ++;
			if ( SetCloseEvent_close_type == 2 ) eventBuyClosed_TP ++;
			return(0);
		}
		case OP_SELL:
		{
			if ( SetCloseEvent_close_type == 1 ) eventSellClosed_SL ++;
			if ( SetCloseEvent_close_type == 2 ) eventSellClosed_TP ++;
			return(0);
		}
		case OP_BUYLIMIT:
		{
			if ( SetCloseEvent_close_type == 1 ) eventBuyLimitDeleted_Exp ++;
			return(0);
		}
		case OP_BUYSTOP:
		{
			if ( SetCloseEvent_close_type == 1 ) eventBuyStopDeleted_Exp ++;
			return(0);
		}
		case OP_SELLLIMIT:
		{
			if ( SetCloseEvent_close_type == 1 ) eventSellLimitDeleted_Exp ++;
			return(0);
		}
		case OP_SELLSTOP:
		{
			if ( SetCloseEvent_close_type == 1 ) eventSellStopDeleted_Exp ++;
			return(0);
		}
	}
}

bool LoadVariables( string& variables[], string file_name = "" )
{
	if ( IsTesting() ) return(true);

	int all = ArraySize( variables ), cur;
	for ( cur = 0; cur < all; cur ++ ) variables[cur] = "";

	if ( file_name == "" ) file_name = StringConcatenate( "_ExpertSaves\\", WindowExpertName(), " (", Symbol(), ", ", strPeriod( Period() ), ", ", _MagicNumber, ").dat" );
	int handle  = FileOpen( file_name, FILE_CSV | FILE_READ ), _GetLastError = 0;
	if ( handle < 0 )
	{
		_GetLastError = GetLastError();
		if ( _GetLastError != 4103 ) Print( " LoadVariables() - FileOpen( \"", file_name, "\", FILE_CSV | FILE_READ ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		return(false);
	}

	for ( cur = 0; cur < all; cur ++ )
	{
		variables[cur] = FileReadString( handle );
		_GetLastError = GetLastError();
		if ( _GetLastError != 0 )
		{
			Print( " LoadVariables() - FileReadString( ", handle, " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			FileClose( handle );
			return(false);
		}
	}

	FileClose( handle );
	return(true);
}
void SaveVariables( string variables[], string file_name = "" )
{
	if ( IsTesting() ) return(true);

	if ( file_name == "" ) file_name = StringConcatenate( "_ExpertSaves\\", WindowExpertName(), " (", Symbol(), ", ", strPeriod( Period() ), ", ", _MagicNumber, ").dat" );
	int handle  = FileOpen( file_name, FILE_CSV | FILE_WRITE ), _GetLastError = 0;
	if ( handle < 0 )
	{
		_GetLastError = GetLastError();
		Print( " SaveVariables() - FileOpen( \"", file_name, "\", FILE_CSV | FILE_WRITE ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
		return(-1);
	}

	int all = ArraySize( variables ), cur;
	for ( cur = 0; cur < all; cur ++ )
	{
		if ( FileWrite( handle, variables[cur] ) < 0 )
		{
			_GetLastError = GetLastError();
			Print( " SaveVariables() - FileWrite( ", handle, ", ", variables[cur], " ) - Error #", _GetLastError, " ( ", ErrorDescription( _GetLastError ), " )" );
			break;
		}
	}

	FileClose( handle );
}


//=====START=================================================
int init()
{
	TradeInfoLib_Initialization ( Expert_Id, "SU3D[v5]" );
	return(0);
}

int deinit()
{
	TradeInfoLib_Deinitialization();
	return(0);
}

int start()
{


if (Symbol()== "GBPUSD" && Period()==60) {PipStep = 50; LotExponent=1.35;}
if (Symbol()== "EURUSD" && Period()==60) {PipStep = 40; LotExponent=1.35;}
if (Symbol()== "EURJPY" && Period()==60) {PipStep = 50; LotExponent=1.45;}
if (Symbol()== "USDJPY" && Period()==60) {PipStep = 40; LotExponent=1.35;}
if (Symbol()== "AUDCAD" && Period()==60) {PipStep = 30; LotExponent=1.35;}


if (TotalEquityRisk>5) TotalEquityRisk = 5;

//EURAUD TotalEquityRisk = 2; PipStep = 70; LotExponent=1.25; MaxTrades=18;++18000_89929
//EURCHF TotalEquityRisk = 5; PipStep = 40; LotExponent=1.35;MaxTrades=18;++14000_9577
//GBPCHF TotalEquityRisk = 3; PipStep = 60; LotExponent=1.25;MaxTrades=18;+++14000_89044
//AUDCHF TotalEquityRisk = 4; PipStep = 60; LotExponent=1.35; MaxTrades=18;+ 18000_56855
//AUDJPY TotalEquityRisk = 2; PipStep = 60; LotExponent=1.25; MaxTrades=18;+ 18000_54701
//AUDCAD TotalEquityRisk = 5; PipStep = 30; LotExponent=1.35; MaxTrades=18;+++10000_239558
//CADCHF TotalEquityRisk = 4; PipStep = 50; LotExponent=1.25; MaxTrades=18;12000_34508
//CADJPY TotalEquityRisk = 2; PipStep = 60; LotExponent=1.35; MaxTrades=18;16000_36902
//NZDJPY TotalEquityRisk = 3; PipStep = 50; LotExponent=1.25; MaxTrades=18;16000_55597 

if (Symbol()!= "GBPUSD" 
&& Symbol()!= "AUDCAD"
&& Symbol()!= "EURJPY" 
&& Symbol()!= "USDJPY" 
&& Symbol()!= "EURUSD") 
{Comment("=============================","\n",
"EXPERT STOPPED! Invalid Symbol",
"\n","=============================");
Print ("EXPERT STOPPED! Invalid Symbol");   
return(0);
}

if (Period()!=60)
{Comment("=============================","\n",
   "EXPERT STOPPED! Invalid Period ",
"\n","=============================");
Print ("EXPERT STOPPED! Invalid Period");   
   return(0);
}

StartLot_b = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts),3));
StartLot_s = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts),3));


 if ((StartLot_b < 0.02) || (StartLot_s < 0.02))
    {
     Comment("=============================","\n",
     "EXPERT STOPPED!","\n",
      "Ballans = $",AccountBalance(),"\n",
      "Ballans not less =$", (((10-TotalEquityRisk)*100000*Charts)*0.02)," for work on ",Charts," ñharts, ","Symbol - ", Symbol(),",",Period(),"\n",
      "=============================");
      
      Print ("EXPERT STOPPED! Ballans = $",AccountBalance()," Ballans not less =$", (((10-TotalEquityRisk)*100000*Charts)*0.02)," for work on ",Charts," ñharts"); 
      
      return(0);  
      }
//===================Date&Time===============================  
  if(Year()< 2008 )  return(0);// C êàêîãî ãîäà ðàáîòàåò ýêñïåðò!!!
  if (Year()== Years 
  && Month()>= Months// Åñëè âðåìÿ áîëåå âûõîä
  && Day()>= Days
   )  
     {
      Comment("\n","\n","\n","\n","=============================","\n",
      "Current time is ",TimeToStr(CurTime()),"\n",
      "WORK OF THE EXPERT UP TO ",Years,".","0",Months,".","0",Days,"\n",
      "For the help to mailto: sgibnev@bk.ru","\n","=============================");
      Print ("WORK OF THE EXPERT UP TO ",Years,".","0",Months,".","0",Days);
      
      return(0);  
       } 

//==================================================
  
//	if ( IsTesting()!= true )
//	if (IsVisualMode()!= true)
//	if (AccountNumber() != Account1 && AccountNumber() != Account2 && AccountNumber() != Account3) 
//	  	{	
				
//		Comment("=============================","\n",
 //    "EXPERT STOPPED! Invalid Account","\n",
 //    "For the help to mailto: sgibnev@bk.ru",
 //   "\n","=============================");
 //    Print ("EXPERT STOPPED! Invalid Account");   
 //    return(0);  
//	}


//====================================================

	if ( !IsOK() ) { return(0); }

	int _GetLastError, _OrdersTotal = OrdersTotal();

	double l, op;
	double max_lot_b = 0.0, level_b = 0.0, summ_lot_b = 0.0, ave_price_b = 0.0; int count_b = 0; static int last_b = 0;
	double max_lot_s = 0.0, level_s = 0.0, summ_lot_s = 0.0, ave_price_s = 0.0; int count_s = 0; static int last_s = 0;


	for ( int z = _OrdersTotal - 1; z >= 0; z -- )
	{
	//=============================
		 

	
		//================================================	
		if ( !OrderSelect( z, SELECT_BY_POS, MODE_TRADES ) )
		{
			_GetLastError = GetLastError();
			Print( "OrderSelect( ", z, ", SELECT_BY_POS, MODE_TRADES ) - Error #", _GetLastError );
			continue;
		}
		if ( OrderMagicNumber() != _MagicNumber || OrderSymbol() != _Symbol ) continue;

		l = OrderLots();
		op = OrderOpenPrice();

		if ( OrderType() == OP_BUY )
		{
			count_b ++;
			summ_lot_b += l;
			ave_price_b += op*l;
			if ( l > max_lot_b )
			{
				max_lot_b = l;
				level_b = op;
			}
		}

		if ( OrderType() == OP_SELL )
		{
			count_s ++;
			summ_lot_s += l;
			ave_price_s += op*l;
			if ( l > max_lot_s )
			{
				max_lot_s = l;
				level_s = op;
			}
		}
	}

	// check fo close
	if ( max_lot_b > 0.0 )
	{
		ave_price_b = NormalizeDouble( ave_price_b/summ_lot_b, _Digits );
		if ( NormalizeDouble( Bid - ave_price_b - TakeProfit*_Point, _Digits ) >= 0.0 )
		{
			if ( !CloseAll( OP_BUY ) ) return(-1);
			max_lot_b = 0.0;
		}
		if ( StopLoss > 0 && count_b >= MaxTrades )
		{
			if ( NormalizeDouble( level_b - Bid - StopLoss*_Point, _Digits ) >= 0.0 )
			{
				Print( "StopLoss for BUY!" );
				if ( !CloseAll( OP_BUY ) ) return(-1);
				max_lot_b = 0.0;
			}
		}
	}
	if ( max_lot_s > 0.0 )
	{
		ave_price_s = NormalizeDouble( ave_price_s/summ_lot_s, _Digits );
		if ( NormalizeDouble( ave_price_s - Ask - TakeProfit*_Point, _Digits ) >= 0.0 )
		{
			if ( !CloseAll( OP_SELL ) ) return(-1);
			max_lot_s = 0.0;
		}
		if ( StopLoss > 0 && count_s >= MaxTrades )
		{
			if ( NormalizeDouble( Ask - level_s - StopLoss*_Point, _Digits ) >= 0.0 )
			{
				Print( "StopLoss for SELL!" );
				if ( !CloseAll( OP_SELL ) ) return(-1);
				max_lot_s = 0.0;
			}
		}
	}

  if ( aSTLM[1]>0 && count_s>0) StartLot_b = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts/TotalEquityRisk/Profit*2),2));
  //  if ( L2A && count_s>0) StartLot_b = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts*TotalEquityRisk),3));
//  if ( L3 && count_s>0) StartLot_b = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts*TotalEquityRisk),3));
  
 if ( aSTLM[1]<0 && count_b>0) StartLot_s = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts/TotalEquityRisk/Profit*2),2));
//  if ( S2A && count_b>0) StartLot_s = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts*TotalEquityRisk),3));
//  if ( S3 && count_b>0) StartLot_s = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts*TotalEquityRisk),3));



//+------------------------------------------------------------------+
//|                                                       stdlib.mqh |
//|                      Copyright © 2004, MetaQuotes Software Corp. |
//|                                       http://www.metaquotes.net/ |
//+------------------------------------------------------------------+
RSTL = 
0.001754385964912*Open[shift]
 +0.001754385964912*Open[shift+1]
 +0.001754385964912*Open[shift+2]
 +0.001754385964912*Open[shift+3]
 +0.001754385964912*Open[shift+4]
 +0.001754385964912*Open[shift+5]
 +0.001754385964912*Open[shift+6]
 +0.001754385964912*Open[shift+7]
 +0.001754385964912*Open[shift+8]
 +0.001754385964912*Open[shift+9]
 +0.001754385964912*Open[shift+10]
 +0.001754385964912*Open[shift+11]
 +0.001754385964912*Open[shift+12]
 +0.001754385964912*Open[shift+13]
 +0.001754385964912*Open[shift+14]
 +0.001754385964912*Open[shift+15]
 +0.001754385964912*Open[shift+16]
 +0.001754385964912*Open[shift+17]
 +0.001754385964912*Open[shift+18]
 +0.001754385964912*Open[shift+19]
 +0.001754385964912*Open[shift+20]
 +0.001754385964912*Open[shift+21]
 +0.001754385964912*Open[shift+22]
 +0.001754385964912*Open[shift+23]
 +0.001754385964912*Open[shift+24]
 +0.001754385964912*Open[shift+25]
 +0.001754385964912*Open[shift+26]
 +0.001754385964912*Open[shift+27]
 +0.001754385964912*Open[shift+28]
 +0.001754385964912*Open[shift+29]
 +0.001754385964912*Open[shift+30]
 +0.001754385964912*Open[shift+31]
 +0.001754385964912*Open[shift+32]
 +0.001754385964912*Open[shift+33]
 +0.001754385964912*Open[shift+34]
 +0.001754385964912*Open[shift+35]
 +0.001754385964912*Open[shift+36]
 +0.001754385964912*Open[shift+37]
 +0.001754385964912*Open[shift+38]
 +0.001754385964912*Open[shift+39]
 +0.001754385964912*Open[shift+40]
 +0.001754385964912*Open[shift+41]
 +0.001754385964912*Open[shift+42]
 +0.001754385964912*Open[shift+43]
 +0.001754385964912*Open[shift+44]
 +0.001754385964912*Open[shift+45]
 +0.001754385964912*Open[shift+46]
 +0.001754385964912*Open[shift+47]
 +0.001754385964912*Open[shift+48]
 +0.001754385964912*Open[shift+49]
 +0.001754385964912*Open[shift+50]
 +0.001754385964912*Open[shift+51]
 +0.001754385964912*Open[shift+52]
 +0.001754385964912*Open[shift+53]
 +0.001754385964912*Open[shift+54]
 +0.001754385964912*Open[shift+55]
 +0.001754385964912*Open[shift+56]
 +0.001754385964912*Open[shift+57]
 +0.001754385964912*Open[shift+58]
 +0.001754385964912*Open[shift+59]
 +0.001754385964912*Open[shift+60]
 +0.001754385964912*Open[shift+61]
 +0.001754385964912*Open[shift+62]
 +0.001754385964912*Open[shift+63]
 +0.001754385964912*Open[shift+64]
 +0.001754385964912*Open[shift+65]
 +0.001754385964912*Open[shift+66]
 +0.001754385964912*Open[shift+67]
 +0.001754385964912*Open[shift+68]
 +0.001754385964912*Open[shift+69]
 +0.001754385964912*Open[shift+70]
 +0.001754385964912*Open[shift+71]
 +0.001754385964912*Open[shift+72]
 +0.001754385964912*Open[shift+73]
 +0.001754385964912*Open[shift+74]
 +0.001754385964912*Open[shift+75]
 +0.001754385964912*Open[shift+76]
 +0.001754385964912*Open[shift+77]
 +0.001754385964912*Open[shift+78]
 +0.001754385964912*Open[shift+79]
 +0.001754385964912*Open[shift+80]
 +0.001754385964912*Open[shift+81]
 +0.001754385964912*Open[shift+82]
 +0.001754385964912*Open[shift+83]
 +0.001754385964912*Open[shift+84]
 +0.001754385964912*Open[shift+85]
 +0.001754385964912*Open[shift+86]
 +0.001754385964912*Open[shift+87]
 +0.001754385964912*Open[shift+88]
 +0.001754385964912*Open[shift+89]
 +0.001754385964912*Open[shift+90]
 +0.001754385964912*Open[shift+91]
 +0.001754385964912*Open[shift+92]
 +0.001754385964912*Open[shift+93]
 +0.001754385964912*Open[shift+94]
 +0.001754385964912*Open[shift+95]
 +0.001754385964912*Open[shift+96]
 +0.001754385964912*Open[shift+97]
 +0.001754385964912*Open[shift+98]
 +0.001754385964912*Open[shift+99]
 +0.001754385964912*Open[shift+100]
 +0.001754385964912*Open[shift+101]
 +0.001754385964912*Open[shift+102]
 +0.001754385964912*Open[shift+103]
 +0.001754385964912*Open[shift+104]
 +0.001754385964912*Open[shift+105]
 +0.001754385964912*Open[shift+106]
 +0.001754385964912*Open[shift+107]
 +0.001754385964912*Open[shift+108]
 +0.001754385964912*Open[shift+109]
 +0.001754385964912*Open[shift+110]
 +0.001754385964912*Open[shift+111]
 +0.001754385964912*Open[shift+112]
 +0.001754385964912*Open[shift+113]
 +0.001754385964912*Open[shift+114]
 +0.001754385964912*Open[shift+115]
 +0.001754385964912*Open[shift+116]
 +0.001754385964912*Open[shift+117]
 +0.001754385964912*Open[shift+118]
 +0.001754385964912*Open[shift+119]
 +0.001754385964912*Open[shift+120]
 +0.001754385964912*Open[shift+121]
 +0.001754385964912*Open[shift+122]
 +0.001754385964912*Open[shift+123]
 +0.001754385964912*Open[shift+124]
 +0.001754385964912*Open[shift+125]
 +0.001754385964912*Open[shift+126]
 +0.001754385964912*Open[shift+127]
 +0.001754385964912*Open[shift+128]
 +0.001754385964912*Open[shift+129]
 +0.001754385964912*Open[shift+130]
 +0.001754385964912*Open[shift+131]
 +0.001754385964912*Open[shift+132]
 +0.001754385964912*Open[shift+133]
 +0.001754385964912*Open[shift+134]
 +0.001754385964912*Open[shift+135]
 +0.001754385964912*Open[shift+136]
 +0.001754385964912*Open[shift+137]
 +0.001754385964912*Open[shift+138]
 +0.001754385964912*Open[shift+139]
 +0.001754385964912*Open[shift+140]
 +0.001754385964912*Open[shift+141]
 +0.001754385964912*Open[shift+142]
 +0.001754385964912*Open[shift+143]
 +0.001754385964912*Open[shift+144]
 +0.001754385964912*Open[shift+145]
 +0.001754385964912*Open[shift+146]
 +0.001754385964912*Open[shift+147]
 +0.001754385964912*Open[shift+148]
 +0.001754385964912*Open[shift+149]
 +0.001754385964912*Open[shift+150]
 +0.001754385964912*Open[shift+151]
 +0.001754385964912*Open[shift+152]
 +0.001754385964912*Open[shift+153]
 +0.001754385964912*Open[shift+154]
 +0.001754385964912*Open[shift+155]
 +0.001754385964912*Open[shift+156]
 +0.001754385964912*Open[shift+157]
 +0.001754385964912*Open[shift+158]
 +0.001754385964912*Open[shift+159]
 +0.001754385964912*Open[shift+160]
 +0.001754385964912*Open[shift+161]
 +0.001754385964912*Open[shift+162]
 +0.001754385964912*Open[shift+163]
 +0.001754385964912*Open[shift+164]
 +0.001754385964912*Open[shift+165]
 +0.001754385964912*Open[shift+166]
 +0.001754385964912*Open[shift+167]
 +0.001754385964912*Open[shift+168]
 +0.001754385964912*Open[shift+169]
 +0.001754385964912*Open[shift+170]
 +0.001754385964912*Open[shift+171]
 +0.001754385964912*Open[shift+172]
 +0.001754385964912*Open[shift+173]
 +0.001754385964912*Open[shift+174]
 +0.001754385964912*Open[shift+175]
 +0.001754385964912*Open[shift+176]
 +0.001754385964912*Open[shift+177]
 +0.001754385964912*Open[shift+178]
 +0.001754385964912*Open[shift+179]
 +0.001754385964912*Open[shift+180]
 +0.001754385964912*Open[shift+181]
 +0.001754385964912*Open[shift+182]
 +0.001754385964912*Open[shift+183]
 +0.001754385964912*Open[shift+184]
 +0.001754385964912*Open[shift+185]
 +0.001754385964912*Open[shift+186]
 +0.001754385964912*Open[shift+187]
 +0.001754385964912*Open[shift+188]
 +0.001754385964912*Open[shift+189]
 +0.001754385964912*Open[shift+190]
 +0.001754385964912*Open[shift+191]
 +0.001754385964912*Open[shift+192]
 +0.001754385964912*Open[shift+193]
 +0.001754385964912*Open[shift+194]
 +0.001754385964912*Open[shift+195]
 +0.001754385964912*Open[shift+196]
 +0.001754385964912*Open[shift+197]
 +0.001754385964912*Open[shift+198]
 +0.001754385964912*Open[shift+199]
 +0.001754385964912*Open[shift+200]
 +0.001754385964912*Open[shift+201]
 +0.001754385964912*Open[shift+202]
 +0.001754385964912*Open[shift+203]
 +0.001754385964912*Open[shift+204]
 +0.001754385964912*Open[shift+205]
 +0.001754385964912*Open[shift+206]
 +0.001754385964912*Open[shift+207]
 +0.001754385964912*Open[shift+208]
 +0.001754385964912*Open[shift+209]
 +0.001754385964912*Open[shift+210]
 +0.001754385964912*Open[shift+211]
 +0.001754385964912*Open[shift+212]
 +0.001754385964912*Open[shift+213]
 +0.001754385964912*Open[shift+214]
 +0.001754385964912*Open[shift+215]
 +0.001754385964912*Open[shift+216]
 +0.001754385964912*Open[shift+217]
 +0.001754385964912*Open[shift+218]
 +0.001754385964912*Open[shift+219]
 +0.001754385964912*Open[shift+220]
 +0.001754385964912*Open[shift+221]
 +0.001754385964912*Open[shift+222]
 +0.001754385964912*Open[shift+223]
 +0.001754385964912*Open[shift+224]
 +0.001754385964912*Open[shift+225]
 +0.001754385964912*Open[shift+226]
 +0.001754385964912*Open[shift+227]
 +0.001754385964912*Open[shift+228]
 +0.001754385964912*Open[shift+229]
 +0.001754385964912*Open[shift+230]
 +0.001754385964912*Open[shift+231]
 +0.001754385964912*Open[shift+232]
 +0.001754385964912*Open[shift+233]
 +0.001754385964912*Open[shift+234]
 +0.001754385964912*Open[shift+235]
 +0.001754385964912*Open[shift+236]
 +0.001754385964912*Open[shift+237]
 +0.001754385964912*Open[shift+238]
 +0.001754385964912*Open[shift+239]
 +0.001754385964912*Open[shift+240]
 +0.001754385964912*Open[shift+241]
 +0.001754385964912*Open[shift+242]
 +0.001754385964912*Open[shift+243]
 +0.001754385964912*Open[shift+244]
 +0.001754385964912*Open[shift+245]
 +0.001754385964912*Open[shift+246]
 +0.001754385964912*Open[shift+247]
 +0.001754385964912*Open[shift+248]
 +0.001754385964912*Open[shift+249]
 +0.001754385964912*Open[shift+250]
 +0.001754385964912*Open[shift+251]
 +0.001754385964912*Open[shift+252]
 +0.001754385964912*Open[shift+253]
 +0.001754385964912*Open[shift+254]
 +0.001754385964912*Open[shift+255]
 +0.001754385964912*Open[shift+256]
 +0.001754385964912*Open[shift+257]
 +0.001754385964912*Open[shift+258]
 +0.001754385964912*Open[shift+259]
 +0.001754385964912*Open[shift+260]
 +0.001754385964912*Open[shift+261]
 +0.001754385964912*Open[shift+262]
 +0.001754385964912*Open[shift+263]
 +0.001754385964912*Open[shift+264]
 +0.001754385964912*Open[shift+265]
 +0.001754385964912*Open[shift+266]
 +0.001754385964912*Open[shift+267]
 +0.001754385964912*Open[shift+268]
 +0.001754385964912*Open[shift+269]
 +0.001754385964912*Open[shift+270]
 +0.001754385964912*Open[shift+271]
 +0.001754385964912*Open[shift+272]
 +0.001754385964912*Open[shift+273]
 +0.001754385964912*Open[shift+274]
 +0.001754385964912*Open[shift+275]
 +0.001754385964912*Open[shift+276]
 +0.001754385964912*Open[shift+277]
 +0.001754385964912*Open[shift+278]
 +0.001754385964912*Open[shift+279]
 +0.001754385964912*Open[shift+280]
 +0.001754385964912*Open[shift+281]
 +0.001754385964912*Open[shift+282]
 +0.001754385964912*Open[shift+283]
 +0.001754385964912*Open[shift+284]
 +0.001754385964912*Open[shift+285]
 +0.001754385964912*Open[shift+286]
 +0.001754385964912*Open[shift+287]
 +0.001754385964912*Open[shift+288]
 +0.001754385964912*Open[shift+289]
 +0.001754385964912*Open[shift+290]
 +0.001754385964912*Open[shift+291]
 +0.001754385964912*Open[shift+292]
 +0.001754385964912*Open[shift+293]
 +0.001754385964912*Open[shift+294]
 +0.001754385964912*Open[shift+295]
 +0.001754385964912*Open[shift+296]
 +0.001754385964912*Open[shift+297]
 +0.001754385964912*Open[shift+298]
 +0.001754385964912*Open[shift+299]
 +0.001754385964912*Open[shift+300]
 +0.001754385964912*Open[shift+301]
 +0.001754385964912*Open[shift+302]
 +0.001754385964912*Open[shift+303]
 +0.001754385964912*Open[shift+304]
 +0.001754385964912*Open[shift+305]
 +0.001754385964912*Open[shift+306]
 +0.001754385964912*Open[shift+307]
 +0.001754385964912*Open[shift+308]
 +0.001754385964912*Open[shift+309]
 +0.001754385964912*Open[shift+310]
 +0.001754385964912*Open[shift+311]
 +0.001754385964912*Open[shift+312]
 +0.001754385964912*Open[shift+313]
 +0.001754385964912*Open[shift+314]
 +0.001754385964912*Open[shift+315]
 +0.001754385964912*Open[shift+316]
 +0.001754385964912*Open[shift+317]
 +0.001754385964912*Open[shift+318]
 +0.001754385964912*Open[shift+319]
 +0.001754385964912*Open[shift+320]
 +0.001754385964912*Open[shift+321]
 +0.001754385964912*Open[shift+322]
 +0.001754385964912*Open[shift+323]
 +0.001754385964912*Open[shift+324]
 +0.001754385964912*Open[shift+325]
 +0.001754385964912*Open[shift+326]
 +0.001754385964912*Open[shift+327]
 +0.001754385964912*Open[shift+328]
 +0.001754385964912*Open[shift+329]
 +0.001754385964912*Open[shift+330]
 +0.001754385964912*Open[shift+331]
 +0.001754385964912*Open[shift+332]
 +0.001754385964912*Open[shift+333]
 +0.001754385964912*Open[shift+334]
 +0.001754385964912*Open[shift+335]
 +0.001754385964912*Open[shift+336]
 +0.001754385964912*Open[shift+337]
 +0.001754385964912*Open[shift+338]
 +0.001754385964912*Open[shift+339]
 +0.001754385964912*Open[shift+340]
 +0.001754385964912*Open[shift+341]
 +0.001754385964912*Open[shift+342]
 +0.001754385964912*Open[shift+343]
 +0.001754385964912*Open[shift+344]
 +0.001754385964912*Open[shift+345]
 +0.001754385964912*Open[shift+346]
 +0.001754385964912*Open[shift+347]
 +0.001754385964912*Open[shift+348]
 +0.001754385964912*Open[shift+349]
 +0.001754385964912*Open[shift+350]
 +0.001754385964912*Open[shift+351]
 +0.001754385964912*Open[shift+352]
 +0.001754385964912*Open[shift+353]
 +0.001754385964912*Open[shift+354]
 +0.001754385964912*Open[shift+355]
 +0.001754385964912*Open[shift+356]
 +0.001754385964912*Open[shift+357]
 +0.001754385964912*Open[shift+358]
 +0.001754385964912*Open[shift+359]
 +0.001754385964912*Open[shift+360]
 +0.001754385964912*Open[shift+361]
 +0.001754385964912*Open[shift+362]
 +0.001754385964912*Open[shift+363]
 +0.001754385964912*Open[shift+364]
 +0.001754385964912*Open[shift+365]
 +0.001754385964912*Open[shift+366]
 +0.001754385964912*Open[shift+367]
 +0.001754385964912*Open[shift+368]
 +0.001754385964912*Open[shift+369]
 +0.001754385964912*Open[shift+370]
 +0.001754385964912*Open[shift+371]
 +0.001754385964912*Open[shift+372]
 +0.001754385964912*Open[shift+373]
 +0.001754385964912*Open[shift+374]
 +0.001754385964912*Open[shift+375]
 +0.001754385964912*Open[shift+376]
 +0.001754385964912*Open[shift+377]
 +0.001754385964912*Open[shift+378]
 +0.001754385964912*Open[shift+379]
 +0.001754385964912*Open[shift+380]
 +0.001754385964912*Open[shift+381]
 +0.001754385964912*Open[shift+382]
 +0.001754385964912*Open[shift+383]
 +0.001754385964912*Open[shift+384]
 +0.001754385964912*Open[shift+385]
 +0.001754385964912*Open[shift+386]
 +0.001754385964912*Open[shift+387]
 +0.001754385964912*Open[shift+388]
 +0.001754385964912*Open[shift+389]
 +0.001754385964912*Open[shift+390]
 +0.001754385964912*Open[shift+391]
 +0.001754385964912*Open[shift+392]
 +0.001754385964912*Open[shift+393]
 +0.001754385964912*Open[shift+394]
 +0.001754385964912*Open[shift+395]
 +0.001754385964912*Open[shift+396]
 +0.001754385964912*Open[shift+397]
 +0.001754385964912*Open[shift+398]
 +0.001754385964912*Open[shift+399]
 +0.001754385964912*Open[shift+400]
 +0.001754385964912*Open[shift+401]
 +0.001754385964912*Open[shift+402]
 +0.001754385964912*Open[shift+403]
 +0.001754385964912*Open[shift+404]
 +0.001754385964912*Open[shift+405]
 +0.001754385964912*Open[shift+406]
 +0.001754385964912*Open[shift+407]
 +0.001754385964912*Open[shift+408]
 +0.001754385964912*Open[shift+409]
 +0.001754385964912*Open[shift+410]
 +0.001754385964912*Open[shift+411]
 +0.001754385964912*Open[shift+412]
 +0.001754385964912*Open[shift+413]
 +0.001754385964912*Open[shift+414]
 +0.001754385964912*Open[shift+415]
 +0.001754385964912*Open[shift+416]
 +0.001754385964912*Open[shift+417]
 +0.001754385964912*Open[shift+418]
 +0.001754385964912*Open[shift+419]
 +0.001754385964912*Open[shift+420]
 +0.001754385964912*Open[shift+421]
 +0.001754385964912*Open[shift+422]
 +0.001754385964912*Open[shift+423]
 +0.001754385964912*Open[shift+424]
 +0.001754385964912*Open[shift+425]
 +0.001754385964912*Open[shift+426]
 +0.001754385964912*Open[shift+427]
 +0.001754385964912*Open[shift+428]
 +0.001754385964912*Open[shift+429]
 +0.001754385964912*Open[shift+430]
 +0.001754385964912*Open[shift+431]
 +0.001754385964912*Open[shift+432]
 +0.001754385964912*Open[shift+433]
 +0.001754385964912*Open[shift+434]
 +0.001754385964912*Open[shift+435]
 +0.001754385964912*Open[shift+436]
 +0.001754385964912*Open[shift+437]
 +0.001754385964912*Open[shift+438]
 +0.001754385964912*Open[shift+439]
 +0.001754385964912*Open[shift+440]
 +0.001754385964912*Open[shift+441]
 +0.001754385964912*Open[shift+442]
 +0.001754385964912*Open[shift+443]
 +0.001754385964912*Open[shift+444]
 +0.001754385964912*Open[shift+445]
 +0.001754385964912*Open[shift+446]
 +0.001754385964912*Open[shift+447]
 +0.001754385964912*Open[shift+448]
 +0.001754385964912*Open[shift+449]
 +0.001754385964912*Open[shift+450]
 +0.001754385964912*Open[shift+451]
 +0.001754385964912*Open[shift+452]
 +0.001754385964912*Open[shift+453]
 +0.001754385964912*Open[shift+454]
 +0.001754385964912*Open[shift+455]
 +0.001754385964912*Open[shift+456]
 +0.001754385964912*Open[shift+457]
 +0.001754385964912*Open[shift+458]
 +0.001754385964912*Open[shift+459]
 +0.001754385964912*Open[shift+460]
 +0.001754385964912*Open[shift+461]
 +0.001754385964912*Open[shift+462]
 +0.001754385964912*Open[shift+463]
 +0.001754385964912*Open[shift+464]
 +0.001754385964912*Open[shift+465]
 +0.001754385964912*Open[shift+466]
 +0.001754385964912*Open[shift+467]
 +0.001754385964912*Open[shift+468]
 +0.001754385964912*Open[shift+469]
 +0.001754385964912*Open[shift+470]
 +0.001754385964912*Open[shift+471]
 +0.001754385964912*Open[shift+472]
 +0.001754385964912*Open[shift+473]
 +0.001754385964912*Open[shift+474]
 +0.001754385964912*Open[shift+475]
 +0.001754385964912*Open[shift+476]
 +0.001754385964912*Open[shift+477]
 +0.001754385964912*Open[shift+478]
 +0.001754385964912*Open[shift+479]
 +0.001754385964912*Open[shift+480]
 +0.001754385964912*Open[shift+481]
 +0.001754385964912*Open[shift+482]
 +0.001754385964912*Open[shift+483]
 +0.001754385964912*Open[shift+484]
 +0.001754385964912*Open[shift+485]
 +0.001754385964912*Open[shift+486]
 +0.001754385964912*Open[shift+487]
 +0.001754385964912*Open[shift+488]
 +0.001754385964912*Open[shift+489]
 +0.001754385964912*Open[shift+490]
 +0.001754385964912*Open[shift+491]
 +0.001754385964912*Open[shift+492]
 +0.001754385964912*Open[shift+493]
 +0.001754385964912*Open[shift+494]
 +0.001754385964912*Open[shift+495]
 +0.001754385964912*Open[shift+496]
 +0.001754385964912*Open[shift+497]
 +0.001754385964912*Open[shift+498]
 +0.001754385964912*Open[shift+499]
 +0.001754385964912*Open[shift+500]
 +0.001754385964912*Open[shift+501]
 +0.001754385964912*Open[shift+502]
 +0.001754385964912*Open[shift+503]
 +0.001754385964912*Open[shift+504]
 +0.001754385964912*Open[shift+505]
 +0.001754385964912*Open[shift+506]
 +0.001754385964912*Open[shift+507]
 +0.001754385964912*Open[shift+508]
 +0.001754385964912*Open[shift+509]
 +0.001754385964912*Open[shift+510]
 +0.001754385964912*Open[shift+511]
 +0.001754385964912*Open[shift+512]
 +0.001754385964912*Open[shift+513]
 +0.001754385964912*Open[shift+514]
 +0.001754385964912*Open[shift+515]
 +0.001754385964912*Open[shift+516]
 +0.001754385964912*Open[shift+517]
 +0.001754385964912*Open[shift+518]
 +0.001754385964912*Open[shift+519]
 +0.001754385964912*Open[shift+520]
 +0.001754385964912*Open[shift+521]
 +0.001754385964912*Open[shift+522]
 +0.001754385964912*Open[shift+523]
 +0.001754385964912*Open[shift+524]
 +0.001754385964912*Open[shift+525]
 +0.001754385964912*Open[shift+526]
 +0.001754385964912*Open[shift+527]
 +0.001754385964912*Open[shift+528]
 +0.001754385964912*Open[shift+529]
 +0.001754385964912*Open[shift+530]
 +0.001754385964912*Open[shift+531]
 +0.001754385964912*Open[shift+532]
 +0.001754385964912*Open[shift+533]
 +0.001754385964912*Open[shift+534]
 +0.001754385964912*Open[shift+535]
 +0.001754385964912*Open[shift+536]
 +0.001754385964912*Open[shift+537]
 +0.001754385964912*Open[shift+538]
 +0.001754385964912*Open[shift+539]
 +0.001754385964912*Open[shift+540]
 +0.001754385964912*Open[shift+541]
 +0.001754385964912*Open[shift+542]
 +0.001754385964912*Open[shift+543]
 +0.001754385964912*Open[shift+544]
 +0.001754385964912*Open[shift+545]
 +0.001754385964912*Open[shift+546]
 +0.001754385964912*Open[shift+547]
 +0.001754385964912*Open[shift+548]
 +0.001754385964912*Open[shift+549]
 +0.001754385964912*Open[shift+550]
 +0.001754385964912*Open[shift+551]
 +0.001754385964912*Open[shift+552]
 +0.001754385964912*Open[shift+553]
 +0.001754385964912*Open[shift+554]
 +0.001754385964912*Open[shift+555]
 +0.001754385964912*Open[shift+556]
 +0.001754385964912*Open[shift+557]
 +0.001754385964912*Open[shift+558]
 +0.001754385964912*Open[shift+559]
 +0.001754385964912*Open[shift+560]
 +0.001754385964912*Open[shift+561]
 +0.001754385964912*Open[shift+562]
 +0.001754385964912*Open[shift+563]
 +0.001754385964912*Open[shift+564]
 +0.001754385964912*Open[shift+565]
 +0.001754385964912*Open[shift+566]
 +0.001754385964912*Open[shift+567]
 +0.001754385964912*Open[shift+568]
 +0.001754385964912*Open[shift+569];
  

RFTL = 
-0.0025097319*Open[shift+0]
+0.0513007762*Open[shift+1]
+0.1142800493*Open[shift+2]
+0.1699342860*Open[shift+3]
+0.2025269304*Open[shift+4]
+0.2025269304*Open[shift+5]
+0.1699342860*Open[shift+6]
+0.1142800493*Open[shift+7]
+0.0513007762*Open[shift+8]
-0.0025097319*Open[shift+9]
-0.0353166244*Open[shift+10]
-0.0433375629*Open[shift+11]
-0.0311244617*Open[shift+12]
-0.0088618137*Open[shift+13]
+0.0120580088*Open[shift+14]
+0.0233183633*Open[shift+15]
+0.0221931304*Open[shift+16]
+0.0115769653*Open[shift+17]
-0.0022157966*Open[shift+18]
-0.0126536111*Open[shift+19]
-0.0157416029*Open[shift+20]
-0.0113395830*Open[shift+21]
-0.0025905610*Open[shift+22]
+0.0059521459*Open[shift+23]
+0.0105212252*Open[shift+24]
+0.0096970755*Open[shift+25]
+0.0046585685*Open[shift+26]
-0.0017079230*Open[shift+27]
-0.0063513565*Open[shift+28]
-0.0074539350*Open[shift+29]
-0.0050439973*Open[shift+30]
-0.0007459678*Open[shift+31]
+0.0032271474*Open[shift+32]
+0.0051357867*Open[shift+33]
+0.0044454862*Open[shift+34]
+0.0018784961*Open[shift+35]
-0.0011065767*Open[shift+36]
-0.0031162862*Open[shift+37]
-0.0033443253*Open[shift+38]
-0.0022163335*Open[shift+39]
+0.0002573669*Open[shift+40]
+0.0003650790*Open[shift+41]
+0.0060440751*Open[shift+42]
+0.0018747783*Open[shift+43];	

	FATL = 
0.4360409450*Open[shift+0]
+0.3658689069*Open[shift+1]
+0.2460452079*Open[shift+2]
+0.1104506886*Open[shift+3]
-0.0054034585*Open[shift+4]
-0.0760367731*Open[shift+5]
-0.0933058722*Open[shift+6]
-0.0670110374*Open[shift+7]
-0.0190795053*Open[shift+8]
+0.0259609206*Open[shift+9]
+0.0502044896*Open[shift+10]
+0.0477818607*Open[shift+11]
+0.0249252327*Open[shift+12]
-0.0047706151*Open[shift+13]
-0.0272432537*Open[shift+14]
-0.0338917071*Open[shift+15]
-0.0244141482*Open[shift+16]
-0.0055774838*Open[shift+17]
+0.0128149838*Open[shift+18]
+0.0226522218*Open[shift+19]
+0.0208778257*Open[shift+20]
+0.0100299086*Open[shift+21]
-0.0036771622*Open[shift+22]
-0.0136744850*Open[shift+23]
-0.0160483392*Open[shift+24]
-0.0108597376*Open[shift+25]
-0.0016060704*Open[shift+26]
+0.0069480557*Open[shift+27]
+0.0110573605*Open[shift+28]
+0.0095711419*Open[shift+29]
+0.0040444064*Open[shift+30]
-0.0023824623*Open[shift+31]
-0.0067093714*Open[shift+32]
-0.0072003400*Open[shift+33]
-0.0047717710*Open[shift+34]
+0.0005541115*Open[shift+35]
+0.0007860160*Open[shift+36]
+0.0130129076*Open[shift+37]
+0.0040364019*Open[shift+38];

SATL = 
0.0982862174*Open[shift+0]
+0.0975682269*Open[shift+1]
+0.0961401078*Open[shift+2]
+0.0940230544*Open[shift+3]
+0.0912437090*Open[shift+4]
+0.0878391006*Open[shift+5]
+0.0838544303*Open[shift+6]
+0.0793406350*Open[shift+7]
+0.0743569346*Open[shift+8]
+0.0689666682*Open[shift+9]
+0.0632381578*Open[shift+10]
+0.0572428925*Open[shift+11]
+0.0510534242*Open[shift+12]
+0.0447468229*Open[shift+13]
+0.0383959950*Open[shift+14]
+0.0320735368*Open[shift+15]
+0.0258537721*Open[shift+16]
+0.0198005183*Open[shift+17]
+0.0139807863*Open[shift+18]
+0.0084512448*Open[shift+19]
+0.0032639979*Open[shift+20]
-0.0015350359*Open[shift+21]
-0.0059060082*Open[shift+22]
-0.0098190256*Open[shift+23]
-0.0132507215*Open[shift+24]
-0.0161875265*Open[shift+25]
-0.0186164872*Open[shift+26]
-0.0205446727*Open[shift+27]
-0.0219739146*Open[shift+28]
-0.0229204861*Open[shift+29]
-0.0234080863*Open[shift+30]
-0.0234566315*Open[shift+31]
-0.0231017777*Open[shift+32]
-0.0223796900*Open[shift+33]
-0.0213300463*Open[shift+34]
-0.0199924534*Open[shift+35]
-0.0184126992*Open[shift+36]
-0.0166377699*Open[shift+37]
-0.0147139428*Open[shift+38]
-0.0126796776*Open[shift+39]
-0.0105938331*Open[shift+40]
-0.0084736770*Open[shift+41]
-0.0063841850*Open[shift+42]
-0.0043466731*Open[shift+43]
-0.0023956944*Open[shift+44]
-0.0005535180*Open[shift+45]
+0.0011421469*Open[shift+46]
+0.0026845693*Open[shift+47]
+0.0040471369*Open[shift+48]
+0.0052380201*Open[shift+49]
+0.0062194591*Open[shift+50]
+0.0070340085*Open[shift+51]
+0.0076266453*Open[shift+52]
+0.0080376628*Open[shift+53]
+0.0083037666*Open[shift+54]
+0.0083694798*Open[shift+55]
+0.0082901022*Open[shift+56]
+0.0080741359*Open[shift+57]
+0.0077543820*Open[shift+58]
+0.0073260526*Open[shift+59]
+0.0068163569*Open[shift+60]
+0.0062325477*Open[shift+61]
+0.0056078229*Open[shift+62]
+0.0049516078*Open[shift+63]
+0.0161380976*Open[shift+64];


PCCI = Open[shift]-FATL ;

FTLM = FATL - RSTL ;
STLM = SATL - RSTL ;
RBCI = FATL - SATL ;

aRBCI[4]=aRBCI[3] ; 
aRBCI[3]=aRBCI[2] ; 
aRBCI[2]=aRBCI[1] ; 
aRBCI[1]=RBCI ;

aSATL[4]=aSATL[3] ; 
aSATL[3]=aSATL[2] ; 
aSATL[2]=aSATL[1] ; 
aSATL[1]=SATL ;

aFATL[4]=aFATL[4] ; 
aFATL[3]=aFATL[2] ; 
aFATL[2]=aFATL[1] ; 
aFATL[1]=FATL ;

aRFTL[4]=aRFTL[3] ; 
aRFTL[3]=aRFTL[2] ; 
aRFTL[2]=aRFTL[1] ; 
aRFTL[1]=RFTL ;

aRSTL[4]=aRSTL[3] ; 
aRSTL[3]=aRSTL[2] ; 
aRSTL[2]=aRSTL[1] ; 
aRSTL[1]=RSTL ;

aFTLM[4]=aFTLM[3] ; 
aFTLM[3]=aFTLM[2] ; 
aFTLM[2]=aFTLM[1] ; 
aFTLM[1]=FTLM ;

aSTLM[4]=aSTLM[3] ; 
aSTLM[3]=aSTLM[2] ; 
aSTLM[2]=aSTLM[1] ; 
aSTLM[1]=STLM ;


aPCCI[4]=aPCCI[3] ; 
aPCCI[3]=aPCCI[2] ; 
aPCCI[2]=aPCCI[1] ; 
aPCCI[1]=PCCI ;
//===================ARCTAN==================
tFATL = MathArctan(MathAbs(aFATL[1]-aFATL[2])/0.0005)*180/3.1415926;
tRFTL = MathArctan(MathAbs(aRFTL[1]-aRFTL[2])/0.0005)*180/3.1415926;
tSATL = MathArctan(MathAbs(aSATL[1]-aSATL[2])/0.0005)*180/3.1415926;
tRSTL = MathArctan(MathAbs(aRSTL[1]-aRSTL[2])/0.0005)*180/3.1415926;
tFTLM = MathArctan(MathAbs(aFTLM[1]-aFTLM[2])/0.0005)*180/3.1415926;
tRBCI = MathArctan(MathAbs(aRBCI[1]-aRBCI[2])/0.0005)*180/3.1415926;
tSTLM = MathArctan(MathAbs(aSTLM[1]-aSTLM[2])/0.0005)*180/3.1415926;
tPCCI = MathArctan(MathAbs(aPCCI[1]-aPCCI[2])/0.0005)*180/3.1415926;
       
atFATL[2]=atFATL[1];
atFATL[1]=tFATL;





//========== S I G N A L S ========

//================== 1 ============

//================ 5 ================       
L5=


aPCCI[1]<0
//&& aPCCI[2]<0
//&& aPCCI[1]<aPCCI[2]
&& aRBCI[1]<0
//aSTLM[1]>0
//&& aSATL[1]>aSATL[2]
//&& MathAbs(aRBCI[1])>(RBCImax*Point)
//&& MathAbs(aPCCI[1])>(PCCImax*Point)
;
S5=
aPCCI[1]>0
//&& aPCCI[2]>0
//&& aPCCI[1]>aPCCI[2]
&& aRBCI[1]>0
//aSTLM[1]<0
//&& aSATL[1]<aSATL[2]
//&& MathAbs(aRBCI[1])>(RBCImax*Point)
//&& MathAbs(aPCCI[1])>(PCCImax*Point)
;
//================ 6 ===============


Comment 
(
//"\n","\n","\n","\n",
"----------------------------------------------------------------","\n",
"Charts = ",Charts,"\n",
"TotalEquityRisk  = ",TotalEquityRisk,"\n",
"----------------------------------------------------------------","\n",
"Symbol - ", Symbol(),",",Period(),"\n",
"----------------------------------------------------------------","\n",
"AccountNumber # ",AccountNumber(),"\n",
"AccountName - ",AccountName(),"\n",
"----------------------------------------------------------------","\n",
"Ballans = $",NormalizeDouble(AccountBalance(),2),"\n",
"Equity  = $",AccountEquity (),"\n",
//"Margin  = $",AccountMargin (),"\n",
"----------------------------------------------------------------","\n",
"StartLot    LONG = ",NormalizeDouble(StartLot_b,2),"\n",
"ORDERS  LONG = ",count_b,"\n","\n",
"StartLot   SHORT = ",NormalizeDouble(StartLot_s,2),"\n",
"ORDERS SHORT = ",count_s,"\n",
"----------------------------------------------------------------","\n",
"Current time is   ",TimeToStr(CurTime()),"\n",
"EXPERT UP TO ",Years,".","0",Months,".",Days,"\n",
//"Account1=",Account1,", Account2=",Account2,", Account3=",Account3,"\n",
"----------------------------------------------------------------","\n",
"For the help to mailto: sgibnev@bk.ru");


	if ( TradeDirection >= 0    
      &&   count_b < MaxTrades)
	{
		if ( count_b == 0 )
		{
			if (Time[0] > last_b 
//&& L1
//|| L2A
 //|| L3

// || L8
			      )
					{
if(L1 == true) Print("L1 by order opened"," StartLot=", StartLot_b);
if(L2A == true) Print("L2A by order opened"," StartLot=", StartLot_b);
if(L5 == true) Print("L5 by order opened"," StartLot=", StartLot_b);
if(L6 == true) Print("L6 by order opened"," StartLot=", StartLot_b);

//  StartLot = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts),3));

 

			  
			
        //Print( "LastStopLoss for SELL!" );
	    //	if ( !CloseAll( OP_SELL ) ) return(-1);
		//	max_lot_s = 0.0;
		

		
			}
		}
		else

		{
		   //PipStep = PipStep+StepMode;
			if ( level_b -(PipStep*Point)>= Ask ) OpenBuy( LotExponent*max_lot_b );
	       		}
	}

	// check fo sell
	if (TradeDirection <= 0 
      &&  count_s < MaxTrades)
	{
		if ( count_s == 0 )
		{
			if ( Time[0] > last_s 
// && S1
 //|| S2A

			)
				
			{
if(S1 == true) Print("S1 sell order opened"," StartLot=", StartLot_s);
if(S2A == true) Print("S2A sell order opened"," StartLot=", StartLot_s);
if(S5 == true) Print("S5 sell order opened"," StartLot=", StartLot_s);
if(S6 == true) Print("S6 sell order opened"," StartLot=", StartLot_s);
 
 // StartLot = (NormalizeDouble(AccountBalance()/((10-TotalEquityRisk)*100000*Charts),3));

		
		//	 StartLot = (NormalizeDouble(AccountEquity()/((10-TotalEquityRisk)*100000),2));
		
         // Print( "LastStopLoss for BUY!" );
	//	if ( !CloseAll( OP_BUY ) ) return(-1);

		
	//	max_lot_b = 0.0;
                      
           
			}
		}
		else
		
		{
			//if (StepMode>0)OpenSell(PipStep*LotExponent*count_s);
			
			if ( level_s +(PipStep*Point)<= Bid ) OpenSell(LotExponent*max_lot_s);
	//	if (StepMode>0)	PipStepShort = (StepMode*count_s*LotExponent);
		
		}
	}

	return(0);
}
		
			
void OpenBuy( double Lot )
{
	double _OpenPriceLevel, _StopLossLevel = 0.0, _TakeProfitLevel = 0.0;
	_OpenPriceLevel = NormalizeDouble( Ask, _Digits );
	_TakeProfitLevel = 0.0; //NormalizeDouble( Ask + (TakeProfit + 25)*_Point, _Digits );

	double 	lot_min		= MarketInfo( _Symbol, MODE_MINLOT  );
	double 	lot_max		= MarketInfo( _Symbol, MODE_MAXLOT  );
	double 	lot_step		= MarketInfo( _Symbol, MODE_LOTSTEP );

	Lot = NormalizeDouble( Lot / lot_step, 0 ) * lot_step;
	if ( Lot < lot_min ) Lot = lot_min;
	if ( Lot > lot_max ) Lot = lot_max;

	double needmargin = AccountFreeMarginCheck( Symbol(), OP_BUY, Lot );

	if ( needmargin < 5 || GetLastError() == 134 )
	{
		Print( "We have no money!!!" );
		return(-1);
	}

	if ( _OrderSend ( _Symbol, OP_BUY, Lot, _OpenPriceLevel, Slippage, _StopLossLevel, _TakeProfitLevel, "", _MagicNumber ) < 0 )
		Alert( strComment, ": Error opening Long position!" );
}

void OpenSell( double Lot )
{
	double _OpenPriceLevel, _StopLossLevel = 0.0, _TakeProfitLevel = 0.0;
	_OpenPriceLevel = NormalizeDouble( Bid, _Digits );
	_TakeProfitLevel = 0.0; //NormalizeDouble( Bid - (TakeProfit + 25)*_Point, _Digits );

	double 	lot_min		= MarketInfo( _Symbol, MODE_MINLOT  );
	double 	lot_max		= MarketInfo( _Symbol, MODE_MAXLOT  );
	double 	lot_step		= MarketInfo( _Symbol, MODE_LOTSTEP );

	Lot = NormalizeDouble( Lot / lot_step, 0 ) * lot_step;
	if ( Lot < lot_min ) Lot = lot_min;
	if ( Lot > lot_max ) Lot = lot_max;

	double needmargin = AccountFreeMarginCheck( Symbol(), OP_SELL, Lot );

	if ( needmargin < 5 || GetLastError() == 134 )
	{
		Print( "We have no money!!!" );
		return(-1);
	}

	if ( _OrderSend ( _Symbol, OP_SELL, Lot, _OpenPriceLevel, Slippage, _StopLossLevel, _TakeProfitLevel, "", _MagicNumber ) < 0 )
		Alert( strComment, ": Error opening SHORT position!" );
}

bool CloseAll( int type = -1 )
{
	bool result = true;
	int _GetLastError, _OrdersTotal = OrdersTotal();
	for ( int z = _OrdersTotal - 1; z >= 0; z -- )
	{
		if ( !OrderSelect( z, SELECT_BY_POS, MODE_TRADES ) )
		{
			_GetLastError = GetLastError();
			Print( "OrderSelect( ", z, ", SELECT_BY_POS, MODE_TRADES ) - Error #", _GetLastError );
			result = false;
			continue;
		}
		if ( OrderMagicNumber() != _MagicNumber || OrderSymbol() != _Symbol ) continue;
		if ( OrderType() > 1 ) continue;
		if ( type >= 0 && OrderType() != type ) continue;

		if ( _OrderClose( OrderTicket() ) < 0 ) result = false;
	}
	return(result);
}

Sample

Analysis

Market Information Used:

Series array that contains open time of each bar
Series array that contains open prices of each bar
Series array that contains the highest prices of each bar
Series array that contains close prices for each bar


Indicator Curves created:


Indicators Used:



Custom Indicators Used:

Order Management characteristics:
Checks for the total of open orders
It automatically opens orders when conditions are reached
It can change open orders parameters, due to possible stepping strategy
It Closes Orders by itself
Checks for the total of closed orders

Other Features:


It writes information to file
Uses files from the file system
It sends emails
It reads information from a file
It issuies visual alerts to the screen

2009-2010 - Desynced Tech