Orders Execution
0
Views
0
Downloads
0
Favorites
e-PSIhPROC
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| e-PSI@PROC.mq4 |
//| Copyright © 2011, TarasBY & Evgeniy Trofimov |
//| taras_bulba@tut.by |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
#property copyright "Copyright © 2010-11, TarasBY & Evgeniy Trofimov"
#property link "taras_bulba@tut.by"
/* * Ïîñëå óñòàíîâêè ýêñïåðòà íà ãðàôèê ìåíÿòü òàéìôðåéì íå ðåêîìåíäóåòñÿ!
* Ðåêîìåíäóåìûå Òàéìôðåéìû H4 - D1 !!!
* Äîïóñêàåòñÿ äîáàâëÿòü â êîä ïðî÷èå òîðãîâûå ñèñòåìû, ñïîñîáíûå ñòàáèëüíî
* ðàáîòàòü íà òàêîì æå òàéìôðåéìå, ÷òî è îñòàëüíûå òîðãîâûå ñòðàòåãèè.
* ÂÍÈÌÀÍÈÅ: Ïàðàìåòðû óêàçàíû äëÿ 4-¸õ çíàêîâ!*/
//IIIIIIIIIIIIIIIIIII==================CONSTANS=================IIIIIIIIIIIIIIIIIIIIII+
#define MAX_TC 8 // ìàêñèìàëüíîå êîëè÷åñòâî èñïîëüçóåìûõ ñòðàòåãèé
#define Trend_UP 0 // Êîíñòàíòà äëÿ ðàáîòû TraillingProfit
#define Trend_DW 1 // Êîíñòàíòà äëÿ ðàáîòû TraillingProfit
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| ***** Ïàðàìåòðû ñîâåòíèêà ***** |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
extern string SETUP_Expert = "==================== SETUP EXPERT ===================";
extern string file = "virtual.csv"; // ôàéë âèðòóàëüíîé òîðãîâëè
extern int MinRating = 50; // Ìèíèìàëüíûé ðåéòèíã â ïðîöåíòàõ äëÿ îòêðûòèÿ ðåàëüíîé ïîçèöèè
extern int Base.Magic = 878; // Áàçîâûé ðàáî÷èé ìàãèê äëÿ òîðãîâûõ ñèñòåì
extern int NewBarInPeriod = 1; // <= 0 - ðàáîòàåì íà íà÷àëå ïåðèîäà íîâîãî áàðà, -1 - ðàáîòàåì íà êàæäîì òèêå
extern int Variant_TradePrice = 1; // Âàðèàíò öåí, ñ êîòîðûìè áóäåò ðàáîòàòü ñîâåòíèê
extern int MAX_OrdersOnTC = 1; // Ìàêñèìàëüíîå ÷èñëî îòêðûòûõ îðäåðîâ íà îäíó Òîðãîâóþ Ñèñòåìó
extern int Period.New.Send = 1440; // Ïåðèîäè÷íîñòü ïðîâåðêè íà îòêðûòèå ñëåäóþùåãî îðäåðà îäíîé ñòðàòåãèåé, åñëè MAX_OrdersOnTC > 1
extern int Period.Indicators = 1440; // Ðàáî÷èé ïåðèîä äëÿ èíäèêàòîðîâ
extern int STOP.Period = 70; // Ïåðèîä äëÿ ðàñ÷¸òà Ñòîïîâ ïî ÌÀ
extern string Setup_TraillingMA = "---- Trailling By MA ----";
extern int MAMode = 1; // 0 = SMA, 1 = EMA, 2 = SSMA, 3 = LWMA
extern int XFactor = 84;
extern int TrailPeriod = 83;
extern string SETUP_TP = "================= Trailling Profit ==================";
extern bool TrailProfit_ON = TRUE; // Âêëþ÷åíèå òðåéëèíãà îáùåãî Ïðîôèòà
extern bool TrailProfitByMA = TRUE; // Òðåéëèíã îáùåãî Ïðîôèòà ïî MA
extern int TrailProfitPeriod = 50; // Ïåðèîä MA äëÿ òðåéëèíãà ïî MA
extern double TrailProfit_Start = 300; // Âåëè÷èíà ïðîôèòà ïðè êîòîðîì íà÷èíàåòñÿ ïåðåìåùåíèå óðîâíÿ çàêðûòèÿ
extern double TrailProfit_Level = 200; // Âåëè÷èíà îáðàòíîãî äâèæåíèÿ ïðîôèòà, ïðè êîòîðîì âûïîëíÿåòñÿ çàêðûòèå
extern string SETUP_TC_1 = "================= TRADE SYSTEM ¹ 1 ==================";
extern int T1.Enabled = 1; // 1 - âêë.; 0 - âûêë.
extern double T1.lot = 0.10; // Âåëè÷èíà ôèêñèðîâàííîãî ëîòà
extern int T1.Var.STOP = 1; // Âàðèàíò Ñòîïîâ: 0 - classic; 1 - By MA
extern int T1.SL = 300; // Ñòîï ëîññ
extern int T1.TP = 300; // Òýéê ïðîôèò
extern int T1.Var.TS = 1; // Âàðèàíò Òðåéëèíã ñòîïà: 0 - classic; 1 - By MA
extern int T1.TS = 100; // Òðåéëèíã ñòîï
extern bool T1.OnlyBU = False; // TraillinStop òîëüêî â ÁÓ
extern int T1.Fast = 10; // Ïåðèîä áûñòðîé ÌÀ
extern int T1.Slow = 100; // Ïåðèîä ìåäëåííîé ÌÀ
extern int T1.PeriodRating = 5; // Ïåðèîä óñðåäíåíèÿ ðåéòèíãà
extern string SETUP_TC_2 = "================= TRADE SYSTEM ¹ 2 ==================";
extern int T2.Enabled = 1; // 1 - âêë.; 0 - âûêë.
extern double T2.lot = 0.10; // Âåëè÷èíà ôèêñèðîâàííîãî ëîòà
extern int T2.Var.STOP = 1; // Âàðèàíò Ñòîïîâ: 0 - classic; 1 - By MA
extern int T2.SL = 500; // Ñòîï ëîññ
extern int T2.TP = 500; // Òýéê ïðîôèò
extern int T2.Var.TS = 1; // Âàðèàíò Òðåéëèíã ñòîïà: 0 - classic; 1 - By MA
extern int T2.TS = 150; // Òðåéëèíã ñòîï
extern bool T2.OnlyBU = False; // TraillinStop òîëüêî â ÁÓ
extern int T2.PeriodCCI = 30;
extern int T2.LevelCCI = 200;
extern int T2.PeriodRating = 3; // Ïåðèîä óñðåäíåíèÿ ðåéòèíãà
extern string SETUP_TC_3 = "================= TRADE SYSTEM ¹ 3 ==================";
extern int T3.Enabled = 1; // 1 - âêë.; 0 - âûêë.
extern double T3.lot = 0.10; // Âåëè÷èíà ôèêñèðîâàííîãî ëîòà
extern int T3.Var.STOP = 1; // Âàðèàíò Ñòîïîâ: 0 - classic; 1 - By MA
extern int T3.SL = 300; // Ñòîï ëîññ
extern int T3.TP = 300; // Òýéê ïðîôèò
extern int T3.Var.TS = 1; // Âàðèàíò Òðåéëèíã ñòîïà: 0 - classic; 1 - By MA
extern int T3.TS = 80; // Òðåéëèíã ñòîï
extern bool T3.OnlyBU = False; // TraillinStop òîëüêî â ÁÓ
extern int T3.Fast = 30; // Ïåðèîä áûñòðîé ÌÀ
extern int T3.Slow = 200; // Ïåðèîä ìåäëåííîé ÌÀ
extern int T3.PeriodRating = 5; // Ïåðèîä óñðåäíåíèÿ ðåéòèíãà
extern string SETUP_TC_4 = "================= TRADE SYSTEM ¹ 4 ==================";
extern int T4.Enabled = 1; // 1 - âêë.; 0 - âûêë.
extern double T4.lot = 0.10; // Âåëè÷èíà ôèêñèðîâàííîãî ëîòà
extern int T4.Var.STOP = 1; // Âàðèàíò Ñòîïîâ: 0 - classic; 1 - By MA
extern double T4.SL = 500; // Ñòîï ëîññ
extern int T4.TP = 500; // Òýéê ïðîôèò
extern int T4.Var.TS = 1; // Âàðèàíò Òðåéëèíã ñòîïà: 0 - classic; 1 - By MA
extern double T4.TS = 150; // Òðåéëèíã ñòîï
extern bool T4.OnlyBU = False; // TraillinStop òîëüêî â ÁÓ
extern double T4.LimitMACD = 0.002;
extern int T4.PeriodRating = 5; // Ïåðèîä óñðåäíåíèÿ ðåéòèíãà
extern string SETUP_TC_5 = "================= TRADE SYSTEM ¹ 5 ==================";
extern int T5.Enabled = 1; // 1 - âêë.; 0 - âûêë.
extern double T5.lot = 0.10; // Âåëè÷èíà ôèêñèðîâàííîãî ëîòà
extern int T5.Var.STOP = 1; // Âàðèàíò Ñòîïîâ: 0 - classic; 1 - By MA
extern int T5.SL = 500; // Ñòîï ëîññ
extern int T5.TP = 500; // Òýéê ïðîôèò
extern int T5.Var.TS = 1; // Âàðèàíò Òðåéëèíã ñòîïà: 0 - classic; 1 - By MA
extern int T5.TS = 300; // Òðåéëèíã ñòîï
extern bool T5.OnlyBU = True; // TraillinStop òîëüêî â ÁÓ
extern int T5.PeriodCCI = 90;
extern int T5.LevelCCI = 100;
extern int T5.TralingCCI = 10;
extern int T5.PeriodRating = 5; // Ïåðèîä óñðåäíåíèÿ ðåéòèíãà
extern string SETUP_TC_6 = "================= TRADE SYSTEM ¹ 6 ==================";
extern int T6.Enabled = 1; // 1 - âêë.; 0 - âûêë.
extern int VarPerceptron = 1; // 0 - Perceptron íà Close\Open; 1 - íà iStochastic; 2 - íà CCI
extern double T6.lot = 0.10; // Âåëè÷èíà ôèêñèðîâàííîãî ëîòà
extern int T6.Var.STOP = 1; // Âàðèàíò Ñòîïîâ: 0 - classic; 1 - By MA
extern int T6.SL = 500; // Ñòîï ëîññ
extern int T6.TP = 500; // Òýéê ïðîôèò
extern int T6.Var.TS = 1; // Âàðèàíò Òðåéëèíã ñòîïà: 0 - classic; 1 - By MA
extern int T6.TS = 150; // Òðåéëèíã ñòîï
extern bool T6.OnlyBU = False; // TraillinStop òîëüêî â ÁÓ
extern int x1 = 120; // 0 - 200: D = 1
extern int x2 = 172; // 0 - 200: D = 1
extern int x3 = 39; // 0 - 200: D = 1
extern int x4 = 172; // 0 - 200: D = 1
extern double Per_BUY = 20.0;
extern double Per_Close_BUY = -5.0;
extern double Per_SELL = -20.0;
extern double Per_Close_SELL = 5.0;
extern string PerceptronBars = "1,3,5,10,15";
extern string Setup_TC_6_Stoch = "---- Íàñòðîéêè iStochastic ----";
extern int T6.K_Period = 92;
extern int T6.D_Period = 5;
extern int T6.Slowing = 11;
extern string Setup_TC_6_CCI = "-------- Íàñòðîéêè iCCI -------";
extern int T6.Period_CCI = 14;
extern int T6.Price_CCI = 0;
extern int T6.PeriodRating = 5; // Ïåðèîä óñðåäíåíèÿ ðåéòèíãà
extern string SETUP_TC_7 = "================= TRADE SYSTEM ¹ 7 ==================";
extern int T7.Enabled = 1; // 1 - âêë.; 0 - âûêë.
extern double T7.lot = 0.10; // Âåëè÷èíà ôèêñèðîâàííîãî ëîòà
extern int T7.Var.STOP = 1; // Âàðèàíò Ñòîïîâ: 0 - classic; 1 - By MA
extern int T7.SL = 500; // Ñòîï ëîññ
extern int T7.TP = 500; // Òýéê ïðîôèò
extern int T7.Var.TS = 1; // Âàðèàíò Òðåéëèíã ñòîïà: 0 - classic; 1 - By MA
extern int T7.TS = 150; // Òðåéëèíã ñòîï
extern bool T7.OnlyBU = False; // TraillinStop òîëüêî â ÁÓ
extern int Warp = -42; // -100 - 100: D = 1
extern double Deviation = 0.14; // 0 - 2: D = 0.01
extern int Amplitude = 8; // 0 - 200: D = 1
extern double Distortion = 0.52; // -1 - 1: D = 0.01
extern double Dir_BUY = 1.0;
extern double Dir_Close_BUY = -0.8;
extern double Dir_SELL = -1.0;
extern double Dir_Close_SELL = 0.8;
extern string DirectionBars = "1,3,5,10";
extern int T7.PeriodRating = 5; // Ïåðèîä óñðåäíåíèÿ ðåéòèíãà
extern string SETUP_TC_8 = "================= TRADE SYSTEM ¹ 8 ==================";
extern int T8.Enabled = 1; // 1 - âêë.; 0 - âûêë.
extern double T8.lot = 0.10; // Âåëè÷èíà ôèêñèðîâàííîãî ëîòà
extern int T8.Var.STOP = 1; // Âàðèàíò Ñòîïîâ: 0 - classic; 1 - By MA
extern int T8.SL = 300; // Ñòîï ëîññ
extern int T8.TP = 300; // Òýéê ïðîôèò
extern int T8.Var.TS = 1; // Âàðèàíò Òðåéëèíã ñòîïà: 0 - classic; 1 - By MA
extern int T8.TS = 120; // Òðåéëèíã ñòîï
extern bool T8.OnlyBU = False; // TraillinStop òîëüêî â ÁÓ
extern int T8.MA = 40; // Ïåðèîä áûñòðîé ÌÀ
extern int T8.PeriodRating = 5; // Ïåðèîä óñðåäíåíèÿ ðåéòèíãà
//IIIIIIIIIIIIIIIIIII======Ãëîáàëüíûå ïåðåìåííûå ñîâåòíèêà======IIIIIIIIIIIIIIIIIIIIII+
double gda_Price[2], // ìàññèâ öåí èíñòðóìåíòà
// gda_Price[0] - Bid
// gda_Price[1] - Ask
gda_TC.SL[MAX_TC],
gda_TC.TP[MAX_TC],
gda_TC.TS[MAX_TC],
gda_TC.lot[MAX_TC],
gd_Point, /*gd_MaxLot, gd_MinLot, gd_StepLot*/
gd_Profit,
gd_XFactor;
int gia_TC.Magic[MAX_TC],
gia_TC.Enable[MAX_TC],
gia_TC.PeriodRating[MAX_TC],
gia_TC.Var.TS[MAX_TC],
gia_TC.Var.STOP[MAX_TC],
gia_TC.Orders[MAX_TC], // ìàññèâ ñ÷¸ò÷èêîâ îòêðûòûõ îðäåðîâ ïî êàæäîé ñòàðàòåãèè
gia_PerceptronBars[5],
gia_DirectionBars[4],
gi_MyOrders, // ñ÷¸ò÷èê îòêðûòûõ îðäåðîâ ïî âñåì ñòðàòåãèÿì
gi_flag_TP, // ôëàã Traiiling Profit
gi_flag_NullStop, // ôëàã îáíóëåíèÿ ñòîïîâ
gi_LastTrend = -1, // ïðåäûäóùåå ïîêàçàíèå òðåíäà
gi_Decimal = 1, gi_Digits, gi_dig = 0;
string gs_Symbol, gs_NameGV, gs_trade, gs_TradeCom[3], gs_VirtCom[3];
bool gba_TC.OnlyBU[MAX_TC];
datetime NewBar;
//IIIIIIIIIIIIIIIIIII==========Ïîäêëþ÷åííûå áèáëèîòåêè==========IIIIIIIIIIIIIIIIIIIIII+
#include <VirtualTrendForPROC.mqh> // áèáëèîòåêà âèðòóàëüíûõ ñäåëîê
#include <RealTrendForPROC.mqh> // áèáëèîòåêà òîðãîâûõ îïðåàöèé
#include <b-PSI@ICManagerForPROC.mqh> // áèáëèîòåêà óïðàâëåíèÿ èíâåñò-êàïèòàëîì
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Custom expert initialization function |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int init()
{
//----
gs_NameGV = "PROC";
//---- Ôîðìèðóåì ïðåôèêñ GV-ïåðåìåííûõ
if (IsTesting())
{gs_NameGV = gs_NameGV + "_t";}
if (IsDemo())
{gs_NameGV = gs_NameGV + "_d";}
gs_Symbol = Symbol();
gd_MaxLot = MarketInfo (gs_Symbol, MODE_MAXLOT);
gd_MinLot = MarketInfo (gs_Symbol, MODE_MINLOT);
gd_StepLot = MarketInfo (gs_Symbol, MODE_LOTSTEP);
gd_Point = MarketInfo (gs_Symbol, MODE_POINT);
gi_Digits = MarketInfo (gs_Symbol, MODE_DIGITS);
if (PrintCom) Print ("minLot = ", gd_MinLot," | stepLot = ", gd_StepLot);
//---- Ðàñ÷èòûâàåì ðàçðÿäíîñòü ëîòà
while (MathPow (10, gi_dig) * gd_StepLot < 1)
{gi_dig += 1;}
//---- Ó÷èòûâàåì ðàáîòó 5-òè çíàêà
if (gi_Digits == 3 || gi_Digits == 5)
{gi_Decimal = 10;}
Slippage *= gi_Decimal;
//---- Ãîòîâèì ê ðàáîòå ìàññèâû äàííûõ
fInitialArrays();
gi_flag_TP = GlobalVariableGet (gs_NameGV + "_#flagTP");
file = StringSubstr (file, 0, StringFind (file, ".csv"));
file = StringConcatenate (file, "_", Symbol(), "_", Period(), ".csv");
if (IsDemo() && !IsTesting())
{file = "virtual_d.csv";}
if (PrintCom) Print ("NameFile = ", file);
gd_XFactor = NDD ((1.6180339887 - XFactor / 1.6180339887) * gd_Point);
//---- Èíèöèàëèçèðóåì áèáëèîòåêó
Init_ICManager (K_Begin);
//---- Êîíòðîëèðóåì âîçìîæíûå îøèáêè
fGetLastError (gs_ComError, "init()");
return (0);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Custor expert deinitialization function |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void deinit()
{
//----
FastTest = false;
VirtualFileSave (file);
//---- Äåèíèöèàëèçèðóåì áèáëèîòåêó ïî óïðàâëåíèþ èíâåñò-êàïèòàëîì
deInit_ICManager (5, 15);
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Custom expert iteration function |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void start()
{
int err = GetLastError();
bool lb_result = false;
//----
//---- Çàïóñêàåì â ðàáîòó áèáëèîòåêó ïî óïðàâëåíèþ èíâåñò-êàïèòàëîì
if (gb_RealTrade)
{f_ICManager (5, 15, False, K_Begin);}
//---- Îïðåäåëÿåì ïåðèîäè÷íîñòü ðàáîòû ñîâåòíèêà
if (NewBarInPeriod >= 0)
{
if (NewBar == iTime (gs_Symbol, NewBarInPeriod, 0))
{return (0);}
NewBar = iTime (gs_Symbol, NewBarInPeriod, 0);
}
//---- Ïîëó÷àåì öåíû, ñ êîòîðûìè áóäåò ðàáîòàòü ñîâåòíèê
fGet_MineTradePrice (Variant_TradePrice, gda_Price);
//---- Îáíîâëÿåì ðûíî÷íóþ èíôîðìàöèþ âèðòóàëüíîé òîðãîâëè
VirtualUpdate (file);
//---- Ïðîâåðÿåì ðûíî÷íûå ïîçèöèè íà çàêðûòèå
fClosings();
//---- Òðåéëèíã îðäåðîâ
fTrailling();
//---- Trailling Profit
if (gi_MyOrders >= 2)
{
if (TrailProfitByMA)
{lb_result = fTrailingProfitByMA (20.0, gd_Profit, gs_NameGV, gi_flag_TP, gi_flag_NullStop);}
else
{lb_result = fTrailingProfit (20.0, TrailProfit_Start, TrailProfit_Level, gd_Profit, gs_NameGV, gi_flag_TP, gi_flag_NullStop);}
if (lb_result)
{
if (CloseOrderAll (gia_TC.Magic))
return;
}
}
//---- Ïðîâåðÿåì óñëîâèÿ íà îòêðûòèå îðäåðîâ
fOpenings();
//---- Çàïóñêàåì â ðàáîòó áèáëèîòåêó ïî óïðàâëåíèþ èíâåñò-êàïèòàëîì (äëÿ òåñòèðîâàíèÿ ïî öåíàì îòêðûòèÿ)
if (!gb_RealTrade)
f_ICManager (5, 15, False, K_Begin);
//---- Êîíòðîëèðóåì âîçìîæíûå îøèáêè
fGetLastError (gs_ComError, "start()");
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ïðîöåäóðà çàêðûòèÿ ïîçèöèé ïî ñèãíàëó |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fClosings()
{
int i, j, li_total, li_POS, myFilter[], li_IND, err = GetLastError();
double PriceClose;
bool lb_close;
//----
//---- Ïåðåáèðàåì âñå ñòðàòåãèè ïî î÷åðåäè
for (int li_TC = 0; li_TC < MAX_TC; li_TC++)
{
if (!(IsTesting() && gia_TC.Enable[li_TC] != 1))
{
li_total = OrdersTotal();
for (li_POS = li_total - 1; li_POS >= 0; li_POS--)
{
if (OrderSelect (li_POS, SELECT_BY_POS))
{
//---- Ïðîïóñêàåì íå ðûíî÷íûå îðäåðà
if (OrderType() > 1)
{continue;}
if (OrderMagicNumber() == gia_TC.Magic[li_TC])
{
lb_close = false;
switch (li_TC)
{
case 0: lb_close = T1_SignalClose (OrderType(), Period.Indicators); break;
case 1: lb_close = T2_SignalClose (OrderType(), Period.Indicators); break;
case 2: lb_close = T3_SignalClose (OrderType(), Period.Indicators); break;
case 3: lb_close = T4_SignalClose (OrderType(), Period.Indicators); break;
case 4: lb_close = T5_SignalClose (OrderType(), Period.Indicators); break;
case 5: lb_close = T6_SignalClose (OrderType(), Period.Indicators); break;
case 6: lb_close = T7_SignalClose (OrderType(), Period.Indicators); break;
case 7: lb_close = T8_SignalClose (OrderType(), OrderOpenTime(), Period.Indicators); break;
}
if (lb_close)
{
PriceClose = gda_Price[OrderType()];
if (!Block()) OrderClose (OrderTicket(), OrderLots(), PriceClose, Slippage);
if (PrintCom) Print ("close #", OrderTicket(), "[", li_TC + 1, "]: ", GetNameOP (OrderType()), " ", DSDig (OrderLots()), " at ", DSD (OrderOpenPrice()), " SL: ", DSD (OrderStopLoss()), " TP: ", DSD (OrderTakeProfit()), " Profit: $", DSD (OrderProfit()), " on a signal.");
}
}
}
}// Next li_POS
VirtualFileLoad (file);
VirtualFilter (VIRT_TRADES, -1, -1, Symbol(), gia_TC.Magic[li_TC]);
if (Virt.Filter.Count > 0)
{
ArrayResize (myFilter, Virt.Filter.Count);
for (li_POS = 0; li_POS < Virt.Filter.Count; li_POS++)
{myFilter[li_POS] = Virt.Filter[li_POS];}// Next li_POS
for (li_POS = 0; li_POS < ArraySize (myFilter); li_POS++)
{
lb_close = false;
li_IND = myFilter[li_POS];
switch (li_TC)
{
case 0: lb_close = T1_SignalClose (Virt.Type[li_IND], Period.Indicators); break;
case 1: lb_close = T2_SignalClose (Virt.Type[li_IND], Period.Indicators); break;
case 2: lb_close = T3_SignalClose (Virt.Type[li_IND], Period.Indicators); break;
case 3: lb_close = T4_SignalClose (Virt.Type[li_IND], Period.Indicators); break;
case 4: lb_close = T5_SignalClose (Virt.Type[li_IND], Period.Indicators); break;
case 5: lb_close = T6_SignalClose (Virt.Type[li_IND], Period.Indicators); break;
case 6: lb_close = T7_SignalClose (Virt.Type[li_IND], Period.Indicators); break;
case 7: lb_close = T8_SignalClose (Virt.Type[li_IND], Virt.OpenTime[li_IND], Period.Indicators); break;
}
if (lb_close)
{
VirtualClose (Virt.Ticket[li_IND], file);
if (PrintCom) Print ("close Virtual #", Virt.Ticket[li_IND], "[", li_TC + 1, "]: ", GetNameOP (Virt.Type[li_IND]), " ", DSDig (Virt.Lots[li_IND]), " at ", Virt.OpenPrice[li_IND], " SL = ", DSD (Virt.StopLoss[li_IND]), " TP = ", DSD (Virt.TakeProfit[li_IND]), " at price = ", DSD (Virt.ClosePrice[li_IND]), " Profit = $", DoubleToStr (Virt.Profit[li_IND], 1));
}
}// Next li_POS
}
}
}
//---- Êîíòðîëèðóåì âîçìîæíûå îøèáêè
fGetLastError (gs_ComError, "fClosings()");
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ïðîöåäóðà ñîïðîâîæäåíèÿ îòêðûòûõ ïîçèöèé (òðàë) |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fTrailling()
{
double ld_TS, ld_Profit, ld_Price,
ld_TS_step = 3 * gi_Decimal * gd_Point,
ld_BU = 5 * gi_Decimal * gd_Point;
int li_total, li_cmd, li_POS, li_Ticket, myFilter[], cnt = 0, li_IND,
err = GetLastError();
bool lb_modify;
//----
gd_Profit = 0.0;
gi_MyOrders = 0;
//---- Ïåðåáèðàåì âñå ñòðàòåãèè ïî î÷åðåäè
for (int li_TC = 0; li_TC < MAX_TC; li_TC++)
{
if (!IsTesting() || gia_TC.Enable[li_TC] == 1)
{
li_total = OrdersTotal();
for (li_POS = li_total - 1; li_POS >= 0; li_POS--)
{
if (OrderSelect (li_POS, SELECT_BY_POS))
{
//---- Ïðîïóñêàåì íå ðûíî÷íûå îðäåðà
if (OrderType() > 1)
{continue;}
if (OrderMagicNumber() == gia_TC.Magic[li_TC])
{
//----- Ðàññ÷èòûâàåì ïðîôèò äëÿ ðàáîòû TraillingProfit
ld_Profit = OrderProfit() + OrderSwap() + OrderCommission();
gd_Profit += ld_Profit;
li_Ticket = OrderTicket();
gi_MyOrders++;
if (gi_flag_NullStop == 0)
{
if (gi_flag_TP == 1)
{
Modify (li_Ticket, 0.0, 0.0, True);
if (PrintCom) {Print ("Delete STOP`s #", li_Ticket, "[", li_TC + 1, "]");}
cnt++;
continue;
}
}
else
{continue;}
ld_Price = gda_Price[OrderType()];
if (OrderType() == OP_BUY) {li_cmd = 1;} else {li_cmd = -1;}
//---- Ðàññ÷èòûâàåì ðàçìåð òðåéëèíã ñòîïà
switch (gia_TC.Var.TS[li_TC])
{
case 0: ld_TS = gda_TC.TS[li_TC]; break;
case 1: ld_TS = NDD (MathAbs (ld_Price - (iMA (NULL, Period.Indicators, TrailPeriod, 0, MAMode, PRICE_OPEN, 0) + li_cmd * gd_XFactor))); break;
}
if (OrderType() == OP_BUY)
{
//---- Ïðîïèñûâàåì ðàáîòó ÁÓ
if (gba_TC.OnlyBU[li_TC])
{
if (OrderStopLoss() == 0 || OrderStopLoss() < OrderOpenPrice())
{
if (ld_Price - OrderOpenPrice() > ld_TS)
{
Modify (li_Ticket, ld_Price - ld_TS + ld_BU);
if (PrintCom) {Print ("Make BU #", li_Ticket, "[", li_TC + 1, "]: ", GetNameOP (OrderType()));}
}
}
}
else
{
if (ld_Price - OrderOpenPrice() > ld_TS)
{
if (OrderStopLoss() == 0 || ld_Price - OrderStopLoss() > ld_TS + ld_TS_step)
{Modify (li_Ticket, ld_Price - ld_TS);}
}
}
}
else if (OrderType() == OP_SELL)
{
//---- Ïðîïèñûâàåì ðàáîòó ÁÓ
if (gba_TC.OnlyBU[li_TC])
{
if (OrderStopLoss() == 0 || OrderStopLoss() > OrderOpenPrice())
{
if (OrderOpenPrice() - ld_Price > ld_TS)
{
Modify (li_Ticket, ld_Price + ld_TS - ld_BU);
if (PrintCom) {Print ("Make BU #", li_Ticket, "[", li_TC + 1, "]: ", GetNameOP (OrderType()));}
}
}
}
else
{
if (OrderOpenPrice() - ld_Price > ld_TS)
{
if (OrderStopLoss() == 0 || OrderStopLoss() - ld_Price > ld_TS + ld_TS_step)
{Modify (li_Ticket, ld_Price + ld_TS);}
}
}
}
}
}
}// Next li_POS
VirtualFileLoad (file);
VirtualFilter (VIRT_TRADES, -1, -1, Symbol(), gia_TC.Magic[li_TC]);
if (Virt.Filter.Count > 0)
{
ArrayResize (myFilter, Virt.Filter.Count);
for (li_POS = 0; li_POS < Virt.Filter.Count; li_POS++)
{myFilter[li_POS] = Virt.Filter[li_POS];}
for (li_POS = 0; li_POS < ArraySize (myFilter); li_POS++)
{
lb_modify = false;
li_IND = myFilter[li_POS];
if (Virt.Type[li_IND] == OP_BUY)
{
if (gba_TC.OnlyBU[li_TC])
{
if (Virt.StopLoss[li_IND] == 0 || Virt.StopLoss[li_IND] < Virt.OpenPrice[li_IND])
{
if (ld_Price - Virt.OpenPrice[li_IND] > ld_TS)
{lb_modify = VirtualModify (Virt.Ticket[li_IND], 0, ld_Price - ld_TS + ld_BU, 0, 0, file);}
}
}
else
{
if (ld_Price - Virt.OpenPrice[li_IND] > ld_TS + ld_TS_step)
{
if (Virt.StopLoss[li_IND] == 0 || ld_Price - Virt.StopLoss[li_IND] > ld_TS)
{lb_modify = VirtualModify (Virt.Ticket[li_IND], 0, ld_Price - ld_TS, 0, 0, file);}
}
}
}
else if (Virt.Type[li_IND] == OP_SELL)
{
if (gba_TC.OnlyBU[li_TC])
{
if (Virt.StopLoss[li_IND] == 0 || Virt.StopLoss[li_IND] > Virt.OpenPrice[li_IND])
{
if (Virt.OpenPrice[li_IND] - ld_Price > ld_TS)
{lb_modify = VirtualModify (Virt.Ticket[li_IND], 0, ld_Price + ld_TS - ld_BU, 0, 0, file);}
}
}
else
{
if (Virt.OpenPrice[li_IND] - ld_Price > ld_TS + ld_TS_step)
{
if (Virt.StopLoss[li_IND] == 0 || Virt.StopLoss[li_IND] - ld_Price > ld_TS)
{lb_modify = VirtualModify (Virt.Ticket[li_IND], 0, ld_Price + ld_TS, 0, 0, file);}
}
}
}
if (lb_modify)
{if (PrintCom) Print ("modify Virtual #", Virt.Ticket[li_IND], "[", li_TC + 1, "]: ", GetNameOP (Virt.Type[li_IND]), " ", DSDig (Virt.Lots[li_IND]), " at ", DSD (Virt.OpenPrice[li_IND]), " SL: ", DSD (Virt.StopLoss[li_IND]), " TP: ", DSD (Virt.TakeProfit[li_IND]));}
}// Next li_POS
}
}
}
//---- Çàêðûâàåì òðåéëèíã
if (gi_flag_NullStop == 0 && gi_flag_TP == 1)
{
if (PrintCom) Print ("Delete STOP`s on ", cnt, " orders");
gi_flag_NullStop = 1;
GlobalVariableSet (gs_NameGV + "_#NULLStops", gi_flag_NullStop);
}
//---- Êîíòðîëèðóåì âîçìîæíûå îøèáêè
fGetLastError (gs_ComError, "fTrailling()");
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ïðîöåäóðà îòêðûòèÿ ïîçèöèé ïî ñèãíàëó |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fOpenings()
{
int li_CMD, li_Magic, li_Ticket, li_cmd, err = GetLastError();
double ld_R, ld_OpenPrice, ld_StopLoss, ld_TakeProfit, ld_SL, ld_TP, ld_Lot,
gd_StopLevel = MarketInfo (Symbol(), MODE_STOPLEVEL) * gd_Point;
string ls_Comment;
//----
//ArrayInitialize (gia_TC.Orders, 0);
//---- Ïåðåáèðàåì âñå ñòðàòåãèè ïî î÷åðåäè
for (int li_TC = 0; li_TC < MAX_TC; li_TC++)
{
if (gia_TC.Enable[li_TC] == 1)
{
switch (li_TC)
{
case 0: li_CMD = T1_SignalOpen (Period.Indicators); break;
case 1: li_CMD = T2_SignalOpen (Period.Indicators); break;
case 2: li_CMD = T3_SignalOpen (Period.Indicators); break;
case 3: li_CMD = T4_SignalOpen (Period.Indicators); break;
case 4: li_CMD = T5_SignalOpen (Period.Indicators); break;
case 5: li_CMD = T6_SignalOpen (Period.Indicators); break;
case 6: li_CMD = T7_SignalOpen (Period.Indicators); break;
case 7: li_CMD = T8_SignalOpen (Period.Indicators); break;
}
if (li_CMD > -1)
{
li_Magic = gia_TC.Magic[li_TC];
VirtualFilter (VIRT_TRADES, -1, -1, Symbol(), li_Magic);
gia_TC.Orders[li_TC] = Virt.Filter.Count;
//---- Îãðàíè÷èâàåì êîëè÷åñòâî îòêðûâàåìûõ îðäåðîâ îäíîé ñòðàòåãèåé
if (Virt.Filter.Count < MAX_OrdersOnTC)
{
ld_R = VirtualRating (li_Magic, Symbol(), gia_TC.PeriodRating[li_TC], 0, file);
gda_R[li_TC] = ld_R;
if (!VirtualExist (iTime (Symbol(), Period.New.Send, 0), li_Magic))
{
if (li_CMD == OP_BUY) {li_cmd = 1;} else {li_cmd = -1;}
if (li_CMD == OP_BUY) {ld_OpenPrice = gda_Price[1];} else {ld_OpenPrice = gda_Price[0];}
switch (gia_TC.Var.STOP[li_TC])
{
case 0:
ld_StopLoss = ld_OpenPrice - li_cmd * MathMax (gd_StopLevel, gda_TC.SL[li_TC]);
ld_TakeProfit = ld_OpenPrice + li_cmd * MathMax (gd_StopLevel, gda_TC.TP[li_TC]);
break;
case 1:
ld_SL = MathAbs (ld_OpenPrice - (iMA (NULL, Period.Indicators, STOP.Period, 0, MAMode, PRICE_OPEN, 0) + li_cmd * gd_XFactor));
ld_StopLoss = NDD (ld_OpenPrice - li_cmd * MathMax (gd_StopLevel, ld_SL));
if (gda_TC.TP[li_TC] == 0)
{
if (li_cmd == 1) {li_cmd = -1;} else {li_cmd = 1;}
ld_TP = MathAbs (ld_OpenPrice - (iMA (NULL, Period.Indicators, STOP.Period, 0, MAMode, PRICE_OPEN, 0) + li_cmd * gd_XFactor));
ld_TakeProfit = MathAbs (NDD (ld_OpenPrice - li_cmd * MathMax (gd_StopLevel, ld_TP)));
}
else
{ld_TakeProfit = ld_OpenPrice + li_cmd * MathMax (gd_StopLevel, gda_TC.TP[li_TC]);}
break;
}
ld_SL = MathMax (gd_StopLevel, ld_SL);
ld_Lot = gda_TC.lot[li_TC];
if (RatingON) if (PrintCom) Print ("System ", li_TC + 1, ": Rating = ", DS0 (ld_R), "%");
li_Ticket = VirtualSend (Symbol(), li_CMD, ld_Lot, ld_OpenPrice, Slippage, ld_StopLoss, ld_TakeProfit, "R = " + DoubleToStr (ld_R, 1) + "%", li_Magic, 0, file);
if (PrintCom) Print ("open Virtual #", li_Ticket, "[", li_TC + 1, "]: ", GetNameOP (li_CMD), " ", DSDig (ld_Lot), " at ", DSD (ld_OpenPrice), " SL[", MathAbs (ld_OpenPrice - ld_StopLoss) / gd_Point, "]: ", DSD (ld_StopLoss), " TP[", MathAbs (ld_OpenPrice - ld_TakeProfit) / gd_Point, "]: ", DSD (ld_TakeProfit), " R: ", DS0 (ld_R), "%");
//---- Åñëè ðåéòíèã ñòðàòåãèè > ìèíèìàëüíîãî ðåéòèíãà, îòêðûâàåì ðûíî÷íûé îðäåð
if (ld_R > MinRating // óñëîâèå ñîîòâåòñâèÿ ðåéòèíãà
&& gi_flag_TP == 0) // íå ðàáîòàåò (âêëþ÷¸í) Trailling Profit
{
if (!OrderExist (iTime (Symbol(), Period.New.Send, 0), li_Magic))
{
li_Ticket = 0;
ld_Lot = ld_Lot * ld_R / 100;
ls_Comment = StringConcatenate ("System ", li_TC + 1, " (R = ", DoubleToStr (ld_R, 1), "%)");
if (li_CMD == OP_BUY)
{li_Ticket = BUY_pips (ld_Lot, ld_StopLoss, ld_TakeProfit, li_Magic, ls_Comment);}
else if (li_CMD == OP_SELL)
{li_Ticket = SELL_pips (ld_Lot, ld_StopLoss, ld_TakeProfit, li_Magic, ls_Comment);}
if (li_Ticket > 0)
{
//Print ("Open orders #", li_Ticket, "[", ld_Lot, "/", li_Magic, "] from ", li_TC + 1, " strategy");
if (OrderSelect (li_Ticket, SELECT_BY_TICKET))
{OrderPrint();}
}
}
}
}// if (!VirtualExist...
}
}
}
}
if (gi_MyOrders == 0)
{
gi_flag_TP = 0;
gi_flag_NullStop = 0;
GlobalVariableSet (gs_NameGV + "_#flagTP", gi_flag_TP);
GlobalVariableSet (gs_NameGV + "_#NULLStops", gi_flag_NullStop);
}
//---- Êîíòðîëèðóåì âîçìîæíûå îøèáêè
fGetLastError (gs_ComError, "fOpenings()");
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà îòêðûòèå ïîçèöèè: |
//| -1 - íå îòêðûâàòü ïîçèöèþ |
//| 0 - ïîêóïàòü |
//| 1 - ïðîäàâàòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int T1_SignalOpen (int fi_Period = 0)
{
double MA_Fast = iMA (NULL, fi_Period, T1.Fast, 0, MODE_EMA, PRICE_CLOSE, 1),
MA_Fast_Last = iMA (NULL, fi_Period, T1.Fast, 0, MODE_EMA, PRICE_CLOSE, 2),
MA_Slow = iMA (NULL, fi_Period, T1.Slow, 0, MODE_EMA, PRICE_CLOSE, 1),
MA_Slow_Last = iMA (NULL, fi_Period, T1.Slow, 0, MODE_EMA, PRICE_CLOSE, 2);
//----
if (MA_Slow > MA_Slow_Last)
{
if (MA_Fast > MA_Slow && MA_Fast_Last < MA_Slow_Last)
{return (OP_BUY);}
}
if (MA_Slow < MA_Slow_Last)
{
if (MA_Fast < MA_Slow && MA_Fast_Last > MA_Slow_Last)
{return (OP_SELL);}
}
//----
return (-1);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà çàêðûòèå ïîçèöèè: |
//| false - íå çàêðûâàòü ïîçèöèþ |
//| true - çàêðûòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool T1_SignalClose (int type, int fi_Period = 0)
{
if (type == T1_SignalOpen (fi_Period)) return (false);
//----
double MA_Fast = iMA (NULL, fi_Period, T1.Fast, 0, MODE_EMA, PRICE_CLOSE, 1),
MA_Slow = iMA (NULL, fi_Period, T1.Slow, 0, MODE_EMA, PRICE_CLOSE, 1);
//----
if (type == OP_BUY)
{if (MA_Fast < MA_Slow) return (true);}
else if (type == OP_SELL)
{if (MA_Fast > MA_Slow) return (true);}
//----
return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà îòêðûòèå ïîçèöèè: |
//| -1 - íå îòêðûâàòü ïîçèöèþ |
//| 0 - ïîêóïàòü |
//| 1 - ïðîäàâàòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int T2_SignalOpen (int fi_Period = 0, int Candle = 0)
{
double CCI = iCCI (NULL, fi_Period, T2.PeriodCCI, PRICE_TYPICAL, Candle + 1),
CCILast = iCCI (NULL, fi_Period, T2.PeriodCCI, PRICE_TYPICAL, Candle + 2);
//----
if ((CCI < T2.LevelCCI) && (CCILast > T2.LevelCCI)) return (OP_SELL);
if ((CCI > -T2.LevelCCI) && (CCILast < -T2.LevelCCI)) return (OP_BUY);
//----
return (-1);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà çàêðûòèå ïîçèöèè: |
//| false - íå çàêðûâàòü ïîçèöèþ |
//| true - çàêðûòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool T2_SignalClose (int type, int fi_Period = 0)
{
int i = 0, SS = -1;
//----
while (SS == -1)
{
SS = T2_SignalOpen (fi_Period, i);
i++;
}
if (type == SS) return (false);
//----
return (true);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà îòêðûòèå ïîçèöèè: |
//| -1 - íå îòêðûâàòü ïîçèöèþ |
//| 0 - ïîêóïàòü |
//| 1 - ïðîäàâàòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int T3_SignalOpen (int fi_Period = 0)
{
double MA_Fast = iMA (NULL, fi_Period, T3.Fast, 0, MODE_EMA, PRICE_CLOSE, 1),
MA_Fast_Last = iMA (NULL, fi_Period, T3.Fast, 0, MODE_EMA, PRICE_CLOSE, 2),
MA_Slow = iMA (NULL, fi_Period, T3.Slow, 0, MODE_EMA, PRICE_CLOSE, 1),
MA_Slow_Last = iMA (NULL, fi_Period, T3.Slow, 0, MODE_EMA, PRICE_CLOSE, 2);
//----
if (MA_Slow > MA_Slow_Last)
{
if (MA_Fast > MA_Slow && MA_Fast_Last < MA_Slow_Last)
{return (OP_BUY);}
}
if (MA_Slow < MA_Slow_Last)
{
if (MA_Fast < MA_Slow && MA_Fast_Last > MA_Slow_Last)
{return (OP_SELL);}
}
//----
return (-1);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà çàêðûòèå ïîçèöèè: |
//| false - íå çàêðûâàòü ïîçèöèþ |
//| true - çàêðûòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool T3_SignalClose (int type, int fi_Period = 0)
{
if (type == T3_SignalOpen (fi_Period)) return (false);
//----
double MA_Fast =iMA (NULL, fi_Period, T3.Fast, 0, MODE_EMA, PRICE_CLOSE, 1),
MA_Slow = iMA (NULL, fi_Period, T3.Slow, 0, MODE_EMA, PRICE_CLOSE, 1);
//----
if (type == OP_BUY)
{if (MA_Fast < MA_Slow) return (true);}
else if (type == OP_SELL)
{if (MA_Fast > MA_Slow) return (true);}
//----
return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà îòêðûòèå ïîçèöèè: |
//| -1 - íå îòêðûâàòü ïîçèöèþ |
//| 0 - ïîêóïàòü |
//| 1 - ïðîäàâàòü |
//| Ñòðàòåãèÿ Ñåðãåÿ Ëîçîâèêà |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int T4_SignalOpen (int fi_Period = 0, int CurrentCandle = 0)
{
double LMA200 = iMA (NULL, fi_Period, 200, 0, MODE_EMA, PRICE_OPEN, CurrentCandle + 1),
MA200 = iMA (NULL, fi_Period, 200, 0, MODE_EMA, PRICE_OPEN, CurrentCandle),
LMA50 = iMA (NULL, fi_Period, 50, 0, MODE_EMA, PRICE_OPEN, CurrentCandle + 1),
MA50 = iMA (NULL, fi_Period, 50, 0, MODE_EMA, PRICE_OPEN, CurrentCandle),
LMA10 = iMA (NULL, fi_Period, 10, 0, MODE_EMA, PRICE_OPEN, CurrentCandle + 1),
MA10 = iMA (NULL, fi_Period, 10, 0, MODE_EMA, PRICE_OPEN, CurrentCandle),
LMACD = iMACD (NULL, fi_Period, 12, 26, 9, PRICE_OPEN, MODE_MAIN, CurrentCandle + 1),
MACD = iMACD (NULL, fi_Period, 12, 26, 9, PRICE_OPEN, MODE_MAIN, CurrentCandle);
//----
if (MA200 > LMA200)
{
if (MA50 > LMA50 && MA50 > MA200)
{
if (MA10 > LMA10 && MA10 > MA50)
{
if (MACD > LMACD && MACD > T4.LimitMACD)
{return (0);}
}
}
}
else if (MA200 < LMA200)
{
if (MA50 < LMA50 && MA50 < MA200)
{
if (MA10 < LMA10 && MA10 < MA50)
{
if (MACD < LMACD && MACD < -T4.LimitMACD)
{return (1);}
}
}
}
//----
return (-1);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà çàêðûòèå ïîçèöèè: |
//| false - íå çàêðûâàòü ïîçèöèþ |
//| true - çàêðûòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool T4_SignalClose (int type, int fi_Period = 0)
{
double MA50 = iMA (NULL, fi_Period, 50, 0, MODE_EMA, PRICE_OPEN, 0);
//----
if (type == OP_BUY)
{
if (Close[1] < MA50)
{return (true);}
}
else if (type == OP_SELL)
{
if (Close[1] > MA50)
{return (true);}
}
//----
return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà îòêðûòèå ïîçèöèè: |
//| -1 - íå îòêðûâàòü ïîçèöèþ |
//| 0 - ïîêóïàòü |
//| 1 - ïðîäàâàòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int T5_SignalOpen (int fi_Period = 0, int Candle = 0)
{
double CCI = iCCI (NULL, fi_Period, T5.PeriodCCI, PRICE_TYPICAL, Candle + 1),
CCILast = iCCI (NULL, fi_Period, T5.PeriodCCI, PRICE_TYPICAL, Candle + 2);
//----
if ((CCI > T5.LevelCCI) && (CCILast < T5.LevelCCI)) return (OP_BUY);
if ((CCI < -T5.LevelCCI) && (CCILast > -T5.LevelCCI)) return (OP_SELL);
//----
return (-1);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà çàêðûòèå ïîçèöèè: |
//| false - íå çàêðûâàòü ïîçèöèþ |
//| true - çàêðûòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool T5_SignalClose (int type, int fi_Period = 0)
{
int i = 0, SS = -1;
double MyLevel, CCI;
//----
if (type == OP_BUY)
{MyLevel = T5.LevelCCI - T5.TralingCCI;}
else {MyLevel = T5.LevelCCI + T5.TralingCCI;}
while (SS == -1) // Ïîèñê ñèãíàëà íà ïîêóïêó
{
SS = T5_SignalOpen (fi_Period, i);
i++;
CCI = iCCI (NULL, fi_Period, T5.PeriodCCI, PRICE_TYPICAL, i);
if (type == OP_BUY)
{
if (CCI > MyLevel + 2 * T5.TralingCCI)
{MyLevel = MyLevel + T5.TralingCCI;}
}
else
{
if (CCI < MyLevel - 2 * T5.TralingCCI)
{MyLevel = MyLevel - T5.TralingCCI;}
}
}
CCI = iCCI (NULL, fi_Period, T5.PeriodCCI, PRICE_TYPICAL, 1);
if (type == OP_BUY)
{if (CCI < MyLevel) return (true);}
else
{if (CCI > MyLevel) return (true);}
//----
return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà îòêðûòèå ïîçèöèè: |
//| -1 - íå îòêðûâàòü ïîçèöèþ |
//| 0 - ïîêóïàòü |
//| 1 - ïðîäàâàòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int T6_SignalOpen (int fi_Period = 0)
{
double ld_Perceptron;
//----
ld_Perceptron = Perceptron (fi_Period, VarPerceptron);
if (ld_Perceptron >= Per_BUY) return (OP_BUY);
if (ld_Perceptron <= Per_SELL) return (OP_SELL);
//----
return (-1);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà çàêðûòèå ïîçèöèè: |
//| false - íå çàêðûâàòü ïîçèöèþ |
//| true - çàêðûòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool T6_SignalClose (int type, int fi_Period = 0)
{
double ld_Perceptron;
//----
ld_Perceptron = Perceptron (fi_Period, VarPerceptron);
if (type == OP_BUY)
{
if (ld_Perceptron <= Per_Close_BUY)
{return (true);}
}
else if (type == OP_SELL)
{
if (ld_Perceptron >= Per_Close_SELL)
{return (true);}
}
//----
return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ðàñ÷èòûâàåì Perceptron |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
double Perceptron (int fi_TF, int fi_varPerceptron)
{
double lda_PRC[4], lda_X[4], ld_result = 0;
//----
lda_X[0] = x1 - 100.0;
lda_X[1] = x2 - 100.0;
lda_X[2] = x3 - 100.0;
lda_X[3] = x4 - 100.0;
for (int li_PRC = 0; li_PRC < 4; li_PRC++)
{
switch (fi_varPerceptron)
{
case 0: lda_PRC[li_PRC] = iClose (NULL, fi_TF, gia_PerceptronBars[li_PRC]) - iOpen (NULL, fi_TF, gia_PerceptronBars[li_PRC+1]); break;
case 1: lda_PRC[li_PRC] = iStochastic (NULL, fi_TF, T6.K_Period, T6.D_Period, T6.Slowing, MODE_EMA, 0, MODE_MAIN, gia_PerceptronBars[li_PRC]) - 50.0; break;
case 2: lda_PRC[li_PRC] = iCCI (NULL, fi_TF, T6.Period_CCI, T6.Price_CCI, gia_PerceptronBars[li_PRC]); break;
}
ld_result += lda_X[li_PRC] * lda_PRC[li_PRC];
}
return (ld_result);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà îòêðûòèå ïîçèöèè: |
//| -1 - íå îòêðûâàòü ïîçèöèþ |
//| 0 - ïîêóïàòü |
//| 1 - ïðîäàâàòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int T7_SignalOpen (int fi_Period = 0)
{
double ld_Direction;
//----
ld_Direction = Direction (gia_DirectionBars, Warp, Deviation, Amplitude, Distortion, fi_Period);
if (ld_Direction >= Dir_BUY) return (OP_BUY);
if (ld_Direction <= Dir_SELL) return (OP_SELL);
//----
return (-1);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà çàêðûòèå ïîçèöèè: |
//| false - íå çàêðûâàòü ïîçèöèþ |
//| true - çàêðûòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool T7_SignalClose (int type, int fi_Period = 0)
{
double ld_Direction;
//----
ld_Direction = Direction (gia_DirectionBars, Warp, Deviation, Amplitude, Distortion, fi_Period);
if (type == OP_BUY)
{
if (ld_Direction <= Dir_Close_BUY)
{return (true);}
}
else if (type == OP_SELL)
{
if (ld_Direction >= Dir_Close_SELL)
{return (true);}
}
//----
return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ðàñ÷èòûâàåì Direction |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
double Direction (int iar_NBars[], // ìàññèâ íîìåðîâ áàðîâ äëÿ ðàñ÷¸òà Direction
int fi_Warp,
double fd_Deviation,
int fi_Amplitude,
double fd_Distortion,
int fi_TF = 0) // òàéìôðåéì èíäèêàòîðà AC
{
double ld_iAC[4];
//----
for (int li_int = 0; li_int < 4; li_int++)
{ld_iAC[li_int] = iAC (Symbol(), fi_TF, iar_NBars[li_int]);}
//----
return (fi_Warp * ld_iAC[0] + 100.0 * (fd_Deviation - 1.0) * ld_iAC[1] + (fi_Amplitude - 100) * ld_iAC[2] + 100.0 * fd_Distortion * ld_iAC[3]);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà îòêðûòèå ïîçèöèè: |
//| -1 - íå îòêðûâàòü ïîçèöèþ |
//| 0 - ïîêóïàòü |
//| 1 - ïðîäàâàòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int T8_SignalOpen (int fi_Period = 0)
{
double li_Trend;
//----
li_Trend = fMA_TrendDetection (fi_Period);
if (gi_LastTrend < 0)
{gi_LastTrend = li_Trend;}
if (li_Trend == Trend_UP && gi_LastTrend == Trend_DW)
{
gi_LastTrend = Trend_UP;
return (OP_BUY);
}
if (li_Trend == Trend_DW && gi_LastTrend == Trend_UP)
{
gi_LastTrend = Trend_DW;
return (OP_SELL);
}
//----
return (-1);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ âîçâðàùàåò ñèãíàë íà çàêðûòèå ïîçèöèè: |
//| false - íå çàêðûâàòü ïîçèöèþ |
//| true - çàêðûòü |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool T8_SignalClose (int type, datetime fdt_OpenTime, int fi_Period = 0)
{
if (fdt_OpenTime + Period.New.Send * 60 > TimeCurrent())
{return (false);}
double li_Trend;
//----
li_Trend = fMA_TrendDetection (fi_Period);
if (type == OP_BUY)
{
if (li_Trend == Trend_DW && gi_LastTrend == Trend_UP)
{return (true);}
}
else if (type == OP_SELL)
{
if (li_Trend == Trend_UP && gi_LastTrend == Trend_DW)
{return (true);}
}
//----
return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| TrendDetection |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
int fMA_TrendDetection (int fi_TF = 0)
{
double ld_MA, ld_MA_next;
int lia_Price[] = {PRICE_CLOSE,PRICE_WEIGHTED,PRICE_TYPICAL,PRICE_MEDIAN,PRICE_OPEN},
liaTrend[] = {0,0};
//-----
for (int li_MA = 0; li_MA < 4; li_MA++)
{
ld_MA = iMA (NULL, fi_TF, T8.MA, 0, MAMode, lia_Price[li_MA], 0);
ld_MA_next = iMA (NULL, fi_TF, T8.MA, 0, MAMode, lia_Price[li_MA+1], 0);
if (ld_MA > ld_MA_next)
{liaTrend[0]++;}
if (ld_MA < ld_MA_next)
{liaTrend[1]++;}
}
if (liaTrend[0] == 4)
return (Trend_UP);
if (liaTrend[1] == 4)
return (Trend_DW);
//-----
return (0);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ïðîâåðêà íà âîçìîæíîñòü îñóùåñòâëåíèÿ òîðãîâûõ îïåðàöèé |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool Block()
{
//----
if (!IsTradeAllowed() || IsTradeContextBusy() || !IsConnected())
{
Print ("Ðûíîê çàíÿò, íåò ñâÿçè, èëè ñîâåòíèêó íå ðàçðåøåíî òîðãîâàòü");
return (true);
}
//----
return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ãîòîâèì ê ðàáîòå ìàññèâû äàííûõ |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fInitialArrays()
{
int li_size, li_int;
string tmpArr[];
//----
//---- Ïîäãîòîâêà êîìïîíåíòîâ Perceptron
if (T6.Enabled == 1)
{
fSplitStrToStr (PerceptronBars, tmpArr);
li_size = ArraySize (tmpArr);
ArrayResize (gia_PerceptronBars, li_size);
for (li_int = 0; li_int < li_size; li_int++)
{gia_PerceptronBars[li_int] = StrToInteger (tmpArr[li_int]);}
}
//---- Ïîäãîòîâêà êîìïîíåíòîâ Direction
if (T7.Enabled == 1)
{
fSplitStrToStr (DirectionBars, tmpArr);
li_size = ArraySize (tmpArr);
ArrayResize (gia_DirectionBars, li_size);
for (li_int = 0; li_int < li_size; li_int++)
{gia_DirectionBars[li_int] = StrToInteger (tmpArr[li_int]);}
}
//---- Ïîäãîòîâêà ðàáî÷èõ ìàññèâîâ
for (int li_MG = 0; li_MG < MAX_TC; li_MG++)
{
gia_TC.Magic[li_MG] = Base.Magic + li_MG;
switch (li_MG)
{
case 0:
gia_TC.Enable[li_MG] = T1.Enabled;
gda_TC.SL[li_MG] = T1.SL * gi_Decimal * gd_Point;
gda_TC.TP[li_MG] = T1.TP * gi_Decimal * gd_Point;
gda_TC.TS[li_MG] = T1.TS * gi_Decimal * gd_Point;
gda_TC.lot[li_MG] = T1.lot;
gia_TC.PeriodRating[li_MG] = T1.PeriodRating;
gba_TC.OnlyBU[li_MG] = T1.OnlyBU;
gia_TC.Var.STOP[li_MG] = T1.Var.STOP;
gia_TC.Var.TS[li_MG] = T1.Var.TS;
break;
case 1:
gia_TC.Enable[li_MG] = T2.Enabled;
gda_TC.SL[li_MG] = T2.SL * gi_Decimal * gd_Point;
gda_TC.TP[li_MG] = T2.TP * gi_Decimal * gd_Point;
gda_TC.TS[li_MG] = T2.TS * gi_Decimal * gd_Point;
gda_TC.lot[li_MG] = T2.lot;
gia_TC.PeriodRating[li_MG] = T2.PeriodRating;
gba_TC.OnlyBU[li_MG] = T2.OnlyBU;
gia_TC.Var.STOP[li_MG] = T2.Var.STOP;
gia_TC.Var.TS[li_MG] = T2.Var.TS;
break;
case 2:
gia_TC.Enable[li_MG] = T3.Enabled;
gda_TC.SL[li_MG] = T3.SL * gi_Decimal * gd_Point;
gda_TC.TP[li_MG] = T3.TP * gi_Decimal * gd_Point;
gda_TC.TS[li_MG] = T3.TS * gi_Decimal * gd_Point;
gda_TC.lot[li_MG] = T3.lot;
gia_TC.PeriodRating[li_MG] = T3.PeriodRating;
gba_TC.OnlyBU[li_MG] = T3.OnlyBU;
gia_TC.Var.STOP[li_MG] = T3.Var.STOP;
gia_TC.Var.TS[li_MG] = T3.Var.TS;
break;
case 3:
gia_TC.Enable[li_MG] = T4.Enabled;
gda_TC.SL[li_MG] = T4.SL * gi_Decimal * gd_Point;
gda_TC.TP[li_MG] = T4.TP * gi_Decimal * gd_Point;
gda_TC.TS[li_MG] = T4.TS * gi_Decimal * gd_Point;
gda_TC.lot[li_MG] = T4.lot;
gia_TC.PeriodRating[li_MG] = T4.PeriodRating;
gba_TC.OnlyBU[li_MG] = T4.OnlyBU;
gia_TC.Var.STOP[li_MG] = T4.Var.STOP;
gia_TC.Var.TS[li_MG] = T4.Var.TS;
break;
case 4:
gia_TC.Enable[li_MG] = T5.Enabled;
gda_TC.SL[li_MG] = T5.SL * gi_Decimal * gd_Point;
gda_TC.TP[li_MG] = T5.TP * gi_Decimal * gd_Point;
gda_TC.TS[li_MG] = T5.TS * gi_Decimal * gd_Point;
gda_TC.lot[li_MG] = T5.lot;
gia_TC.PeriodRating[li_MG] = T5.PeriodRating;
gba_TC.OnlyBU[li_MG] = T5.OnlyBU;
gia_TC.Var.STOP[li_MG] = T5.Var.STOP;
gia_TC.Var.TS[li_MG] = T5.Var.TS;
T5.TralingCCI *= gi_Decimal;
break;
case 5:
gia_TC.Enable[li_MG] = T6.Enabled;
gda_TC.SL[li_MG] = T6.SL * gi_Decimal * gd_Point;
gda_TC.TP[li_MG] = T6.TP * gi_Decimal * gd_Point;
gda_TC.TS[li_MG] = T6.TS * gi_Decimal * gd_Point;
gda_TC.lot[li_MG] = T6.lot;
gia_TC.PeriodRating[li_MG] = T6.PeriodRating;
gba_TC.OnlyBU[li_MG] = T6.OnlyBU;
gia_TC.Var.STOP[li_MG] = T6.Var.STOP;
gia_TC.Var.TS[li_MG] = T6.Var.TS;
break;
case 6:
gia_TC.Enable[li_MG] = T7.Enabled;
gda_TC.SL[li_MG] = T7.SL * gi_Decimal * gd_Point;
gda_TC.TP[li_MG] = T7.TP * gi_Decimal * gd_Point;
gda_TC.TS[li_MG] = T7.TS * gi_Decimal * gd_Point;
gda_TC.lot[li_MG] = T7.lot;
gia_TC.PeriodRating[li_MG] = T7.PeriodRating;
gba_TC.OnlyBU[li_MG] = T7.OnlyBU;
gia_TC.Var.STOP[li_MG] = T7.Var.STOP;
gia_TC.Var.TS[li_MG] = T7.Var.TS;
break;
case 7:
gia_TC.Enable[li_MG] = T8.Enabled;
gda_TC.SL[li_MG] = T8.SL * gi_Decimal * gd_Point;
gda_TC.TP[li_MG] = T8.TP * gi_Decimal * gd_Point;
gda_TC.TS[li_MG] = T8.TS * gi_Decimal * gd_Point;
gda_TC.lot[li_MG] = T8.lot;
gia_TC.PeriodRating[li_MG] = T8.PeriodRating;
gba_TC.OnlyBU[li_MG] = T8.OnlyBU;
gia_TC.Var.STOP[li_MG] = T8.Var.STOP;
gia_TC.Var.TS[li_MG] = T8.Var.TS;
break;
}
}
//---- Êîíòðîëèðóåì âîçìîæíûå îøèáêè
fGetLastError (gs_ComError, "fInitialArrays()");
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//+===================================================================================+
//|***********************************************************************************|
//| ÐÀÇÄÅË: Îáùèå ôóíêöèè |
//|***********************************************************************************|
//+===================================================================================+
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Âîçâðàùàåò ìàññèâ STRING èç ñòðîêè, ðàçäåë¸ííîé sDelimiter |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
/*int fSplitStrToStr (string aString, string& aArray[], string aDelimiter = ",")
{
string tmp_str = "", tmp_char = "";
//----
ArrayResize (aArray, 0);
for (int i = 0; i < StringLen (aString); i++)
{
tmp_char = StringSubstr (aString, i, 1);
if (tmp_char == aDelimiter)
{
if (StringTrimLeft (StringTrimRight (tmp_str)) != "")
{
ArrayResize (aArray, ArraySize (aArray) + 1);
aArray[ArraySize (aArray) - 1] = tmp_str;
}
tmp_str = "";
}
else
{
if (tmp_char != " ")
{tmp_str = tmp_str + tmp_char;}
}
}
if (StringTrimLeft (StringTrimRight (tmp_str)) != "")
{
ArrayResize (aArray, ArraySize (aArray) + 1);
aArray[ArraySize (aArray) - 1] = tmp_str;
}
//----
return (ArraySize (aArray));
}*/
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Àâòîð : Êèì Èãîðü Â. aka KimIV, http://www.kimiv.ru |
//+-----------------------------------------------------------------------------------+
//| Âåðñèÿ : 01.09.2005 |
//| Îïèñàíèå : Âîçâðàùàåò íàèìåíîâàíèå òîðãîâîé îïåðàöèè |
//+-----------------------------------------------------------------------------------+
//| Ïàðàìåòðû: |
//| op - èäåíòèôèêàòîð òîðãîâîé îïåðàöèè |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
string GetNameOP (int op)
{
switch (op)
{
case OP_BUY : return ("BUY");
case OP_SELL : return ("SELL");
case OP_BUYLIMIT : return ("BUYLIMIT");
case OP_SELLLIMIT: return ("SELLLIMIT");
case OP_BUYSTOP : return ("BUYSTOP");
case OP_SELLSTOP : return ("SELLSTOP");
}
return (StringConcatenate ("None (", op, ")"));
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ, íîðìàëèçàöèè çíà÷åíèÿ double äî Digit |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
double NDD (double v) {return (NormalizeDouble (v, gi_Digits));}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ, ïåðåâîäà çíà÷åíèÿ èç double â string c íîðìàëèçàöèåé ïî 0 |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
string DS0 (double v) {return (DoubleToStr (v, 0));}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ, ïåðåâîäà çíà÷åíèÿ èç double â string c íîðìàëèçàöèåé ïî Digit |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
string DSD (double v) {return (DoubleToStr (v, gi_Digits));}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ, ïåðåâîäà çíà÷åíèÿ èç double â string c íîðìàëèçàöèåé ïî |
//| ìèíèìàëüíîé ðàçðÿäíîñòè ëîòà |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
string DSDig (double v) {return (DoubleToStr (v, gi_dig));}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Âîçâðàùàåò íàèìåíîâàíèå ñîñòîÿíèÿ (ÄÀ\ÍÅÒ) |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
string CheckBOOL (int M)
{
//----
switch (M)
{
case 0: {return ("Íåò");}
case 1: {return ("Äà");}
}
//----
return ("Íå çíàþ...");
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//+===================================================================================+
//|***********************************************************************************|
//| ÐÀÇÄÅË: Ðàáîòà ñ îðäåðàìè |
//|***********************************************************************************|
//+===================================================================================+
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ôóíêöèÿ çàêðûòèÿ îðäåðîâ ïî òèïó (OP) è Magic (iMG) |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool CloseOrderAll (int iar_MG[], int OP = -1)
{
color lc_close;
int li_Type, li_NUM, err = GetLastError();
double ld_ClosePrice;
bool lb_Close = false;
//----
for (int i = OrdersTotal() - 1; i >= 0; i--)
{
if (!OrderSelect (i, SELECT_BY_POS, MODE_TRADES))
{continue;}
li_NUM = fCheckMyMagic (OrderMagicNumber(), iar_MG);
if (li_NUM < 0)
{continue;}
if (OrderSymbol() != Symbol() || OrderType() > 1)
{continue;}
li_Type = OrderType();
if (OP == li_Type || OP == -1)
{
ld_ClosePrice = gda_Price[li_Type];
if (li_Type == OP_BUY) {lc_close = Blue;} else {lc_close = Red;}
lb_Close = OrderClose (OrderTicket(), OrderLots(), ld_ClosePrice, Slippage, lc_close);
}
}
fGetLastError (gs_ComError, "CloseOrderAll()");
//----
return (lb_Close);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Àâòîð : TarasBY |
//+-----------------------------------------------------------------------------------+
//| Îïèñàíèå : Ïîëó÷àåì öåíû, ñ êîòîðûìè áóäåò ðàáîòàòü ñîâåòíèê |
//+-----------------------------------------------------------------------------------+
//| Ïàðàìåòðû: |
//| iPrice : 0 - Bid; 1 - Ask |
//| fi_VariantPrice : 0 - Bid\Ask; 1 - Open[0]; 2 - Close [1]; 3 - Close[0] |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fGet_MineTradePrice (int fi_VariantPrice, double& ar_Price[])
{
//----
switch (fi_VariantPrice)
{
case 0:
RefreshRates();
ar_Price[0] = Bid;
ar_Price[1] = Ask;
break;
case 1: double ld_Price = iOpen (Symbol(), NewBarInPeriod, 0); break;
case 2: ld_Price = iClose (Symbol(), NewBarInPeriod, 1); break;
case 3: ld_Price = iClose (Symbol(), NewBarInPeriod, 0); break;
}
double ld_spread = MarketInfo (gs_Symbol, MODE_SPREAD) * gd_Point;
ar_Price[0] = ld_Price;
ar_Price[1] = ld_Price + ld_spread;
//----
return;
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| UNI: Òðàëèì ïðîôèò ïî ñ÷¸òó ïî MA |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool fTrailingProfitByMA (int TrailStopMin, // íèæíÿÿ ãðàíèöà ñðàáàòûâàíèÿ Trailing
double dProfit, // ïðîôèò (êîíòðîëèðóåìàÿ âåëè÷èíà)
string Name_GV, // ïðåôèêñ äëÿ GV-ïåðåìåííûõ
int& flag_TP, // ôëàã ñðàáàòûâàíèÿ Trailing
int& flag_Stop) // ôëàã îáíóëåíèÿ ñòîïîâ
{
static double MaxProfit, ld_Profit_BU, ld_ProfitMIN, ld_ProfitSL;
static int li_Trend = -1;
static bool lsb_ON = false, lsb_BU = false;
double ld_MA, ld_ProfitTS, ld_Price;
string ls_fName = "fTrailingProfitByMA()";
int err = GetLastError();
bool lb_result = false;
//----
if (dProfit > 0)
{
//---- Ôèêñèðóåì óðîâåíü ÁÓ äëÿ îáùåãî ïðîôèòà
if (!lsb_BU)
{
ld_Profit_BU = gda_Price[0];
lsb_BU = true;
}
if (dProfit > TrailStopMin)
{
//---- Ôèêñèðóåì óðîâåíü MinProfit äëÿ îáùåãî ïðîôèòà
if (!lsb_ON)
{
ld_ProfitMIN = gda_Price[0];
fCreat_OBJ ("Profit BU", OBJ_HLINE, 0, "Profit BU", 0, Time[0], ld_Profit_BU, false, Gold);
lsb_ON = true;
if (ld_ProfitMIN > ld_Profit_BU)
{li_Trend = Trend_UP;} else {li_Trend = Trend_DW;}
if (PrintCom) Print ("Profit BU = ", DSD (ld_Profit_BU));
}
}
}
else if (dProfit < 0)
{
ld_Profit_BU = 0.0;
ld_ProfitMIN = 0.0;
lsb_BU = false;
lsb_ON = false;
li_Trend = -1;
flag_TP = 0;
flag_Stop = 0;
DelObject ("Profit BU");
DelObject ("Profit SL");
}
if (ld_Profit_BU > 0.0)
{
ld_MA = iMA (NULL, Period.Indicators, TrailProfitPeriod, 0, MAMode, PRICE_OPEN, 0);
if (li_Trend == Trend_UP) // Trend UP
{
ld_Price = gda_Price[0];
//---- Îïðåäåëÿåì ðàçìåð òðåéëèíã ñòîïà
ld_ProfitTS = NDD (MathAbs (ld_Price - (ld_MA + gd_XFactor)));
if (flag_TP == 0)
{
if (ld_Price - ld_Profit_BU > ld_ProfitTS)
{
ld_ProfitSL = NDD (ld_MA + gd_XFactor);
flag_TP = 1;
ObjectSet ("Profit BU", OBJPROP_COLOR, Blue);
GlobalVariableSet (Name_GV + "_#flagTP", flag_TP);
gs_trade = fPrepareComment (StringConcatenate (ls_fName, ": TrailingProfit_ON[UP]. flagTrailProfit = ", CheckBOOL (flag_TP), "."), gb_InfoPrint);
if (PrintCom) Print ("Trailling Stop = ", ld_ProfitTS / gd_Point, " pips; Profit SL[", (ld_Price - ld_ProfitSL) / gd_Point, "] = ", DSD (ld_ProfitSL), "; Price = ", ld_Price);
if (PrintCom) {Print (gs_trade);}
}
}
if (flag_TP == 1)
{
if (ld_Price - ld_ProfitSL > ld_ProfitTS)
{
ld_ProfitSL = ld_Price - ld_ProfitTS;
MaxProfit = MathMax (MaxProfit, dProfit);
DelObject ("Profit BU");
fCreat_OBJ ("Profit SL", OBJ_HLINE, 0, "Profit SL", 0, Time[0], ld_ProfitSL, false, Blue);
ObjectSet ("Profit SL", OBJPROP_STYLE, DRAW_SECTION);
gs_trade = fPrepareComment (StringConcatenate (ls_fName, ": Work TP - MAX = $", DS0 (MaxProfit), "; Profit SL [", (ld_Price - ld_ProfitSL) / gd_Point, "] = ", DSD (ld_ProfitSL), ")."), gb_InfoPrint);
if (PrintCom && fCCV_D (ND0 (MaxProfit), 3)) {Print (gs_trade);}
}
if (ld_Price < ld_ProfitSL)
{lb_result = true;}
}
}
if (li_Trend == Trend_DW) // Trend DW
{
ld_Price = gda_Price[1];
ld_ProfitTS = NDD (MathAbs ((ld_MA - gd_XFactor) - ld_Price));
if (flag_TP == 0)
{
if (ld_Profit_BU - ld_Price > ld_ProfitTS)
{
ld_ProfitSL = NDD (ld_MA - gd_XFactor);
flag_TP = 1;
ObjectSet ("Profit BU", OBJPROP_COLOR, Red);
GlobalVariableSet (Name_GV + "_#flagTP", flag_TP);
gs_trade = fPrepareComment (StringConcatenate (ls_fName, ": TrailingProfit_ON[DW]. flagTrailProfit = ", CheckBOOL (flag_TP), "."), gb_InfoPrint);
if (PrintCom) Print ("Trailling Stop = ", ld_ProfitTS / gd_Point, " pips; Profit SL[", (ld_ProfitSL - ld_Price) / gd_Point, "] = ", DSD (ld_ProfitSL), "; Price = ", ld_Price);
if (PrintCom) {Print (gs_trade);}
}
}
if (flag_TP == 1)
{
if (ld_ProfitSL - ld_Price > ld_ProfitTS)
{
ld_ProfitSL = ld_Price + ld_ProfitTS;
MaxProfit = MathMax (MaxProfit, dProfit);
DelObject ("Profit BU");
fCreat_OBJ ("Profit SL", OBJ_HLINE, 0, "Profit SL", 0, Time[0], ld_ProfitSL, false, Red);
ObjectSet ("Profit SL", OBJPROP_STYLE, DRAW_SECTION);
gs_trade = fPrepareComment (StringConcatenate (ls_fName, ": Work TP - MAX = $", DS0 (MaxProfit), "; Profit SL[", (ld_ProfitSL - ld_Price) / gd_Point, "] = ", DSD (ld_ProfitSL), ")."), gb_InfoPrint);
if (PrintCom && fCCV_D (ND0 (MaxProfit), 3)) {Print (gs_trade);}
}
if (ld_Price > ld_ProfitSL)
{lb_result = true;}
}
}
}
if (lb_result)
{
gs_trade = fPrepareComment (StringConcatenate (ls_fName, ": Close from TP, Profit = $", DS0 (dProfit), "."), gb_InfoPrint);
if (PrintCom) {Print (gs_trade);}
MaxProfit = 0;
flag_TP = 0;
flag_Stop = 0;
GlobalVariableSet (Name_GV + "_#flagTP", flag_TP);
GlobalVariableSet (Name_GV + "_#NULLStops", flag_Stop);
DelObject ("Profit BU");
DelObject ("Profit SL");
return (true);
}
//---- Êîíòðîëèðóåì âîçìîæíûå îøèáêè
fGetLastError (gs_ComError, ls_fName);
return (false);
//----
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| UNI: Òðàëèì ïðîôèò ïî ñ÷¸òó |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool fTrailingProfit (int TrailStopMin, // íèæíÿÿ ãðàíèöà ñðàáàòûâàíèÿ Trailing
int TrailStart, // âåëè÷èíà ñðàáàòûâàíèÿ Trailing
int TrailValue, // âåëè÷èíà îáðàòíîãî îòêàòà ïîñëå ñðàáàòûâàíèÿ
double dProfit, // ïðîôèò (êîíòðîëèðóåìàÿ âåëè÷èíà)
string Name_GV, // ïðåôèêñ äëÿ GV-ïåðåìåííûõ
int& flag_TP, // ôëàã ñðàáàòûâàíèÿ Trailing
int& flag_Stop) // ôëàã îáíóëåíèÿ ñòîïîâ
{
static double MinProfit, MaxProfit;
static int cur_TrailValue, cur_TrailStart, cur_TrailStopMin;
string ls_fName = "fTrailingProfit()";
int err = GetLastError();
//----
cur_TrailValue = TrailValue;
cur_TrailStart = TrailStart;
if (MinProfit > 0)
{cur_TrailStopMin = MathMin (TrailStopMin, MinProfit);}
//----
if (flag_TP == 0)
{
if (dProfit >= cur_TrailStart)
{
MinProfit = dProfit - cur_TrailValue; // íèæíÿÿ ãðàíèöà êîðèäîðà
MaxProfit = MinProfit + cur_TrailValue; // âåðõíÿÿ ãðàíèöà êîðèäîðà
flag_TP = 1;
GlobalVariableSet (Name_GV + "_#flagTP", flag_TP);
gs_trade = fPrepareComment (StringConcatenate (ls_fName, ": TrailingProfit_ON. flagTrailProfit = ", CheckBOOL (flag_TP), "."), gb_InfoPrint);
if (PrintCom) {Print (gs_trade);}
return (false);
}
}
if (flag_TP == 1)
{
if (dProfit >= cur_TrailStart)
{
MinProfit = MathMax (MinProfit, dProfit - cur_TrailValue);
MaxProfit = MathMax (MaxProfit, dProfit);
fCreat_OBJ ("Profit SL", OBJ_HLINE, 0, "Profit SL", 0, Time[0], MinProfit, false, Yellow);
ObjectSet ("Profit SL", OBJPROP_STYLE, DRAW_SECTION);
gs_trade = fPrepareComment (StringConcatenate (ls_fName, ": Work TP. (UP = $", DS0 (MaxProfit), "; DOWN = $", DS0 (MinProfit), "), ProfitStart = ", DS0 (cur_TrailStart), "."), gb_InfoPrint);
if (PrintCom && fCCV_D (ND0 (MaxProfit), 3)) {Print (gs_trade);}
}
if (dProfit < MinProfit)
{
if (MinProfit == cur_TrailStopMin)
{gs_trade = fPrepareComment (StringConcatenate (ls_fName, ": Close by ProfitMin[", TrailStopMin, "], Profit = $", DS0 (dProfit), "."), gb_InfoPrint);}
if (MinProfit > cur_TrailStopMin)
{gs_trade = fPrepareComment (StringConcatenate (ls_fName, ": Close from TP, Profit = $", DS0 (dProfit), "."), gb_InfoPrint);}
if (PrintCom) {Print (gs_trade);}
MaxProfit = 0;
MinProfit = 0;
flag_TP = 0;
flag_Stop = 0;
DelObject ("Profit SL");
GlobalVariableSet (Name_GV + "_#flagTP", flag_TP);
GlobalVariableSet (Name_GV + "_#NULLStops", flag_Stop);
return (true);
}
}
//---- Êîíòðîëèðóåì âîçìîæíûå îøèáêè
fGetLastError (gs_ComError, ls_fName);
return (false);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//+===================================================================================+
//|***********************************************************************************|
//| ÐÀÇÄÅË: Ñåðâèñíûõ ôóíêöèé |
//|***********************************************************************************|
//+===================================================================================+
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ãîòîâèì ê âûâîäó íà ïå÷àòü è íà ãðàôèê êîììåíòàðèè |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
string fPrepareComment (string sText = "", bool bConditions = false)
{if (bConditions) if (StringLen (sText) > 0) {return (sText);}}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Âûâîäèì íà ïå÷àòü è íà ãðàôèê êîììåíòàðèè |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
void fPrintAndShowComment (string Text, bool Show_Conditions, bool Print_Conditions, string& s_Show[], int ind = -1)
{
if ((Show_Conditions || Print_Conditions) && StringLen (Text) > 0)
{
if (ind >= 0 && Show_Conditions)
{s_Show[ind] = Text;}
if (Print_Conditions)
{Print (Text);}
}
//----
return;
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//+===================================================================================+
//|***********************************************************************************|
//| ÐÀÇÄÅË: Ðàáîòà ñ ãðàôè÷åñêèìè îáúåêòàìè |
//|***********************************************************************************|
//+===================================================================================+
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
//| Ðèñóåì OBJ_TREND, OBJ_ARROW, OBJ_HLINE |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool fCreat_OBJ (string fs_Name, int fi_OBJ, int fi_ArrowCode, string fs_Text, int fi_FontSize,
datetime fdt_Time1, double fd_Price1, bool fb_Ray = true, color fc_Color = Gold,
datetime fdt_Time2 = 0, double fd_Price2 = 0)
{
int err = GetLastError();
bool lb_result = false;
//----
if (ObjectFind (fs_Name) == -1)
{lb_result = ObjectCreate (fs_Name, fi_OBJ, 0, 0, 0);}
ObjectSet (fs_Name, OBJPROP_TIME1, fdt_Time1);
ObjectSet (fs_Name, OBJPROP_PRICE1, fd_Price1);
if (fdt_Time2 != 0 || fd_Price2 != 0)
{
ObjectSet (fs_Name, OBJPROP_TIME2, fdt_Time2);
ObjectSet (fs_Name, OBJPROP_PRICE2, fd_Price2);
}
ObjectSet (fs_Name, OBJPROP_COLOR, fc_Color);
if (fi_OBJ == OBJ_TREND)
{ObjectSet (fs_Name, OBJPROP_RAY, fb_Ray);}
if (fi_OBJ == OBJ_ARROW)
{ObjectSet (fs_Name, OBJPROP_ARROWCODE, fi_ArrowCode);}
if (StringLen (fs_Text) > 0)
{ObjectSetText (fs_Name, fs_Text, fi_FontSize, "Calibri", fc_Color);}
fGetLastError (gs_ComError, "fCreat_OBJ()");
//----
return (lb_result);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
// ÓÄÀËÅÍÈÅ ÃÐÀÔÈ×ÅÑÊÎÃÎ ÎÁÚÅÊÒÀ |
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
bool DelObject (string fs_partTXT)
{
int err = GetLastError();
string ls_Name;
bool lb_result = false;
//----
if (ObjectFind (fs_partTXT) != -1)
{
if (ObjectDelete (fs_partTXT))
{return (true);}
}
//---- Óäàëÿåì âñå îáúåêòû ñ çàäàííûì ïðåôèêñîì fs_partTXT
for (int li_OBJ = ObjectsTotal() - 1; li_OBJ >= 0; li_OBJ--)
{
ls_Name = ObjectName (li_OBJ);
if (StringFind (ls_Name, fs_partTXT, 0) > -1)
{
if (ObjectDelete (ls_Name))
{lb_result = true;}
}
}
fGetLastError (gs_ComError, StringConcatenate ("DelObject()[", fs_partTXT, "]"));
//----
return (lb_result);
}
//IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII+
Comments
Markdown Formatting Guide
# H1## H2
### H3
**bold text***italicized text*[title](https://www.example.com)`code````code block
```
> blockquote- Item 1- Item 2
1. First item2. Second item
---