Rest

//+------------------------------------------------------------------+
//|                                                         Rest.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                              GlobalVariables.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
 //+------------------------------------------------------------------+
//ÂÑÅ Î×ÅÍÜ ÏÐÎÑÒÎ: ÎÒÊÐÛÒÈÅ ÏÅÐÂÎÉ ÏÎÇÈÖÈÈ ÏÐÎÈÇÂÎÄÈÒÑß ÍÀ ÍÓËÅÂÎÌ ÁÀÐÅ ÏÐÈ ÏÐÎÁÎÅ ÒÅÊÓÙÅÃÎ ÔÐÀÊÒÀËÀ ÂÛØÅ ÇÓÁΠÀËËÈÃÀÒÎÐÀ.
//                  ÄÎÏÎËÍÈÒÅËÜÍÛÅ ÏÎÇÈÖÈÈ Â ÍÀÏÐÀÂËÅÍÈÅ ÏÅÐÂÎÉ ÏÎÇÈÖÈÈ ÎÒÊÐÛÂÀÞÒÑß ÍÀ ÍÓËÅÂÎÌ ÁÀÐÅ ÏÐÈ ÏÐÎÁÎÅ ÒÅÊÓÙÅÃÎ ÔÐÀÊÒÀËÀ 
//                  ÂÛØÅ ÇÓÁÎÂ ÀËËÈÃÀÒÎÐÀ, ÍÎ ËÈØÜ ÏÐÈ ÓÑËÎÂÈÈ, ÅÑËÈ ÂÑÅ ÒÐÈ ËÈÍÈÈ ÀËËÈÃÀÒÎÐÀ ÂÛÑÒÐÎÈËÈÑÜ Â ÒÐÅÍÄ ÍÀ ÍÓËÅÂÎÌ ÁÀÐÅ.
//                  ÇÀÊÐÛÒÈÅ ÂÑÅÕ ÏÎÇÈÖÈÉ ÏÐÈÎÈÇÂÎÄÈÒÑß ÏÐÈ ÂÎÇÍÈÊÍÎÂÅÍÈÅ ÍÓËÅÂÎÃÎ ÁÀÐÀ ÏÐÈ ÓÑËÎÂÈÅ, ÊÎÃÄÀ ÇÀÊÐÛÒÈÅ ÏÅÐÂÎÃÎ ÁÀÐÀ 
//                  ÏÐÎÈÇÎØËÎ ÇÀ ÏÐÅÄÅËÀÌÈ ÃÓÁ/ÇÓÁÎÂ/×ÅËÞÑÒÈ (ÇÀÄÀÅÒÑß ÂÍÅØÍÈÌ ÏÀÐÀÌÅÒÐÎÌ) ÀËËÈÃÀÒÎÐÀ.
// Delta, TakeProfit, StopLoss è Stop_0 çàäàíû äëÿ 4-õ ðàçðÿäíûõ êîòèðîâîê, åñëè êîòèðîâêè 5-òè ðàçðÿäíûå, òî ïðîãðàììà ñàìà ýòî îáíàðóæèâàåò
// è óìíîæàåò çàäàííûå âåëè÷èíû íà 10.
//+------------------------------------------------------------------+
extern bool TradeAllowed = true;  // ðàçðåøåíèå íà òîðãîâëþ, åñëè TradeAllowed = false, íî åñòü îòêðûòûå ïîçèöèè,
                                  // òî îíè áóäóò çàêðûòà îáû÷íûì ìàíåðîì - ïðè âîçíèêíîâåíèÿ ñèãíàëà íà çàêðûòèå,
                                  // îäíàêî, íîâûå ïîçèöèè îòêðûâàòüñÿ íå áóäåò.
                                  // Ïîýòîìó çàäàâ TradeAllowed = false, ìîæíî èäòè îòäûõàòü, íàäåÿñü ÷òî âñå áóäåò õîðîøî.
extern double ProfitTarget     = 10.0;    // öåëåâàÿ ïðèáûëü â âàëþòå äåïîçèòà, ïðè äîñòèæåíèå îáùåé ïðèáûëüþ ProfitTotal ýòîãî çíà÷åíèÿ âñå ïîçèöèè çàêðûâàþòñÿ
extern int    MagicNumber = 20110218;    // ïðè íóäåâîì çíà÷åíèå ñîâåòíèê ïðèíèìàåò çà ñâîè âñå îðäåðà îòêðûòûå íà èíñòðóìåíòå, íà êîòîðîì îí çàïóùåí
extern double LotInitial  = 0.01;  // ýòè ëîòîì ìû áóäåì òîðãîâàòü
// TakeProfit,StopLoss, Stop_0 è Delta çàäàíû äëÿ 4-õ ðàçðÿäíûõ êîòèðîâîê, åñëè êîòèðîâêè 5-òè ðàçðÿäíûå, òî ïðîãðàììà ñàìà ýòî îáíàðóæèâàåò
// è óìíîæàåò çàäàííûå âåëè÷èíû íà 10.
extern int    TakeProfit  = 0;  // 4-õ ðàçðÿäíàÿ êîòèðîâêà
extern int    StopLoss    = 0;  // 4-õ ðàçðÿäíàÿ êîòèðîâêà
extern int    Stop_0      = 0;  // 4-õ ðàçðÿäíàÿ êîòèðîâêà, ïðè äîñòèæåíèå ëþáûì èç îðäåðîâ òàêîãî ïðîôèòà  â ïóíêòàõ åãî ñòîï-ëîññ ïåðåíîñèòñÿ â áåçóáûòîê.
                                // Åñëè Stoplevel íå ïîçâîëÿåò ýòîãî ñäåëàòü, âûäàåòñÿ ñîîáùåíèå è çâóêîâîé ñèãíàë òðåâîãè.
                                // Åñëè Stop_0 = 0, òî íèêàêèõ äåéñòâèé ïî ïåðåíîñó StopLoss-óðîâíÿ â áåçóáûòîê íå ïðîèçâîäèì.
extern double Stop_0_Zero    = 1.0; // êîãäà îáùàÿ ïðèáûëü ïðåâûñèò ýòî çíà÷åíèå, ñòîï-ëîñû âñåõ îðäåðîâ ïåðåíîñÿòñÿ íà ëèíèþ áåçóáûòêà ZeroTargetPrice
                                     // Åñëè   Stop_0_Zero = 0, íèêàêèõ äåéñòâèé íå ïðîèçâîäèì 
extern double ZeroTarget     = 0.0;  // çíà÷åíèå îáùåé ïðèáûëè íà óðîâíå áåçóáûòêà  ZeroTargetPrice                                                                
extern int    Delta       = 1;    // 4-õ ðàçðÿäíàÿ êîòèðîâêà, êîãäà öåíà Bid ïðåâûñèëà/îïóñòèëàñü íèæå çíà÷åíèÿ âåðõíåãî/íèæíåãî ôðàêòàëà
                                  // íà ýòî çíà÷åíèå â ïóíêòàõ, ôðàêòàë ñ÷èòàåòñÿ ïðîáèòûì
extern int    Distance = 50;      // 4-õ ðàçðÿäíàÿ êîòèðîâêà, ïóíêòû - íå ñïåøèòü óñèëèâàòüñÿ....                              
                                  
