eSwapHistory3

//+------------------------------------------------------------------+
//|                                                 eSwapHistory.mq4 |
//|                                      Copyright © 2011, komposter |
//|                                          http://www.komposter.me |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2011, komposter"
#property link      "http://www.komposter.me"

/*
2011.04.20
	Ñîâåòíèê, ñîõðàíÿþùèé ðàç â ñóòêè èñòîðèþ ñâîïîâ ïî âñåì èíñòðóìåíòàì èç "Îáçîðà ðûíêà"
	Ôàéëû ñîõðàíÿþòñÿ â ïàïêå "MT4\experts\files\" è èìåþò íàçâàíèå "SwapHistory_ServerName.csv" (ServerName - èìÿ ñåðâåðà).
	Ôîðìàò ôàéëîâ: "Äàòà (ïî âðåìåíè ñåðâåðà);Èíñòðóìåíò;Ñâîï_áàé;Ñâîï_ñåëë;Ìèíèìàëüíûé_ñïðåä_ñ_ìîìåíòà_çàïóñêà"

2011.05.13
	×òî óìååò íîâàÿ âåðñèÿ:
	1. Âñå, ÷òî äåëàëà ñòàðàÿ (çàïèñûâàòü ôàéë ñî ñâîïàìè êàæäûé äåíü). Ñòàðóþ ìîæíî íå èñïîëüçîâàòü, íîâàÿ áóäåò îáíîâëÿòü òîò æå ôàéë.
	2. Íàõîäèòü ìèíèìàëüíûé ñïðåä ïî âñåì ïàðàì è çàïèñûâàòü åãî â òîò æå ôàéë ïîñëåäíåé êîëîíêîé.
	3. Ðàçäåëÿòü ñèìâîëû íà 3 ãðóïïû (ïî ðàçìåðó ïîëîæèòåëüíîãî ñâîïà), ñîðòèðîâàòü ñèìâîëû ïî óáûâàíèþ ïîëîæèòåëüíîãî ñâîïà.
	4. Ðèñîâàòü êðàñèâóþ òàáëèöó ñî âñåìè äàííûìè (ðàçìåð íàñòðàèâàåòñÿ ïåðåìåííîé SizeVariant: 1, 2 èëè 3).
	5. Îòêðûâàòü ãðàôèêè âñåõ ïàð ãðóïïû ïî íàæàòèþ êíîïêè.

	Êíîïêè ðàñïîëîæåíû ñâåðõó, íàçûâàþòñÿ [GROUP 1], [GROUP 2] è [GROUP 3]. Äëÿ àêòèâàöèè/äåàêòèâàöèè íóæíî êíîïêó âûäåëèòü, ïåðåìåñòèòü â ëþáîå ìåñòî, è îòïóñòèòü.
	Ïîñëå ïîïûòêè îòêðûòèÿ âñåõ ãðàôèêîâ (íå âàæíî - óäà÷íîé èëè íåóäà÷íîé) êíîïêà îòæèìàåòñÿ ñàìà.

	Ãðàôèê îòêðûâàåòñÿ ñ òàéì-ôðåéìîì ChartTimeFrame (ïåðåìåííàÿ), ñ øàáëîíîì "default.tpl" (ñòàíäàðòíûé).
//Ñäåëàë íîâóþ ïåðåìåííóþ: ShowGroup - Îòîáðàæàåìàÿ â òàáëèöå ãðóïïà èíñòðóìåíòîâ: 1 - òîëüêî 1-ÿ, 2 - òîëüêî 2-ÿ, 3 - òîëüêî 3-ÿ, 0 - âñå

	Îñòàëîñü ñäåëàòü:
	1. Âûáîð ïðîèçâîëüíîãî øàáëîíà äëÿ îòêðûâàåìûõ ãðàôèêîâ (ÍÅ ÓÂÅÐÅÍ, ×ÒÎ ÂÎÇÌÎÆÍÎ).
	2. Íàíåñåíèå íà íîâûå ãðàôèêè ëèíèé ñ èíôîðìàöèåé îá èçìåíåíèè ïðîöåíòíûõ ñòàâîê.


Íà ãðàôèêàõ òîðãîâûõ ïàð âåðòèêàëüíîé ëèíèåé (âûáîð ëèíèè, íàñòðîéêè öâåò, òîëùèíà) îòîáðàæàåì ïî äàòå, êîãäà áûëè ïðåäûäóùèå èçìåíåíèÿ(èçâåñòíûå) è êîãäà îæèäàþòñÿ èçìåíåíèÿ ïî ÏÐÎÖÅÍÒÍÛÌ ñòàâêàì.
ëó÷øå ýòè ñîáûòèÿ è èçìåíåíèÿ âáèâàòü ïî âàëþòàì âðó÷íóþ: âàëþòà-ñòàâêà-ïðåäûäóùèå èçìåíåíèÿ- äàòà ñëåäóþùåãî èçìåíåíèÿ- òàê áóäåò íàäåæíåé.
Cèãíàë íà ñëó÷àé èçìåíåíèÿ ðåéòèíãà ïàðû, ñ ó÷¸òîì çàïèñè â Ýêñåëü ýòîãî ñîáûòèÿ.
*/