// Êðèòåðèé çàêðûòèÿ âñåõ ïîçèöèé - âûáèðàòüñÿ äîëæåí òîëüêî îäèí èç ýòèõ êðèòåðèåâ, â ïðîòèâíîì ñëó÷àå ñîâåòíèê îòêàæåòñÿ ðàáîòàòü
extern bool   CloseAllonLIPS  = false;
extern bool   CloseAllonTEETH = false;
extern bool   CloseAllonJAW   = true;
// Åùå îäèí êðèòåðèé çàêðûòèÿ âñåõ ïîçèöèé. Ýòîò êðèòåðèé èìååò ïðèîðèòåò íàä êðèòåðèÿìè, óêàçàííûìè âûøå.
extern double CloseAllonProfitValue = 1000000.0; // ïðè  ïðåâûøåíèå ïðîôèòîì óêàçàííîé âåëè÷èíû â âàëþòå äåïîçèòà, âñå ïîçèöèè çàêðûâàþòñÿ
// Âîçìîæíî âàì çàõî÷åòñÿ ïðèíóäèòåëüíî çàêðûòü âñå ïîçèöèè íåçàâèñèìî îò äîñòèæåíèÿ äðóãèõ êðèòåðèåâ
extern bool   CloseForced  = false; // ïðèíóäèòåëüíîå çàêðûòèå âñåõ ïîçèöèé
extern bool   OpenBuyOnly  = false; // áóäóò îòêðûâàòüñÿ òîëüêî ïîçèöèè ââåðõ
extern bool   OpenSellOnly = false; // áóäóò îòêðûâàòüñÿ òîëüêî ïîçèöèè âíèç

int           Stoplevel;          // çäåñü áóäåò õðàíèòüñÿ òåêóùèé Stoplevel = MarketInfo(Symbol(),MODE_STOPLEVE)   

double      ProfitTotal;
double      ZeroTargetPrice;
double      ProfitTargetPrice;
double      TicValue;

static bool     BUY_Sign  = false;
static bool     BUY_Stop  = false;
static bool     SELL_Sign = false;
static bool     SELL_Stop = false;

static datetime LastBar = 0;
int             bar2, bar1, bar0;
//---
double   FractalUpperValue = 0;
datetime FractalUpperTime  = 0;
bool     FractalUpperHit   = false;
double   FractalLowerValue = 0;
datetime FractalLowerTime  = 0;
bool     FractalLowerHit   = false;

//---
int jaw_period    = 13;	          //Ïåðèîä óñðåäíåíèÿ ñèíåé ëèíèè (÷åëþñòè àëëèãàòîðà).
int jaw_shift 	   = 8;            //Ñìåùåíèå ñèíåé ëèíèè îòíîñèòåëüíî ãðàôèêà öåíû.
int teeth_period  = 8; 	          //Ïåðèîä óñðåäíåíèÿ êðàñíîé ëèíèè (çóáîâ àëëèãàòîðà).
int teeth_shift   = 5;	          //Ñìåùåíèå êðàñíîé ëèíèè îòíîñèòåëüíî ãðàôèêà öåíû.
int lips_period   = 5;	          //Ïåðèîä óñðåäíåíèÿ çåëåíîé ëèíèè (ãóá àëëèãàòîðà).
int lips_shift    = 3;	          //Ñìåùåíèå çåëåíîé ëèíèè îòíîñèòåëüíî ãðàôèêà öåíû.
int ma_method 	   = MODE_SMMA;    //Ìåòîä óñðåäíåíèÿ. Ìîæåò áûòü ëþáûì èç çíà÷åíèé ìåòîäîâ ñêîëüçÿùåãî ñðåäíåãî (Moving Average).
int applied_price = PRICE_MEDIAN; //Èñïîëüçóåìàÿ öåíà. Ìîæåò áûòü ëþáîé èç öåíîâûõ êîíñòàíò.
//mode 	  -   	Èñòî÷íèê äàííûõ, èäåíòèôèêàòîð îäíîé èç ëèíèé èíäèêàòîðà. Mîæåò áûòü ëþáîé èç ñëåäóþùèõ âåëè÷èí:
//MODE_GATORJAW - ñèíÿÿ ëèíèÿ (ëèíèÿ ÷åëþñòè àëëèãàòîðà),
//MODE_GATORTEETH - êðàñíàÿ ëèíèÿ (ëèíèÿ çóáîâ àëëèãàòîðà),
//MODE_GATORLIPS - çåëåíàÿ ëèíèÿ (ëèíèÿ ãóá àëëèãàòîðà).
double Jaw_0;
double Jaw_1;
double Jaw_2;

double Teeth_0;
double Teeth_1;
double Teeth_2;

double Lips_0;
double Lips_1;
double Lips_2;

bool   TrendUp0;      // TrendUp0   = true if (Lips_0 > Teeth_0 && Teeth_0 > Jaw_0)
bool   TrendDown0;    // TrendDown0 = true if (Lips_0 < Teeth_0 && Teeth_0 < Jaw_0)

bool   TrendUp1;      // TrendUp1   = true if (Lips_1 > Teeth_1 && Teeth_1 > Jaw_1)
bool   TrendDown1;    // TrendDown1 = true if (Lips_1 < Teeth_1 && Teeth_1 < Jaw_1)

bool   TrendUp2;      // TrendUp2   = true if (Lips_2 > Teeth_2 && Teeth_2 > Jaw_2)
bool   TrendDown2;    // TrendDown2 = true if (Lips_2 < Teeth_2 && Teeth_2 < Jaw_2)

double CloseLevel;   // çàâèñèò îò âíåøíèõ ïàðàìåòðîâ CloseAllonLIPS, CloseAllonTEETH, CloseAllonJAW

int _ExpertOrdersTotal;    //îáùåå êîëè÷åñòâî îðäåðîâ, ïðèíàäëåæàùèõ ýêñïåðòó
int _ExpertOrdersBuy;     
int _ExpertOrdersSell;     
int _ExpertOrdersBuyStop;    
int _ExpertOrdersSellStop;     
int _ExpertOrdersBuyLimit;    
int _ExpertOrdersSellLimit;     

// ìàññèâû, â êîòîðûõ áóäóò õðàíèòñüÿ õàðàêòåðèñòèêè îðäåðîâ ïðè âõîäå ïî òåêóùåìó òèêó:
int      _OrderTicket[], _OrderType[];
double   _OrderLots[], _OrderOpenPrice[], _OrderStopLoss[], _OrderTakeProfit[];
double   _OrderProfit[], _OrderSwap[], _OrderCommission[];
datetime _OrderOpenTime[], _OrderExpiration[];
string   _OrderComment[];
int      _OrderMagicNumber[];

color   Order_Clr;
#define ORDER_BUY_CLR  Blue 
#define ORDER_SELL_CLR Red

string OrderOpenSetOkMes           = "  - Îòêðûò/óñòàíîâëåí óñïåøíî"; 
string OrderOpenSetErrorMes        = "  - Îøèáêà îòêðûòèÿ/óñòàíîâêè"; 
string OrderOpenStoplevel_ErrorMes = "  - Îøèáêà îòêðûòèÿ: StopLoss/TakeProfit ìåíüøå òåêóùåãî Stoplevel=";
string OrderOpenLotValue_ErrorMes  = "  - Îøèáêà îòêðûòèÿ: íå õâàòàåò äåíåã äëÿ îòêðûòèÿ ïîçèöèè";

string OrderModifyOkMes            = "  - Ìîäèôèöèðîâàí óñïåøíî";   
string OrderModifyErrorMes         = "  - Îøèáêà ïðè ìîäèôèêàöèè"; 
string OrderModifyStop_0_ErrorMes  = "  - Îøèáêà ïðè ìîäèôèêàöèè: Stop_0 ìåíüøå òåêóùåãî Stoplevel="; 
string OrderModifyZeroPrice_ErrorMes  = "  - Îøèáêà ïðè ìîäèôèêàöèè: ðàçíèöà ìåæäó òåêóùåé öåíîé è ZeroPrice ìåíüøå òåêóùåãî Stoplevel="; 

string OrderDeleteOkMes        = "  - Óäàëåí óñïåøíî"; 
string OrderDeleteErrorMes     = "  - Îøèáêà ïðè óäàëåíèè"; 

string OrderCloseOkMes        = "  - Çàêðûò óñïåøíî"; 
string OrderCloseErrorMes     = "  - Îøèáêà ïðè çàêðûòèè"; 

string CloseParmErrorMes="Íåâåðíî çàäàíû ïàðàìåòðû çàêðûòèÿ ïîçèöèé CloseAllonLIPS,CloseAllonTEETH,CloseAllonJAW,äîëæåí áàòü çàäàí òîëüêî îäèí êðèòåðèé"; 
string CloseForcedParmErrorMes="Íåâåðíî çàäàí ïàðàìåòð ïðèíóäèòåëüíîãî çàêðûòèÿ âñåõ ïîçèöèé CloseForced, íà ñòàðòå ýòîò ïàðàìåòð ä.á. ðàâåí false";
string OnlyTradeParmErrorMes="Íåâåðíî çàäàíû ïàðàìåòðû îäíîñòîðîííåé òîðãîâëè OpenBuyOnly, OpenSellOnly, òîëüêî îäèí èç íèõ ä.á. true";
string Stop_0Stop_0_ZeroParmErrorMes="Íåâåðíî çàäàíû ïàðàìåòðû  Stop_0, Stop_0_Zero, òîëüêî îäèí èç ìîæåò áûòü îòëè÷íûì îò íóëÿ";
string ParmsErrorsMes="Îøèáêè â çàäàíèå çíà÷åíèé âíåøíèõ ïàðàìåòðîâ, ñîâåòíèê íå ðàáîòàåò !";
string ParmsOKReadyMes="Âíåøíèå ïàðàìåòðû çàäàíû âåðíî,Ñîâåòíèê ðàáîòàåò è ãîòîâ îòêðûâàòü ïîçèöèè - TradeAllowed = true";
string ParmsOKNotReadyMes="Âíåøíèå ïàðàìåòðû çàäàíû âåðíî,Ñîâåòíèê ðàáîòàåò, íî îòêðûòèå íîâûõ ïîçèöèé  çàïðåùåíî  - TradeAllowed = false";

int TradeDirection;
int LastError;
int i;
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                             SetSignalesMarti.mq4 |
//|                                         Copyright © 2010, "more" |
//|                                      "mailto:tradertobe@gmail.co |
//+------------------------------------------------------------------+
//************************************************************          
void SetSignalesMarti(bool& BUY_Sign, bool& BUY_Stop, bool& SELL_Sign, bool& SELL_Stop, int& LastBar, int& bar2, int& bar1,int& bar0 )  
  {      
   datetime IBARS = iTime(NULL,0,0); 
//---  
   if (LastBar != IBARS)  // ïðîâåðêà íà íà÷àëî íîâîãî áàðà
   {
    LastBar  = IBARS;     // íîâûé áàð
    SetFractalsValue();
    GetJTLCloseLevelTrend();
   }  // if (LastBar != IBARS) - êîíåö îáðàáîòêè ïîÿâëåíèÿ íîâîãî áàðà
   else  
   {   // ïðîñòî òèê íà íóëåâîì áàðå
//---   
    SetFractalsValue();
    GetJTLCloseLevelTrend();
//--- 
    double BuyLevel  = FractalUpperValue + Delta*Point;
    double SellLevel = FractalLowerValue - Delta*Point;
    if (!FractalUpperHit)
    {
// Ñèãíàë íà îòêðûòèå ïåðâîé ïîçèöèè â òîðãîâîì öèêëå ââåðõ  
      if (_ExpertOrdersBuy == 0 && _ExpertOrdersSell == 0 && (Bid > BuyLevel) && (BuyLevel > Teeth_0))
      {
       BUY_Sign  = true; 
       FractalUpperHit = true;  ObjectSet("FractalUpper",OBJPROP_COLOR,White);  
       return;
      } 
// Ñèãíàë íà îòêðûòèå äîëèâî÷íûõ ïîîçèöèé â òîðãîâîì öèêëå ââåðõ  
      int distance = (_OrderOpenPrice[_ExpertOrdersTotal-1] - Ask)/Point;
      if (_ExpertOrdersBuy >= 1 && _ExpertOrdersSell == 0 && (Bid > BuyLevel) && (BuyLevel > Teeth_0) && TrendUp0 && distance >= Distance)
      {
       BUY_Sign  = true; 
       FractalUpperHit = true;  ObjectSet("FractalUpper",OBJPROP_COLOR,White);  
       return;
      } 
    } // if (!FractalUpperHit)
//---  
    if (!FractalLowerHit)
    {
// Ñèãíàë íà îòêðûòèå ïåðâîé ïîçèöèè â òîðãîâîì öèêëå âíèç  
      if (_ExpertOrdersSell == 0 && _ExpertOrdersBuy == 0 && (Bid < SellLevel) && (SellLevel < Teeth_0))
      {
       SELL_Sign  = true; 
       FractalLowerHit = true;  ObjectSet("FractalLower",OBJPROP_COLOR,White);  
       return;
      } 
// Ñèãíàë íà îòêðûòèå äîëèâî÷íûõ ïîçèöèé â òîðãîâîì öèêëå âíèç
      distance = (Bid - _OrderOpenPrice[_ExpertOrdersTotal-1])/Point;
      if (_ExpertOrdersSell >= 1 && _ExpertOrdersBuy == 0 && (Bid < SellLevel) && (SellLevel < Teeth_0) && TrendDown0 && distance >= Distance)
      {
       SELL_Sign  = true; 
       FractalLowerHit = true;  ObjectSet("FractalLower",OBJPROP_COLOR,White);  
       return;
      } 
    } // if (!FractalLowerHit) 
//---
    
// Ìîæåò òàê ñëó÷èòüñÿ, ÷òî îáùàÿ ïðèáûëü ïðåâûñèò çíà÷åíèå, çàäàííîå âî âíåøíåé ïåðåìåííîé -
// extern double ProfitTarget     = 3000.0 - öåëåâàÿ ïðèáûëü â âàëþòå äåïîçèòà, êîãäà  îáùàÿ ïðèáûëüþ ProfitTotal ïðåâûñèò ýòî çíà÷åíèÿ
// âñå ïîçèöèè çàêðûâàþòñÿ.
// Åñëè ProfitTarget = 0, ýòîò ìåõàíèçì çàêðûòèÿ òîðãîâîãî öèêëà íå èñïîëüçóåòñÿ
    ProfitTotal = 0;
    for (i = 0; i < _ExpertOrdersTotal; i++)
    {
     ProfitTotal  += _OrderProfit[i];
    }
    Comment("Ïðèáûëü â âàëþòå äåïîçèòà = ",NormalizeDouble(ProfitTotal,0));
    if (ProfitTarget != 0 && ProfitTotal > ProfitTarget)
    {
     if (_OrderType[0] == OP_BUY)  BUY_Stop = true;
     if (_OrderType[0] == OP_SELL) SELL_Stop  = true;
    }
//---
// Åñëè çàäàíî çíà÷åíèå ïàðàìåòðà ñîâåòíèêà extern bool   CloseForced  = true(ïðèíóäèòåëüíîå çàêðûòèå âñåõ ïîçèöèé),
// òî âñå ïîçèöèè áóäóò çàêðûòû îäíà çà äðóãîé. Ïîñëå çàêðûòèÿ âñåõ ïîçèöèé ñîâåòíèê âîçîáíîâëÿåò ðàáîòó â îáû÷íîì ðåæèìå,
// îäíàêî, ÷òîáû èçáåæàòü ñëó÷àéíîñòåé èíèöèèðóéòå ñîâåòíèê çíà÷åíèåì CloseForced = false
    if (CloseForced && _ExpertOrdersTotal !=0)
    {
     if (_OrderType[0] == OP_BUY)  BUY_Stop = true;
     if (_OrderType[0] == OP_SELL) SELL_Stop  = true;
     CloseForced = false;
     Comment("Ïðèíóäèòåëüíîå çàêðûòèå âñåõ ïîçèöèé ñîãëàñíî çíà÷åíèÿ CloseForced=true"+"\n"+
            "Ïîñëå çàêðûòèÿ âñåõ ïîçèöèé îáÿçàòåëüíî èíèöèèðóéòå ñîâåòíèê ñî çà÷åíèåì CloseForced=false");
    }
//---
   } // else - êîíåö îáðàáîòêè òèêà
   return;  
  } // end of void SetSignales ()       