extern string	Main							= "----------------Main-----------------";
extern uint		RefreshInterval_ms		= 1000;			// ×àñòîòà îáíîâëåíèÿ (ìñ)
extern string	ChartTimeFrame				= "D1";			// Ïåðèîä îòêðûâàåìûõ ãðàôèêîâ (M1, M5, M15, M30, H1, H4, D1, W1, MN)
extern int		ShowGroup					= 0;				// Îòîáðàæàåìàÿ â òàáëèöå ãðóïïà èíñòðóìåíòîâ: 1 - òîëüêî 1-ÿ, 2 - òîëüêî 2-ÿ, 3 - òîëüêî 3-ÿ, 0 - âñå

extern string	TableColors					= "----------------Colors---------------";
extern int		SizeVariant					= 2;				// Âàðèàíò ðàçìåðà øðèôòà (1-3)
extern color	Table_ColorMain			= LightGray;	// Îñíîâíîé öâåò
extern color	Table_ColorUP				= Green; 		// Öâåò ïðèáûëè
extern color	Table_ColorDN				= Maroon; 		// Öâåò óáûòêà

#include <WinUser32.mqh>

#import "user32.dll"
  int GetParent( int hWnd );
  int GetDlgItem( int hDlg, int nIDDlgItem );
#import

#define VK_RETURN 0x0D
#define VK_ESCAPE 0x1B
#define PAUSE 250

//+------------------------------------------------------------------+
//| vars
//+------------------------------------------------------------------+
bool		GlobalError			= false;

string	Table_Line			= "_________________________ ";
int		TableRows			= 5;		// Êîë-âî ñòðîê â òàáëèöå
double	Table_FontSize		= 9.0;	// Êåãëü øðèôòà
double	Table_RowHeight	= 16.0;	// Âûñîòà ñòðîêè (ïèêñåëåé)
double	Table_WidthCoeff	= 1.0;	// Êîýôôèöèåíò óâåëè÷åíèÿ ãîðèçîíòàëüíîãî îòñòóïà

int		SymbolsCount		= 0;
string	SymbolsName			[];
double	SymbolsData			[][3]; 	// { swap buy, swap sell, spread }

#define SHIFT_WINDOW_UP 5				// Âåðõíÿÿ ðàìêà îêíà â ïèêñåëÿõ
#define SHIFT_WINDOW_DN 20				// Íèæíÿÿ ðàìêà îêíà â ïèêñåëÿõ
#define SHIFT_BUTTONS 2					// Îòñòóï êíîïîê îò êðàÿ îêíà
#define SHIFT_TABLE 20					// Îòñòóï òàáëèöû îò êíîïîê

bool		AllowButton			[3] = { false, false, false };
string	ButtonsName			[3] = { "SH_Button1", "SH_Button2", "SH_Button3" };
string	ButtonsDesc			[3] = { "[GROUP 1]", "[GROUP 2]", "[GROUP 3]" };
int		ButtonsX				[3] = { 220, 155, 90 };
int		ButtonsY					 = SHIFT_BUTTONS;

//+------------------------------------------------------------------+
//| init
//+------------------------------------------------------------------+
void init()
{
	GlobalError = false;
	// áåç äëë ðàáîòàòü íå ïîëó÷èòñÿ
	if ( !IsDllsAllowed() )
	{
		Alert( "Âûçîâ DLL-ôóíêöèé çàïðåùåí, ýêñïåðò íå ìîæåò ðàáîòàòü!" );
		GlobalError = true;
		return;
	}

	switch ( SizeVariant )
	{
		case 3:
		{
			Table_FontSize		= 16.0;
			Table_RowHeight	= 24.0;
			Table_WidthCoeff	= 1.82;
			Table_Line			= "_________________________ ";
			break;
		}
		case 2:
		{
			Table_FontSize		= 11.0;
			Table_RowHeight	= 19.0;
			Table_WidthCoeff	= 1.1;
			Table_Line			= "_________________________ ";
			break;
		}
		default:
		{
			Table_FontSize		= 9.0;
			Table_RowHeight	= 16.0;
			Table_WidthCoeff	= 1.0;
			Table_Line			= "_________________________ ";
		}
	}

	SymbolsCount = 0;
	InitButtons	();
	start			();
}