//************************************************************          
//+------------------------------------------------------------------+
//|                                                  OrdersOpen.mq4  |
//|                                      Copyright © 2010, "more"    |
//|                                     "mailto:tradertobe@gmail.com |
//+------------------------------------------------------------------+
//+---------------------------------------------------------------------------------------------------------------+
//| ôóíêöèÿ îòêðûâàåò îðäåðà                                                                                      |
//+---------------------------------------------------------------------------------------------------------------+
bool OrdersOpen(bool& BUY_Sign, bool& SELL_Sign)   // return(true) -ôóíêöèÿ âûïîëíèëà âñå ÷òî ìîãëà è óïðàâëåíèå ñëåäóåò ïåðåäàòü òåðìèíàëó
{                                      // return(false)-â âûçîâå ôóíêöèè íå áûëî íåîáõîäèìîñòè, óïðàâëåíèå ñëåäóåò ïåðåäàòü äàëåå ïî òåëó ôóíêöèè start()
    if (!BUY_Sign && !SELL_Sign) return(false);
//----
    if (TradeAllowed)  
     {
       Stoplevel = MarketInfo(Symbol(),MODE_STOPLEVEL);
       if ((StopLoss != 0 && StopLoss < Stoplevel) || (TakeProfit != 0 && TakeProfit < Stoplevel))
       {
        PlaySound("alert.wav");
        Print(OrderOpenStoplevel_ErrorMes+Stoplevel);
        return(false);
       } // if ((StopLoss != 0 && StopLoss < Stoplevel) || (TakeProfit != 0 && TakeProfit < Stoplevel))
       i = 0; // ðàäè óäîáñòâà
       double LotValue = 0;     
       _OrderType       [i] = iif(TradeDirection < 0,OP_SELL,OP_BUY);
       if (!GetLotValue(Symbol(),_OrderType[i],LotValue)) 
       {
        PlaySound("alert.wav");
        Print(OrderOpenLotValue_ErrorMes);
        return(false);
       }
       RefreshRates();
       TradeDirection = iif(BUY_Sign,+1,-1);
      _OrderType       [i] = iif(TradeDirection < 0,OP_SELL,OP_BUY);
      _OrderLots       [i] = LotValue;
      _OrderOpenPrice  [i] = iif(_OrderType[i]==OP_BUY,Ask,Bid);

      _OrderStopLoss  [i] = iif(_OrderType[i]==OP_BUY,_OrderOpenPrice[i] - StopLoss * Point,_OrderOpenPrice[i] + StopLoss * Point);
      _OrderStopLoss  [i] = iif( _OrderStopLoss[i]==_OrderOpenPrice[i],0,_OrderStopLoss[i]);

      _OrderTakeProfit[i] = iif(_OrderType[i]==OP_BUY,_OrderOpenPrice[i] + TakeProfit*Point,_OrderOpenPrice[i] - TakeProfit*Point);
      _OrderTakeProfit[i] = iif(_OrderTakeProfit[i] == _OrderOpenPrice[i],0,_OrderTakeProfit[i]);

      _OrderMagicNumber[i] = MagicNumber;
      _OrderComment    [i] = " "; 
      Order_Clr            = iif(TradeDirection > 0,ORDER_BUY_CLR,ORDER_SELL_CLR);  
      bool temp = false;
      if (_OrderSend())
      {
       BUY_Sign  = iif(TradeDirection == +1,false,BUY_Sign ); 
       SELL_Sign = iif(TradeDirection == -1,false,SELL_Sign); 
       temp = true;
      }
      return(temp);
     } // if (TradeAllowed)
 //----
    return(false); // âûçîâ ôóíêöèè íå áûë íåîáõîäèì, óïðàâëåíèå ñëåäóåò ïåðåäàòü äàëåå ïî òåëó ôóíêöèè start()
} // bool OrdersOpen(bool& BUY_Sign, bool& SELL_Sign)
//+---------------------------------------------------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| ôóíêöèÿ ïîñûëàåò íà ÒÎÐÃÎÂÛÉ ÑÅÐÂÅÐ êîìàíäû íà íåìåäëåííîå       |
//| îòêðûòèå îðäåðà èëè íà óñòàíîâêó ëèìèòíîãî îðäåðà                |
//+------------------------------------------------------------------+
bool _OrderSend()
  {
   if (IsTradeContextBusy()) { PlaySound("alert.wav"); return(false);} // òîðãîâûé ïîòîê çàíÿò, ïîäîæäåì ñëåäóþùåãî òèêà
   _OrderTicket[i]=  
        OrderSend(Symbol(),_OrderType       [i]
                          ,_OrderLots       [i]
                          ,_OrderOpenPrice  [i] ,3
                          ,_OrderStopLoss   [i]
                          ,_OrderTakeProfit [i]
                          ,_OrderComment    [i]
                          ,_OrderMagicNumber[i],0,Order_Clr);
   if (_OrderTicket[i] < 0)
    {
     LastError = GetLastError();
     Print("("+_OrderMagicNumber[i]+")"+_OrderComment[i]+OrderOpenSetErrorMes+" : "+ LastError+" - "+ErrorDescription(LastError));
     PlaySound("alert.wav");
     return(false);
    }
   Print("("+_OrderMagicNumber[i]+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderOpenSetOkMes);
   PlaySound("ok.wav");
   return(true);
}    // end of bool _OrderSend()  
//+---------------------------------------------------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                                  OrdersClose.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
//+----------------------------------------------------------------------------------------------------------------------+
//| ôóíêöèÿ ïðîèçâîäèò çàêðûòèå âñåõ îòêðûòûõ îðäåðîâ BUY èëè | âñåõ îòêðûòûõ îðäåðîâ SELL
//+----------------------------------------------------------------------------------------------------------------------+
bool OrdersClose(bool& BUY_Stop, bool& SELL_Stop )   // return(true) -ôóíêöèÿ âûïîëíèëà âñå ÷òî ìîãëà è óïðàâëåíèå ñëåäóåò ïåðåäàòü òåðìèíàëó
{                  // return(false)-â âûçîâå ôóíêöèè íå áûëî íåîáõîäèìîñòè, óïðàâëåíèå ñëåäóåò ïåðåäàòü äàëåå ïî òåëó ôóíêöèè start()
    if (!BUY_Stop && !SELL_Stop)             return(false);
    if (BUY_Stop  && _ExpertOrdersBuy  == 0) {BUY_Stop  = false; return(false);}
    if (SELL_Stop && _ExpertOrdersSell == 0) {SELL_Stop = false; return(false);}
    
    i = 0;
    RefreshRates();
    TradeDirection = iif(BUY_Stop,+1,-1);
    _OrderOpenPrice  [i] = iif(TradeDirection == +1,Bid,Ask);
    Order_Clr            = iif(TradeDirection > 0,ORDER_BUY_CLR,ORDER_SELL_CLR);  
    if (_OrderClose())  return(true);
    return(false);   
}  // end of if ( (BUY_Stop && _ExpertOrdersBuy  != 0) ||  (SELL_Stop && _ExpertOrdersSell != 0))
 //+--------------------------------------------------------------------+