//+------------------------------------------------------------------+
//| deinit
//+------------------------------------------------------------------+
void deinit()
{
	obj_delete( "SH_" );
}


//+------------------------------------------------------------------+
//| start
//+------------------------------------------------------------------+
void start()
{
	if ( GlobalError ) return;

	// Ðàáîòàåì â áåñêîíå÷íîì öèêëå ïîêà ïîëüçîâàòåëü íå óäàëèò èëè íå îñòàíîâèò ýêñïåðòà
	uint LastTickCouunt = 0;

	while ( !IsStopped() && IsExpertEnabled() )
	{
		CheckButtons();	// Ïðîâåðÿåì êíîïêè

		// Êàæäûå RefreshInterval_ms îáíîâëÿåì òàáëèöó
		if ( GetTickCount() - LastTickCouunt >= RefreshInterval_ms )
		{
			RefreshRates();
			InitSymbols	();
			RefreshData	();
			SortArrays	();
			ShowInfo		();
			OpenCharts	();
			WriteSwaps	();

			LastTickCouunt = GetTickCount();
		}

		Sleep(100);
	}
}


//+------------------------------------------------------------------+
//| InitButtons
//+------------------------------------------------------------------+
void InitButtons()
{
	for ( int b = 0; b < 3; b ++ )
	{
		if ( ObjectFind( ButtonsName[b] ) < 0 )
		{
			ObjectCreate( ButtonsName[b], OBJ_LABEL, 0, Time[0], Ask );
			ObjectSet	( ButtonsName[b], OBJPROP_CORNER, 1 );
			ObjectSet	( ButtonsName[b], OBJPROP_BACK, false );
			ObjectSet	( ButtonsName[b], OBJPROP_ANGLE, 0.0 );
		}

		if ( AllowButton[b] )
			ObjectSet( ButtonsName[b], OBJPROP_COLOR, Aqua );
		else
			ObjectSet( ButtonsName[b], OBJPROP_COLOR, Gray );

		ObjectSet	( ButtonsName[b], OBJPROP_XDISTANCE, ButtonsX[b] );
		ObjectSet	( ButtonsName[b], OBJPROP_YDISTANCE, ButtonsY );

		if ( AllowButton[b] )
			ObjectSetText	( ButtonsName[b], ButtonsDesc[b], 8, "Terminal bold", Aqua );
		else
			ObjectSetText	( ButtonsName[b], ButtonsDesc[b], 8, "Terminal bold", Gray );
	}
	GetLastError();
}


//+------------------------------------------------------------------+
//| CheckButtons
//+------------------------------------------------------------------+
void CheckButtons()
{
	bool need_redraw = false;

	for ( int b = 0; b < 3; b ++ )
	{
		if ( ObjectFind( ButtonsName[b] ) < 0 )
		{
			ObjectCreate	( ButtonsName[b], OBJ_LABEL, 0, Time[0], Ask );
			ObjectSet		( ButtonsName[b], OBJPROP_CORNER, 1 );
			ObjectSet		( ButtonsName[b], OBJPROP_BACK, false );
			ObjectSet		( ButtonsName[b], OBJPROP_ANGLE, 0.0 );
			if ( AllowButton[b] )
				ObjectSetText	( ButtonsName[b], ButtonsDesc[b], 8, "Terminal bold", Aqua );
			else
				ObjectSetText	( ButtonsName[b], ButtonsDesc[b], 8, "Terminal bold", Gray );
			need_redraw = true;
		}
		else
		{
			if ( ObjectGet( ButtonsName[b], OBJPROP_XDISTANCE ) != ButtonsX[b] || ObjectGet( ButtonsName[b], OBJPROP_YDISTANCE ) != ButtonsY )
			{
				if ( ObjectDelete( ButtonsName[b] ) && ObjectFind( ButtonsName[b] ) < 0 )
				{
					need_redraw = true;
					AllowButton[b] = !AllowButton[b];
				}
			}
		}

		if ( AllowButton[b] )
			ObjectSet( ButtonsName[b], OBJPROP_COLOR, Aqua );
		else
			ObjectSet( ButtonsName[b], OBJPROP_COLOR, Gray );

		ObjectSet	( ButtonsName[b], OBJPROP_XDISTANCE, ButtonsX[b] );
		ObjectSet	( ButtonsName[b], OBJPROP_YDISTANCE, ButtonsY );

	}
	if ( need_redraw ) WindowRedraw();
	GetLastError();
}