//| ôóíêöèÿ ïîñûëàåò íà ÒÎÐÃÎÂÛÉ ÑÅÐÂÅÐ êîìàíäó íà íåìåäëåííîå         |
//| çàêðûòèå îòêðûòîãîî îðäåðà                                          |
//+--------------------------------------------------------------------+
bool _OrderClose()
  {
   if (IsTradeContextBusy()) { PlaySound("alert.wav"); return(false);} // òîðãîâûé ïîòîê çàíÿò, ïîäîæäåì ñëåäóþùåãî òèêà
   if (OrderClose(_OrderTicket   [i]
                 ,_OrderLots     [i]
                 ,_OrderOpenPrice[i],3
                 ,Order_Clr))
    {
     Print("("+_OrderMagicNumber[i]+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderCloseOkMes);
     PlaySound("ok.wav");
     return(true);
    }
     LastError = GetLastError();  
     Print("("+_OrderMagicNumber[i]+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderCloseErrorMes+" : "+ LastError+" - "+ErrorDescription(LastError));
     PlaySound("alert.wav");
     return(false);
  }  // end of bool _OrderClose()
//************************************************************************************************************************************
//+------------------------------------------------------------------+
//|                                                 OrdersModify.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
//+---------------------------------------------------------------------------------------+
//| ôóíêöèÿ ïðîèçâîäèò ìîäèôèêàöèþ îðäåðîâ èñõîäÿ èç ðåçóëüòàòîâ àíàëèçà òåêóùåé ñèòóàöèè |
//+---------------------------------------------------------------------------------------+
bool OrdersModify()    // return(true) -ôóíêöèÿ âûïîëíèëà âñå ÷òî ìîãëà è óïðàâëåíèå ñëåäóåò ïåðåäàòü òåðìèíàëó
{                      // return(false)-â âûçîâå ôóíêöèè íå áûëî íåîáõîäèìîñòè, óïðàâëåíèå ñëåäóåò ïåðåäàòü äàëåå ïî òåëó ôóíêöèè start()
    if (_ExpertOrdersTotal == 0) return(false);
//--    
    RefreshRates();
    ProfitTotal = 0;
    for (i = 0; i < _ExpertOrdersTotal; i++)
    {
     ProfitTotal  += _OrderProfit[i];
    }
    Comment("Ïðèáûëü â âàëþòå äåïîçèòà = ",NormalizeDouble(ProfitTotal,0));
//--
// Åñëè  Stop_0 != 0, óñòàíîâèì ñòîï-ëîñû âñåõ îòêðûòûõ ïîçèöèé â áåçóáûòîê
    if (Stop_0 != 0) 
    {
     for (i = 0; i < _ExpertOrdersTotal; i++)
     {    
      TradeDirection = iif(_OrderType[i] == OP_BUY,+1,-1);
      double CurrentPrice = iif(TradeDirection == +1,Bid,Ask);
      int ProfitPips = iif(TradeDirection == +1,(CurrentPrice - _OrderOpenPrice[i])/Point,(_OrderOpenPrice[i] - CurrentPrice)/Point);
      if (ProfitPips < Stop_0)     continue;
      Stoplevel = MarketInfo(Symbol(),MODE_STOPLEVEL);
      if (Stop_0 <= Stoplevel)
      {
       PlaySound("alert.wav");
       Print("("+MagicNumber+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderModifyStop_0_ErrorMes+Stoplevel);
       continue;
      }
      if (_OrderStopLoss  [i] == _OrderOpenPrice [i]) continue;
      _OrderStopLoss  [i] = _OrderOpenPrice [i]; 
      bool temp = _OrderModify();
      break;
     } // for (i = 0; i < _ExpertOrdersTotal; i++)
     return(temp); 
    } // if (Stop_0 != 0) 
// Êîãäà îáùàÿ ïðèáûëü ProfitTotal ïðåâûñìò çíà÷åíèå extern double Stop_0_Zero , ñòîï-ëîñû âñåõ îðäåðîâ ïåðåíîñÿòñÿ íà ëèíèþ áåçóáûòêà ZeroTargetPrice
    if (ProfitTotal > Stop_0_Zero && Stop_0_Zero != 0) 
    {
     for (i = 0; i < _ExpertOrdersTotal; i++)
     {    
      if (_OrderStopLoss  [i] == ZeroTargetPrice) continue;
      TradeDirection = iif(_OrderType[i] == OP_BUY,+1,-1);
      CurrentPrice = iif(TradeDirection == +1,Bid,Ask);
      int ZeroPips = iif(TradeDirection == +1,(CurrentPrice - ZeroTargetPrice)/Point,(ZeroTargetPrice - CurrentPrice)/Point);
      Stoplevel = MarketInfo(Symbol(),MODE_STOPLEVEL);
      if (ZeroPips <= Stoplevel)
      {
       PlaySound("alert.wav");
       Print("("+MagicNumber+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderModifyZeroPrice_ErrorMes+Stoplevel);
       continue;
      }
      _OrderStopLoss  [i] = ZeroTargetPrice; 
      temp = _OrderModify();
      break;
     } // for (i = 0; i < _ExpertOrdersTotal; i++)
     return(temp); 
    } // if (ProfitTotal > Stop_0_Zero)
} // end of bool OrdersModify()
//+--------------------------------------------------------------------+
//| ôóíêöèÿ ïîñûëàåò íà ÒÎÐÃÎÂÛÉ ÑÅÐÂÅÐ êîìàíäó íà íåìåäëåííóþ         |
//| ìîäèôèêàöèþ îòêðûòîãî èëè ëèìèòíîãî îðäåðà                         |
//+--------------------------------------------------------------------+
bool _OrderModify()
  {
   if (IsTradeContextBusy()) { PlaySound("alert.wav"); return(false);} // òîðãîâûé ïîòîê çàíÿò, ïîäîæäåì ñëåäóþùåãî òèêà
   if (OrderModify(_OrderTicket    [i]
                  ,_OrderOpenPrice [i]
                  ,_OrderStopLoss  [i]
                  ,_OrderTakeProfit[i]
                  ,0
                  ,CLR_NONE))
    {
     Print("("+MagicNumber+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderModifyOkMes);
     PlaySound("ok.wav");
     return(true);
    }
     LastError = GetLastError(); if (LastError == ERR_NO_RESULT) return(true);
     Print("("+MagicNumber+")"+_OrderComment[i]+"("+_OrderTicket[i]+")"+OrderModifyErrorMes+" : "+ LastError+" - "+ErrorDescription(LastError));
     PlaySound("alert.wav");
     return(false);
  }  // end of bool _OrderModify() 