//+------------------------------------------------------------------+
//| InitSymbols
//+------------------------------------------------------------------+
void InitSymbols()
{
	if ( SymbolsCount > 0 ) return;

	// ïîëó÷àåì ñïèñîê ñèìâîëîâ, çàãðóæåííûõ â îêíî "Îáçîð ðûíêà"
	SymbolsCount = SymbolsList( SymbolsName, true );

	if ( SymbolsCount <= 0 )
	{
		Alert( "Íå óäàëîñü ïîëó÷èòü ñïèñîê èíñòðóìåíòîâ, çàãðóæåííûõ â îêíî \"Îáçîð ðûíêà\"!!!" );
		return;
	}

	if ( SymbolsCount >= TableRows-5 ) TableRows = SymbolsCount + 5;

	ArrayResize( SymbolsData, SymbolsCount );
	RefreshData( true );
}


//+------------------------------------------------------------------+
//| RefreshData
//+------------------------------------------------------------------+
void RefreshData( bool init = false )
{
	for ( int s = 0; s < SymbolsCount; s ++ )
	{
		if ( MarketInfo( SymbolsName[s], MODE_BID ) < 0.00001 ) continue;

		string g_name = "SwapHistory_" + AccountServer() + "_" + SymbolsName[s] + "_spread";

		if ( init )
		{
			SymbolsData[s][0] = MarketInfo( SymbolsName[s], MODE_SWAPLONG );
			SymbolsData[s][1] = MarketInfo( SymbolsName[s], MODE_SWAPSHORT );

			if ( GlobalVariableCheck( g_name ) )
			{
				SymbolsData[s][2] = NormalizeDouble( GlobalVariableGet( g_name ), 0 );
			}
			else
			{
				SymbolsData[s][2] = MarketInfo( SymbolsName[s], MODE_SPREAD );
				GlobalVariableSet( g_name, SymbolsData[s][2] );
			}
		}
		else
		{
			if ( MathAbs( SymbolsData[s][0] - MarketInfo( SymbolsName[s], MODE_SWAPLONG  ) ) > 0.0001 )
			{
				Print( SymbolsName[s], ": èçìåíèëñÿ swap áàé-ïîçèöèé: "	, DoubleToStr( SymbolsData[s][0], 4 ), " -> ", DoubleToStr( MarketInfo( SymbolsName[s], MODE_SWAPLONG  ), 4 ) );
				SymbolsData[s][0] = MarketInfo( SymbolsName[s], MODE_SWAPLONG );
			}
			if ( MathAbs( SymbolsData[s][1] - MarketInfo( SymbolsName[s], MODE_SWAPSHORT ) ) > 0.0001 )
			{
				Print( SymbolsName[s], ": èçìåíèëñÿ swap ñåëë-ïîçèöèé: "	, DoubleToStr( SymbolsData[s][1], 4 ), " -> ", DoubleToStr( MarketInfo( SymbolsName[s], MODE_SWAPSHORT ), 4 ) );
				SymbolsData[s][1] = MarketInfo( SymbolsName[s], MODE_SWAPSHORT );
			}
			if ( SymbolsData[s][2] - MarketInfo( SymbolsName[s], MODE_SPREAD ) > 0.0001 )
			{
				Print( SymbolsName[s], ": ñïðåä óìåíüøèëñÿ: ", DoubleToStr( SymbolsData[s][2], 0 ), " -> ", DoubleToStr( MarketInfo( SymbolsName[s], MODE_SPREAD ), 0 ) );
				SymbolsData[s][2] = MarketInfo( SymbolsName[s], MODE_SPREAD );
				GlobalVariableSet( g_name, SymbolsData[s][2] );
			}
		}
	}
}


//+------------------------------------------------------------------+
//| SortArrays
//+------------------------------------------------------------------+
void SortArrays()
{
	string	tmpSymbolsName;
	double	tmpSymbolsData[3];

	for ( int s1 = 0; s1 < SymbolsCount; s1 ++ )
	{
		for ( int s2 = s1+1; s2 < SymbolsCount; s2 ++ )
		{
			if ( MathMax( SymbolsData[s1][0], SymbolsData[s1][1] ) < MathMax( SymbolsData[s2][0], SymbolsData[s2][1] ) )
			{
				tmpSymbolsName					= SymbolsName	[s1];
				tmpSymbolsData		[0]		= SymbolsData	[s1][0];
				tmpSymbolsData		[1]		= SymbolsData	[s1][1];
				tmpSymbolsData		[2]		= SymbolsData	[s1][2];

				SymbolsName			[s1]		= SymbolsName	[s2];
				SymbolsData			[s1][0]	= SymbolsData	[s2][0];
				SymbolsData			[s1][1]	= SymbolsData	[s2][1];
				SymbolsData			[s1][2]	= SymbolsData	[s2][2];

				SymbolsName			[s2]		= tmpSymbolsName;
				SymbolsData			[s2][0]	= tmpSymbolsData[0];
				SymbolsData			[s2][1]	= tmpSymbolsData[1];
				SymbolsData			[s2][2]	= tmpSymbolsData[2];
			}
		}
	}
}


//+------------------------------------------------------------------+
//| ShowInfo
//+------------------------------------------------------------------+
void ShowInfo()
{
	int c = -1;

	c++; SetTableVal( 0, c, Table_Line, -1, 1 );
	c++; SetTableVal( 0, c, "Spread" );
	c++; SetTableVal( 0, c, "" );
	c++; SetTableVal( 0, c, "Swap S" );
	c++; SetTableVal( 0, c, "Swap B" );
	c++; SetTableVal( 0, c, "" );
	c++; SetTableVal( 0, c, "" );


	int drawed_group = 1, use_shift = 0;
	int cur_row = 1;
	if ( ShowGroup != 0 ) drawed_group = ShowGroup;

	for ( int s = 0; s < SymbolsCount; s ++ )
	{
		int current_group = 0;
		if ( MathMax( SymbolsData[s][0], SymbolsData[s][1] ) >= 3.0 )
		{
			current_group = 1;
		}
		else if ( MathMax( SymbolsData[s][0], SymbolsData[s][1] ) >= 0.0 )
		{
			current_group = 2;
		}
		else
		{
			current_group = 3;
		}

		if ( ShowGroup != 0 )
		{
			if ( ShowGroup != current_group ) continue;
		}

		if ( current_group != drawed_group )
		{
			drawed_group = current_group;
			use_shift += -Table_RowHeight+4;

			c = -1;
			c++; SetTableVal( cur_row, c, Table_Line, -1, use_shift );
			c++; SetTableVal( cur_row, c, "" );
			c++; SetTableVal( cur_row, c, "" );
			c++; SetTableVal( cur_row, c, "" );
			c++; SetTableVal( cur_row, c, "" );
			c++; SetTableVal( cur_row, c, "" );
			c++; SetTableVal( cur_row, c, "" );
		}
		else
		{
			c = -1;
			c++; SetTableVal( cur_row, c, "|", -1, use_shift );
			c++; SetTableVal( cur_row, c, DoubleToStr( SymbolsData[s][2], 0 ), -1, use_shift );
			c++; SetTableVal( cur_row, c, "|", -1, use_shift );
			c++; SetTableVal( cur_row, c, strPlus( SymbolsData[s][1], 2 ), -1, use_shift );
			c++; SetTableVal( cur_row, c, strPlus( SymbolsData[s][0], 2 ), -1, use_shift );
			c++; SetTableVal( cur_row, c, "|", -1, use_shift );
			c++; SetTableVal( cur_row, c, SymbolsName[s], -1, use_shift );
		}

		cur_row ++;
	}

	c = -1;
	c++; SetTableVal( cur_row, c, Table_Line, -1, use_shift-Table_RowHeight+3 );
	c++; SetTableVal( cur_row, c, "" );
	c++; SetTableVal( cur_row, c, "" );
	c++; SetTableVal( cur_row, c, "" );
	c++; SetTableVal( cur_row, c, "" );
	c++; SetTableVal( cur_row, c, "" );
	c++; SetTableVal( cur_row, c, "" );

	cur_row ++;

	while ( cur_row < TableRows )
	{
		for ( c = 0; c < 7; c ++ ) SetTableVal( cur_row, c, "" );

		cur_row ++;
	}

	WindowRedraw();
}