//+---------------------------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                             SetFractalsValue.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
void  SetFractalsValue() 
  {
   datetime FractalUpperTimeOld = FractalUpperTime;
   datetime FractalLowerTimeOld = FractalLowerTime;
   
   FractalUpperValue = 0;
   FractalLowerValue = 0;
//---   
   int i = 0;
   while (FractalUpperValue == 0)
   {
    FractalUpperValue = iFractals(NULL, 0, MODE_UPPER, i);
    i++;
   }
   int FractalUpperBar = i - 1;
//---   
   i = 0;
   while (FractalLowerValue == 0)
   {
    FractalLowerValue = iFractals(NULL, 0, MODE_LOWER, i);
    i++;
   }
   int FractalLowerBar = i - 1;
//---   
   if (ObjectFind("FractalUpper")<0) 
    {
     ObjectCreate("FractalUpper",OBJ_TREND,0,Time[FractalUpperBar+1],FractalUpperValue,Time[FractalUpperBar-1],FractalUpperValue);
     ObjectSet("FractalUpper",OBJPROP_STYLE,STYLE_SOLID);
     if (Bid > FractalUpperValue){FractalUpperHit = true;  ObjectSet("FractalUpper",OBJPROP_COLOR,White);}

     else                        {FractalUpperHit = false; ObjectSet("FractalUpper",OBJPROP_COLOR,Blue); }
    }
    FractalUpperTime = Time[FractalUpperBar];
    if (FractalUpperTime != FractalUpperTimeOld)
    {
     if (Bid > FractalUpperValue){FractalUpperHit = true;  ObjectSet("FractalUpper",OBJPROP_COLOR,White);}

     else                        {FractalUpperHit = false; ObjectSet("FractalUpper",OBJPROP_COLOR,Blue); }
     
     ObjectMove("FractalUpper",0,Time[FractalUpperBar+1],FractalUpperValue);  
     ObjectMove("FractalUpper",1,Time[FractalUpperBar-1],FractalUpperValue);
    }
//---
//---   
   if (ObjectFind("FractalLower")<0) 
    {
     ObjectCreate("FractalLower",OBJ_TREND,0,Time[FractalLowerBar+1],FractalLowerValue,Time[FractalLowerBar-1],FractalLowerValue);
     ObjectSet("FractalLower",OBJPROP_STYLE,STYLE_SOLID);
     if (Bid < FractalLowerValue) {FractalLowerHit = true;  ObjectSet("FractalLower",OBJPROP_COLOR,White);}
     else                         {FractalLowerHit = false; ObjectSet("FractalLower",OBJPROP_COLOR,Red);  }
    }
    FractalLowerTime = Time[FractalLowerBar];
    if (FractalLowerTime != FractalLowerTimeOld)
    {
     if (Bid < FractalLowerValue) {FractalLowerHit = true;  ObjectSet("FractalLower",OBJPROP_COLOR,White);}
     else                         {FractalLowerHit = false; ObjectSet("FractalLower",OBJPROP_COLOR,Red);  }
     
     ObjectMove("FractalLower",0,Time[FractalLowerBar+1],FractalLowerValue);
     ObjectMove("FractalLower",1,Time[FractalLowerBar-1],FractalLowerValue);
    }
//---   
  } //  void  SetFractalsValue() 
//+------------------------------------------------------------------+
//|                                        GetJTLCloseLevelTrend.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
 void GetJTLCloseLevelTrend()
{
    Jaw_0  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORJAW  ,0);
    Teeth_0  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORTEETH,0);
    Lips_0  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORLIPS ,0);
   
    Jaw_1  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORJAW  ,1);
    Teeth_1  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORTEETH,1);
    Lips_1  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORLIPS ,1);
   
    Jaw_2  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORJAW  ,2);
    Teeth_2  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORTEETH,2);
    Lips_2  =
    iAlligator(NULL,0,jaw_period,jaw_shift,teeth_period,teeth_shift,lips_period,lips_shift,ma_method,applied_price,MODE_GATORLIPS ,2);
   
    
    if (Lips_0 > Teeth_0 && Teeth_0 > Jaw_0) TrendUp0   = true; else TrendUp0   = false;
    if (Lips_0 < Teeth_0 && Teeth_0 < Jaw_0) TrendDown0 = true; else TrendDown0 = false;
    
    if (Lips_1 > Teeth_1 && Teeth_1 > Jaw_1) TrendUp1   = true; else TrendUp1   = false;
    if (Lips_1 < Teeth_1 && Teeth_1 < Jaw_1) TrendDown1 = true; else TrendDown1 = false;
    
    if (Lips_2 > Teeth_2 && Teeth_2 > Jaw_2) TrendUp2   = true; else TrendUp2   = false;
    if (Lips_2 < Teeth_2 && Teeth_2 < Jaw_2) TrendDown2 = true; else TrendDown2 = false;
    