//+------------------------------------------------------------------+
//| Îòðèñîâêà ÿ÷åéêè òàáëèöû
//+------------------------------------------------------------------+
void SetTableVal( int row, int col, string text, color custom_color = CLR_NONE, int custom_y_shift = 0 )
{
	string name = StringConcatenate( "SH_T_", str00( row ), "_", col );

	double val = StrToDouble( text );
	if ( val > 0.000001 )
	{
		custom_color = Table_ColorUP;
	}
	else if ( val < -0.000001 )
	{
		custom_color = Table_ColorDN;
	}
	if ( col == 1 )
	{
		if ( row != 0 ) text = text + " ";
		custom_color = Table_ColorMain;
	}

	int columns_width[] = { 15, 45, 15, 57, 55, 13, 70 };

	int x = 5;
	for ( int c = 0; c < col; c ++ ) x += columns_width[c];
	x = 1.0 * x * Table_WidthCoeff;

	int y = SHIFT_BUTTONS + SHIFT_TABLE + row*Table_RowHeight + custom_y_shift;

	color use_color = Table_ColorMain;
	if ( custom_color != CLR_NONE ) use_color = custom_color;

	if ( ObjectFind( name ) < 0 )
	{
		ObjectCreate( name, OBJ_LABEL, 0, Time[0], Ask );
		ObjectSet	( name, OBJPROP_CORNER, 1 );
		ObjectSet	( name, OBJPROP_BACK, false );
		ObjectSet	( name, OBJPROP_ANGLE, 0.0 );
	}

	ObjectSet	( name, OBJPROP_COLOR, use_color );
	ObjectSet	( name, OBJPROP_XDISTANCE, x );
	ObjectSet	( name, OBJPROP_YDISTANCE, y );

	ObjectSetText( name, text, Table_FontSize, "Courier new", use_color );
	GetLastError();
}

string strPlus( double value, int digits )
{
	if ( value < -0.0000001 )
		return( "-" + DoubleToStr( -value, digits ) );
	else if ( value > 0.0000001 )
		return( "+" + DoubleToStr( value, digits ) );
	else
		return( DoubleToStr( value, digits ) );
}

string str00( string str )
{
	if ( StringLen( str ) < 2 ) return( StringConcatenate( "0", str ) );
	return(str);
}

void obj_delete( string prefix )
{
	int obj_total = ObjectsTotal(); string name;
	for ( int i = obj_total-1; i >= 0; i -- )
	{
		name = ObjectName(i);
		if ( StringFind( name, prefix ) == 0 ) ObjectDelete( name );
	}
}

//+------------------------------------------------------------------+
//| OpenCharts
//+------------------------------------------------------------------+
void OpenCharts()
{
	for ( int s = 0; s < SymbolsCount; s ++ )
	{
		if ( MathMax( SymbolsData[s][0], SymbolsData[s][1] ) >= 3.0 )
		{
			if ( AllowButton[0] ) OpenChart( SymbolsName[s] );
		}
		else if ( MathMax( SymbolsData[s][0], SymbolsData[s][1] ) >= 0.0 )
		{
			if ( AllowButton[1] ) OpenChart( SymbolsName[s] );
		}
		else
		{
			if ( AllowButton[2] ) OpenChart( SymbolsName[s] );
		}
	}
	for ( int b = 0; b < 3; b ++ )
	{
		if ( AllowButton[b] )
		{
			if ( ObjectDelete( ButtonsName[b] ) ) AllowButton[b] = false;
		}
	}
}


//+------------------------------------------------------------------+
//| WriteSwaps
//+------------------------------------------------------------------+
void WriteSwaps()
{
	//----
	string	gl_name		= "SwapHistory_" + AccountServer();
	datetime	last_write	= 0;

	if ( GlobalVariableCheck( gl_name ) )
	{
		last_write = GlobalVariableGet( gl_name );
	}

	datetime	cur_date = StrToTime( TimeToStr( TimeCurrent(), TIME_DATE ) );
	if ( cur_date > last_write )
	{
		if ( WriteFile() )
		{
			GlobalVariableSet( gl_name, cur_date );
		}
	}
}


//+------------------------------------------------------------------+
//| WriteFile
//+------------------------------------------------------------------+
bool WriteFile()
{
	string file_name = StringConcatenate( "SwapHistory_", AccountServer(), ".csv" );
	int handle  = FileOpen( file_name, FILE_CSV | FILE_READ | FILE_WRITE ), _GetLastError = 0;
	if ( handle < 0 )
	{
		_GetLastError = GetLastError();
		Print( "FileOpen( \"", file_name, "\" ) - Error #", _GetLastError );
		return(false);
	}

	if ( !FileSeek( handle, 0, SEEK_END ) )
	{
		_GetLastError = GetLastError();
		Print( "FileSeek( ", handle, " ) - Error #", _GetLastError );
		FileClose( handle );
		return(false);
	}

	for ( int s = 0; s < SymbolsCount; s ++ )
	{
		FileWrite( handle, TimeToStr( TimeCurrent(), TIME_DATE ), SymbolsName[s], SymbolsData[s][0], SymbolsData[s][1], SymbolsData[s][2] );
	}

	FileClose( handle );

	return(true);
}


//+------------------------------------------------------------------+
//| OpenChart
//+------------------------------------------------------------------+
void OpenChart( string symbol )
{
	string	g_name	= "SwapHistory_ChartHandle_" + symbol;
	int		handle	= -1;

	if ( GlobalVariableCheck( g_name ) )
	{
		handle = NormalizeDouble( GlobalVariableGet( g_name ), 0 );
		if ( isChartOpened( handle ) )
		{
			return;
		}
		else
		{
			Print( "Ãðàôèê \"", symbol, "\" áûë çàêðûò, îòêðûâàåì íîâûé..." );
			GlobalVariableDel( g_name );
			handle = -1;
		}
	}

	// Ñîõðàíÿåì îòêðûòûå ãðàôèêè, ÷òîá ïîòîì íàéòè íîâûé
	SaveOpenedCharts();

	// Îòêðûâàåì ãðàôèê
	handle = ChartOpen( symbol, intPeriod( ChartTimeFrame ) );
/*
	int hwnd_parent = Parent();
	PostMessageA(hwnd_parent, WM_COMMAND, 33160, 0); // îòêðûëè ãðàôèê
	Sleep(PAUSE*3);

	// Íàõîäèì åãî
	handle = FindNewChart();

	if ( handle < 0 )
	{
		Print( "Îøèáêà ïðè îòêðûòèè íîâîãî ãðàôèêà \"", symbol, "\"!!!" );
		return;
	}

	// Ñîõðàíÿåì õåíäë íà áóäóùåå
	GlobalVariableSet( g_name, handle );

	// Àêòèâèðóåì ñòðîêó áûñòðîé íàâèãàöèè
	PostMessageA(handle, WM_KEYDOWN, VK_RETURN, 0);
	Sleep(PAUSE);
	PostMessageA(GetDlgItem(handle, 0x45A), WM_KEYDOWN, VK_ESCAPE, 0);
	Sleep(PAUSE);

	int hwnd_base = WindowHandle(Symbol(), Period());
	PostMessageA(hwnd_base, WM_KEYDOWN, VK_RETURN, 0);
	Sleep(PAUSE);
	PostMessageA(GetDlgItem(hwnd_base, 0x45A), WM_KEYDOWN, VK_ESCAPE, 0);

	// Ïåðåêëþ÷àåì ñèìâîë è ÒÔ
	ActivateString( handle, symbol + "," + ChartTimeFrame );
	Sleep(PAUSE);
*/
	return;
}

bool isChartOpened( int handle )
{
	int hwnd_base = WindowHandle(Symbol(), Period());

	int hwnd = NextChart(hwnd_base);
	while ( hwnd != hwnd_base )
	{
 		if ( hwnd == handle ) return(true);

 		hwnd = NextChart(hwnd);
	}
	return(false);
}

int		OldChartsCount	= 0;
int		OldHandles		[];

void SaveOpenedCharts()
{
	int hwnd_base = WindowHandle(Symbol(), Period());

	int hwnd = NextChart(hwnd_base);
	while ( hwnd != hwnd_base )
	{
 		OldChartsCount ++;
 		ArrayResize( OldHandles, OldChartsCount );
 		OldHandles[OldChartsCount-1] = hwnd;

 		hwnd = NextChart(hwnd);
	}
/*
	string sComment = "OldCharts (" + OldChartsCount + "):\n";
	for ( int c = 0; c < OldChartsCount; c ++ )
	{
		sComment = sComment + OldHandles[c] + "\n";
	}
	Comment( sComment );
*/
}

int FindNewChart()
{
	int hwnd_base = WindowHandle(Symbol(), Period());

	int hwnd = NextChart(hwnd_base);
	while ( hwnd != hwnd_base )
	{
		// íîâûé ãðàôèê
		if ( !isChartOld( hwnd ) )
		{
			return( hwnd );
		}
 		hwnd = NextChart(hwnd);
	}
	return(-1);
}

bool isChartOld( int handle )
{
	for ( int c = 0; c < OldChartsCount; c ++ )
	{
		if ( handle == OldHandles[c] ) return(true);
	}
	return(false);
}