/*    
    if (CloseAllonLIPS  && (TrendUp0 || TrendDown0))  {CloseLevel = Lips_1;  return;}
    if (CloseAllonTEETH && (TrendUp0 || TrendDown0))  {CloseLevel = Teeth_1; return;}
    if (CloseAllonJAW   && (TrendUp0 || TrendDown0))  {CloseLevel = Jaw_1;   return;}
*/    
    if (CloseAllonLIPS)  {CloseLevel = Lips_1;  return;}
    if (CloseAllonTEETH) {CloseLevel = Teeth_1; return;}
    if (CloseAllonJAW  ) {CloseLevel = Jaw_1;   return;}
    return;
    
}  // void GetJawTeethLips()
//+------------------------------------------------------------------+
//|                                           GetZeroTargetLines.mq4 |
//|                                      Copyright © 2010, "more"    |
//|                                     "mailto:tradertobe@gmail.com |
//+------------------------------------------------------------------+
int GetZeroTargetLines()
  {
   if (_ExpertOrdersTotal == 0)
   {
    ObjectDelete("ZeroTargetPrice");
    ObjectDelete("ProfitTargetPrice");
    return;
   }
   double sum=0;
   double sum1=0;
   double ZeroTargetPriceOld;
   double ProfitTargetPriceOld;
   ZeroTargetPriceOld = ZeroTargetPrice;
   ProfitTargetPriceOld = ProfitTargetPrice;
   for (i=0; i < _ExpertOrdersTotal; i++)
   {
      if (_OrderType[i] == OP_BUY)
      {
       sum  = sum   + _OrderLots[i]  * _OrderOpenPrice[i] * TicValue;
       sum1 = sum1  + _OrderLots[i]  * TicValue ; 
      }
      if (_OrderType[i] == OP_SELL)
      {
       sum =  sum -  _OrderLots[i] * _OrderOpenPrice[i] * TicValue;
       sum1 = sum1 - _OrderLots[i] * TicValue ; 
      }
   } // for (i=0; i < _ExpertOrdersTotal; i++)
   if (sum1 == 0) return;
//---   
   ZeroTargetPrice = (ZeroTarget * Point +  sum)/sum1;
   ZeroTargetPrice = NormalizeDouble(ZeroTargetPrice,Digits); 
   if (ObjectFind("ZeroTargetPrice")<0)   
    {
     ObjectCreate("ZeroTargetPrice",OBJ_HLINE,0,D'2007.05.01 00:00:00',ZeroTargetPrice);
     ObjectSet   ("ZeroTargetPrice",OBJPROP_COLOR,White);
     ObjectSet   ("ZeroTargetPrice",OBJPROP_STYLE,STYLE_SOLID);
    }
   if (ZeroTargetPrice != ZeroTargetPriceOld)
   {
    PlaySound("Ku_ku.wav"); 
    ObjectMove("ZeroTargetPrice",0,D'2007.05.01 00:00:00', ZeroTargetPrice);
   }
//---   
   if (ProfitTarget == 0) return;
   ProfitTargetPrice = (ProfitTarget * Point +  sum)/sum1;
   ProfitTargetPrice = NormalizeDouble(ProfitTargetPrice,Digits); 
   if (ObjectFind("ProfitTargetPrice")<0)   
    {
     ObjectCreate("ProfitTargetPrice",OBJ_HLINE,0,D'2007.05.01 00:00:00',ProfitTargetPrice);
     ObjectSet   ("ProfitTargetPrice",OBJPROP_COLOR,Gold);
     ObjectSet   ("ProfitTargetPrice",OBJPROP_STYLE,STYLE_SOLID);
    }
   if (ProfitTargetPrice != ProfitTargetPriceOld)
   {
    PlaySound("Ku_ku.wav"); 
    ObjectMove("ProfitTargetPrice",0,D'2007.05.01 00:00:00', ProfitTargetPrice);
   }
//---   
   return(0);
} // GetZeroTargetLines
//+------------------------------------------------------------------+
//|                                                  GetLotValue.mq4 |
//|                                         Copyright © 2010, "more" |
//|                                      "mailto:tradertobe@gmail.co |
//+------------------------------------------------------------------+
bool GetLotValue(string symbol, int Cmd, double& Lot)
 {
   if (_ExpertOrdersTotal < 3) 
   {
    Lot = LotInitial;
   }
   else
   {
    for (int i = 0; i < _ExpertOrdersTotal; i++) {Lot += _OrderLots[i];}
   }
//---+
   int  Margin_Check;
   //---
   double MINLOT = MarketInfo(symbol, MODE_MINLOT);
   if (MINLOT == 0)
              return(false);
   //---          
   if (Lot < MINLOT)
    {
     Lot = 0.0;
     return(false);
    }
   //---           
   double LOTSTEP = MarketInfo(symbol, MODE_LOTSTEP);
   if (LOTSTEP == 0)
              return(false);
   //---           
   Lot = LOTSTEP * MathFloor(Lot / LOTSTEP); 
   //---
/*   
   while(Lot >= MINLOT && Margin_Check <= 0)
     {
       Margin_Check =
         AccountFreeMarginCheck(symbol, Cmd, Lot);
       //---              
       if (Margin_Check < 0)
                     Lot -= LOTSTEP; 
       //---              
       if (Lot < MINLOT)
        {
         Lot = 0.0;
         return(false);
        }
     }
*/            
  return(true);
//---+
 }  // bool GetLotValue(string symbol, int Cmd, double& Lot)
//********************************************************************************************************************
//+------------------------------------------------------------------+
//|                                                AllOrdersInit.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
 //| ôóíêöèÿ ïðîèçâîäèò  ôîðìèðîâàíèå ìàññèâîâ, êàæäûé èç êîòîðûõ ïðåäñòàâëÿåò îäíî                      |
//| ïîëå îðäåðà, ïðèíàäëåæàùåãî ýêñïåðòó. òàêèì îáðàçîì, ìíîæåñòâî ýëåìåíòîâ ìàññèâîâ ñ                 |
//| îäíèì çíà÷åíèå èíäåêñà ïðåäñòàâëÿåò îðäåð. ìàññèâû îòñîðòèðîâàíû â ïîðÿäêå âîçðàñòàíèÿ òèêåòà       |
//| ðàçìåðíîñòü ìàññèâîâ =  _ExpertOrdersTotal + 1                                                      |
//| ïîñëåäíèå ýëåìåíòû ìàññèâîâ áóäóò èñïîëüçîâàòüñÿ íàìè äëÿ ôîðìèðîâàíèÿ äàííûõ ïðè îòêðûòèè/óñòàíîâêè|
//| íîâîãî îðäåðà                                                                                       |
 //+----------------------------------------------------------------------------------------------------+