//+------------------------------------------------------------------+
//|                                                   SymbolsLib.mq4 |
//|                                          Copyright © 2009, Ilnur |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Ôóíêöèÿ âîçâðàùàåò ñïèñîê äîñòóïíûõ ñèìâîëîâ                     |
//+------------------------------------------------------------------+
int SymbolsList(string &Symbols[], bool Selected)
{
   string SymbolsFileName;
   int Offset, SymbolsNumber;

   if(Selected) SymbolsFileName = "symbols.sel";
   else         SymbolsFileName = "symbols.raw";

// Îòêðûâàåì ôàéë ñ îïèñàíèåì ñèìâîëîâ

   int hFile = FileOpenHistory(SymbolsFileName, FILE_BIN|FILE_READ);
   if(hFile < 0) return(-1);

// Îïðåäåëÿåì êîëè÷åñòâî ñèìâîëîâ, çàðåãèñòðèðîâàííûõ â ôàéëå

   if(Selected) { SymbolsNumber = (FileSize(hFile) - 4) / 128; Offset = 116;  }
   else         { SymbolsNumber = FileSize(hFile) / 1936;      Offset = 1924; }

   ArrayResize(Symbols, SymbolsNumber);

// Ñ÷èòûâàåì ñèìâîëû èç ôàéëà

   if(Selected) FileSeek(hFile, 4, SEEK_SET);
   
   for(int i = 0; i < SymbolsNumber; i++)
   {
      Symbols[i] = FileReadString(hFile, 12);
      FileSeek(hFile, Offset, SEEK_CUR);
   }
   
   FileClose(hFile);
   
// Âîçâðàùàåì êîëè÷åñòâî ñ÷èòàííûõ èíñòðóìåíòîâ

   return(SymbolsNumber);
}


//+------------------------------------------------------------------+
//| Big thanks to getch (http://forum.mql4.com/ru/13304/page3#84476)
//| Big thanks to getch (http://forum.mql4.com/ru/11344#67611)
//+------------------------------------------------------------------+
// Âîçâðàùàåò õýíäë îñíîâíîãî îêíà òåðìèíàëà
int Parent()
{
	int hwnd = WindowHandle( Symbol(), Period() );
	int hwnd_parent = 0;

	while (!IsStopped())
	{
		hwnd = GetParent(hwnd);

		if (hwnd == 0)
		break;

		hwnd_parent = hwnd;
	}

	return(hwnd_parent);
}

// Âîçâðàùàåò õýíäë ñëåäóþùåãî ÷àðòà çà hwnd-÷àðòîì
int NextChart( int hwnd ) 
{
  int handle;
  
  hwnd = GetParent(hwnd);
  handle = GetWindow(hwnd, GW_HWNDNEXT);
  
  if (handle == 0)
    handle = GetWindow(hwnd, GW_HWNDFIRST);
    
  hwnd = GetDlgItem(handle, 0xE900); 
  
  return(hwnd);
}
/*
//Àêòèâèðóåò ñòðîêó Str â ñòðîêå áûñòðîé íàâèãàöèè hwnd-÷àðòà
// NB: Ïðè èçìåíåíèè ñèìâîëà èëè òàéìôðýéìà
// òðåáóåòñÿ îòñóòñòâèå çàïóùåííîãî ñêðèïòà íà hwnd-÷àðòå!
void ActivateString( int hwnd, string Str )
{
  hwnd = GetDlgItem(hwnd, 0x45A);
  SetWindowTextA(hwnd, Str);
  PostMessageA(hwnd, WM_KEYDOWN, VK_RETURN, 0);
  
  return;
}
*/

//+---------------------------------------------------------
int intPeriod( string period )
//+---------------------------------------------------------
// âîçâðàùàåò Period â âèäå öåëîãî ÷èñëà
//+---------------------------------------------------------
{
	if ( period == "MN1"			)	{ return(PERIOD_MN1	); }
	if ( period == "W1"			)	{ return(PERIOD_W1	); }
	if ( period == "D1"			)	{ return(PERIOD_D1	); }
	if ( period == "H4"			)	{ return(PERIOD_H4	); }
	if ( period == "H1"			)	{ return(PERIOD_H1	); }
	if ( period == "M30"			)	{ return(PERIOD_M30	); }
	if ( period == "M15"			)	{ return(PERIOD_M15	); }
	if ( period == "M5"			)	{ return(PERIOD_M5	); }
	if ( period == "M1"			)	{ return(PERIOD_M1	); }
	return(0);
}