//"mailto:komposterius@mail.ru" - Àíäðåé Õàòèìëÿíñêèé - àâòîð ýòîé ôóíêöèè
//http://www.mql4.com/ru/users/komposter Àíäðåé Õàòèìëÿíñêèé
void AllOrdersInit( int magic )
{
	int _GetLastError = 0, _OrdersTotal = OrdersTotal();
    _ExpertOrdersTotal     = 0;    //îáùåå êîëè÷åñòâî îðäåðîâ, ïðèíàäëåæàùèõ ýêñïåðòó
    _ExpertOrdersBuy       = 0;    // 
    _ExpertOrdersSell      = 0;    // 
    _ExpertOrdersBuyStop   = 0;    // 
    _ExpertOrdersSellStop  = 0;    // 
    _ExpertOrdersBuyLimit  = 0;    // 
    _ExpertOrdersSellLimit = 0;    // 
 	// èçìåíÿåì ðàçìåðû ìàññèâîâ ïîä òåêóùåå êîë-âî ïîçèöèé
	// (åñëè _OrdersTotal = 0, ìåíÿåì ðàçìåð ìàññèâîâ íà 1) 
	int temp_value = MathMax( _OrdersTotal+1, 1 );
	ArrayResize( _OrderTicket,			temp_value );
	ArrayResize( _OrderType,			temp_value );
	ArrayResize( _OrderLots,			temp_value );
	ArrayResize( _OrderOpenPrice,		temp_value );
	ArrayResize( _OrderStopLoss,		temp_value );
	ArrayResize( _OrderTakeProfit,	temp_value );
	ArrayResize( _OrderOpenTime,		temp_value );
	ArrayResize( _OrderProfit,			temp_value );
	ArrayResize( _OrderSwap,			temp_value );
	ArrayResize( _OrderCommission,	temp_value );
	ArrayResize( _OrderComment,		temp_value );
	ArrayResize( _OrderExpiration,	temp_value );
	ArrayResize( _OrderMagicNumber,	temp_value );
	

	// îáíóëÿåì ìàññèâû
	ArrayInitialize( _OrderTicket,		0 );    
	ArrayInitialize( _OrderType,			0 );
	ArrayInitialize( _OrderLots,			0 );
	ArrayInitialize( _OrderOpenPrice,	0 );
	ArrayInitialize( _OrderStopLoss,		0 );
	ArrayInitialize( _OrderTakeProfit,	0 );
	ArrayInitialize( _OrderOpenTime,		0 );
	ArrayInitialize( _OrderProfit,		0 );
	ArrayInitialize( _OrderSwap,			0 );
	ArrayInitialize( _OrderCommission,	0 );
	ArrayInitialize( _OrderExpiration,	0 );
	ArrayInitialize( _OrderMagicNumber,	0 );
   
 	for ( int z = 0;  z < _OrdersTotal;  z ++ )
 	{
		if ( !OrderSelect( z, SELECT_BY_POS ) )
		{
			_GetLastError = GetLastError();
			Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #", _GetLastError );
			continue;
		}
      if (magic == 0)
      {
		 if (OrderSymbol() == Symbol() )
		 {
			// çàïîëíÿåì ìàññèâ òèêåòîâ îðäåðîâ, ïðèíàäëåæàùèõ åêñïåðòó
			_OrderTicket [_ExpertOrdersTotal] = OrderTicket();
 			_ExpertOrdersTotal ++;
 	   	switch(OrderType())
           {
            case OP_BUY       : _ExpertOrdersBuy++ ;        break; 
            case OP_SELL      : _ExpertOrdersSell++ ;       break;
            case OP_BUYSTOP   : _ExpertOrdersBuyStop++ ;    break;
            case OP_SELLSTOP  : _ExpertOrdersSellStop++ ;   break;
            case OP_BUYLIMIT  : _ExpertOrdersBuyLimit++ ;   break;
            case OP_SELLLIMIT : _ExpertOrdersSellLimit++ ;  break;
           }
		 } // if (OrderSymbol() == Symbol() )
		}  // if (magic == 0)
		else
		if (OrderMagicNumber() == magic && OrderSymbol() == Symbol() )
      {
		 {
			// çàïîëíÿåì ìàññèâ òèêåòîâ îðäåðîâ, ïðèíàäëåæàùèõ åêñïåðòó
			_OrderTicket [_ExpertOrdersTotal] = OrderTicket();
 			_ExpertOrdersTotal ++;
 	   	switch(OrderType())
           {
            case OP_BUY       : _ExpertOrdersBuy++ ;        break; 
            case OP_SELL      : _ExpertOrdersSell++ ;       break;
            case OP_BUYSTOP   : _ExpertOrdersBuyStop++ ;    break;
            case OP_SELLSTOP  : _ExpertOrdersSellStop++ ;   break;
            case OP_BUYLIMIT  : _ExpertOrdersBuyLimit++ ;   break;
            case OP_SELLLIMIT : _ExpertOrdersSellLimit++ ;  break;
           }
		 } // if (OrderMagicNumber() == magic && OrderSymbol() == Symbol() )
		} // else
	} // for ( int z = 0;  z < _OrdersTotal;  z ++ )
	// èçìåíÿåì ðàçìåðû ìàññèâîâ ïîä êîë-âî ïîçèöèé, ïðèíàäëåæàùèõ ýêñïåðòó + îäíà
	// (åñëè _ExpertOrdersTotal = 0, ìåíÿåì ðàçìåð ìàññèâîâ íà 1)
	temp_value = MathMax( _ExpertOrdersTotal+1, 1 );
	ArrayResize( _OrderTicket,			temp_value );
	ArrayResize( _OrderType,			temp_value );
	ArrayResize( _OrderLots,			temp_value );
	ArrayResize( _OrderOpenPrice,		temp_value );
	ArrayResize( _OrderStopLoss,		temp_value );
	ArrayResize( _OrderTakeProfit,	temp_value );
	ArrayResize( _OrderOpenTime,		temp_value );
	ArrayResize( _OrderProfit,			temp_value );
	ArrayResize( _OrderSwap,			temp_value );
	ArrayResize( _OrderCommission,	temp_value );
	ArrayResize( _OrderComment,		temp_value );
	ArrayResize( _OrderExpiration,	temp_value );
	
	_OrderTicket[_ExpertOrdersTotal] = 99999999;// ïðè ñîðòèðîâêå ýòîò ïóñòîé ýëåìåíò áóäåò ïîñëåäíèì
   ArraySort(_OrderTicket);  // ïîëó÷èì õðîíîëîãè÷åñêèé ïîðÿäîê...
//------------------------------------------------------------------------------------------------------------------------
	for (   z = 0;  z < _ExpertOrdersTotal;  z ++ )
 	{
		if ( !OrderSelect( _OrderTicket[z], SELECT_BY_TICKET ) )
		{
			_GetLastError = GetLastError();
			Print("OrderSelect( ", _OrderTicket[z], ", SELECT_BY_TICKET ) - Error #", _GetLastError );
			continue;
		}
 			// çàïîëíÿåì îñòàëüíûå ìàññèâû
 			_OrderType			[z] = OrderType();
			_OrderLots			[z] = NormalizeDouble( OrderLots(), 2 );
			_OrderOpenPrice	[z] = NormalizeDouble( OrderOpenPrice(), Digits );
			_OrderStopLoss		[z] = NormalizeDouble( OrderStopLoss(), Digits );
			_OrderTakeProfit	[z] = NormalizeDouble( OrderTakeProfit(), Digits );
			_OrderOpenTime		[z] = OrderOpenTime();
			_OrderProfit		[z] = NormalizeDouble( OrderProfit(), 2 );
			_OrderSwap			[z] = NormalizeDouble( OrderSwap(), 2 );
			_OrderCommission	[z] = NormalizeDouble( OrderCommission(), 2 );
			_OrderComment		[z] = OrderComment();
			_OrderExpiration	[z] = OrderExpiration();
	      _OrderMagicNumber [z] = OrderMagicNumber();
			
  	}
//------------------------------------------------------------------------------------------------------------------------ 
return;	
} // AllOrdersInit( int magic )

//+------------------------------------------------------------------+
//|                                             ServiceFunctions.mq4 |
//|                      Copyright © 2010, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
 //http://www.mql4.com/ru/users/bstone -Êðàìàðü Ðîìàí - àâòîð ÷åòûðåõ, ñëåäóþùèõ íèæå ôóíêöèé
//+------------------------------------------------------------------+
//| helper functions   -   Êðàìàðü Ðîìàí                                     
//+------------------------------------------------------------------+

int sign( double v )
{
    if( v < 0 ) return( -1 );
    return( 1 );
}

//+------------------------------------------------------------------+
double iif( bool condition, double ifTrue, double ifFalse )
{
    if( condition ) return( ifTrue );
    
    return( ifFalse );
}

//+------------------------------------------------------------------+
string iifStr( bool condition, string ifTrue, string ifFalse )
{
    if( condition ) return( ifTrue );

    return( ifFalse );
}

//+------------------------------------------------------------------+
int orderDirection()
{
    return( 1 - 2 * ( OrderType() % 2 ) );
}
//------------------------------------------------------------------------------------------------------------------------