Market_Capture_v5_01

//-----------------------------------------------------------------------------+
#property copyright "Copyright © 2010, Trishkin Artyom A."
#property link      "support@goldsuccess.ru"
//-----------------------------------------------------------------------------+
#include <stdlib.mqh>
#include <stderror.mqh>
#include <WinUser32.mqh>
//==============================================================================
// --------------------------- Ïåðåìåííûå ñîâåòíèêà ---------------------------+
//==============================================================================
extern string  P_Expert= "-- Experts Variables --";
extern double Lots=0.1;                                        // Ëîò
extern bool   UseEquClose=true;                                // Èñïîëüçîâàòü ëè ô-öèþ çàêðûòèÿ ïî ýêâèòè true = äà, false = íåò
extern bool   UseBalanceClose=true;                            // Èñïîëüçîâàòü ëè ô-öèþ çàêðûòèÿ ïî áàëàíñó true = äà, false = íåò
extern double PercentBalanceForClose=50.0;                     // Ïðîöåíò ïðèðîñòà áàëàíñà äëÿ çàêðûòèÿ óáûòî÷íûõ ïîçèöèé
extern double PercentEquityForClose=50.0;                      // Ïðîöåíò ïðèðîñòà ýêâèòè äëÿ çàêðûòèÿ óáûòî÷íûõ ïîçèöèé
extern int    NumberLossPoseForClose=5;                        // Êîëè÷åñòâî çàêðûâàåìûõ óáûòî÷íûõ ïîçèöèé
extern int    DistanceSetOrder=10;                             // Äèñòàíöèÿ óñòàíîâêè îðäåðîâ â ïï
extern int    NumberUpLevels=5;                                // Êîëè÷åñòâî óðîâíåé âûøå öåíû
extern int    NumberDnLevels=5;                                // Êîëè÷åñòâî óðîâíåé íèæå öåíû
//------- Ïàðàìåòðû èñïîëíåíèÿ òîðãîâûõ ïðèêàçîâ ------------------------------+
extern string P_Performanc= "-- Parameters for Trades --";
extern int    NumberOfTry = 5;                                 // Êîëè÷åñòâî òîðãîâûõ ïîïûòîê ïðè îøèáêàõ
extern int    Slippage    = 3;                                 // Âåëè÷èíà ïðîñêàëüçûâàíèÿ öåíû
extern bool   UseSound    = True;                              // Èñïîëüçîâàòü çâóêîâîé ñèãíàë
string        SoundSuccess= "ok.wav";                          // Çâóê óñïåõà
string        SoundError  = "timeout.wav";                     // Çâóê îøèáêè
string        SoundClose  = "Close_order.wav";                 // Çâóê çàêðûòèÿ
//==============================================================================
int      tf, dg, sp;
int      Magic, Level_old, Level_new;
int      MassUpLen, MassDnLen;
string   Prefix, Exp_Name, NameGL_Equ, NameGL_Add, NameGL_Bln, NameGL_BAdd, sy;
color    clUP, clDN;
double   EquStart, EquAdd, EquClose, BlnStart, BlnAdd, BlnClose;
double   CenterLevel, PointX;
double   pa, pb;
double   MassUpLev[5][2];
double   MassDnLev[5][2];
double   MassCtLev[1][2];
double   HighestLev;
double   LowestLev;
//==============================================================================
//---------------------- Ïåðåìåííûå äëÿ ôóíêöèé--------------------------------+
//==============================================================================
bool   AllMessages, PrintEnable;
color  clOpenBuy    = MediumBlue;      // Öâåò çíà÷êà îòêðûòèÿ ïîêóïêè
color  clOpenSell   = OrangeRed;       // Öâåò çíà÷êà îòêðûòèÿ ïðîäàæè
color  clCloseBuy   = Blue;            // Öâåò çíà÷êà çàêðûòèÿ ïîêóïêè
color  clCloseSell  = IndianRed;       // Öâåò çíà÷êà çàêðûòèÿ ïðîäàæè
color  clModifyBuy  = DodgerBlue;      // Öâåò çíà÷êà ìîäèôèêàöèè ïîêóïêè
color  clModifySell = Tomato;          // Öâåò çíà÷êà ìîäèôèêàöèè ïðîäàæè
color  clDelete     = Yellow;          // Öâåò çíà÷êà óäàëåíèÿ îðäåðà
bool   MarketWatch  = True;            // Çàïðîñû ïîä èñïîëíåíèå "Market Watch".
bool   gbDisabled   = False;           // Ôëàã áëîêèðîâêè ñîâåòíèêà
int    modeSetOrders= 1;               // Ñïîñîá óñòàíîâêè îðäåðîâ:
                                       //  0 - ïî çàäàííîé öåíå
                                       //  1 - ñêîððåêòèðîâàòü öåíû
                                       //  2 - âõîä ïî òåêóùèì öåíàì
//----------------------------------------------------------------
//==============================================================================
int init()
{
   double p1, p2;
   tf=Period();
   sy=Symbol();
   pa=MarketInfo(sy,MODE_ASK);
   pb=MarketInfo(sy,MODE_BID);
   dg=MarketInfo(sy,MODE_DIGITS);
   Level_old=MarketInfo(Symbol(),MODE_STOPLEVEL );             // Ìèíèì. äèñòàíèöèÿ óñòàíîâêè ñòîïîâ
   if(Digits==5 || Digits==3) PointX = Point * 10;             // Êîððåêòèðîâêà Point ïîä òð¸õ- ïÿòèçíàê
   if(Digits==4 || Digits==2) PointX = Point;
   Exp_Name=WindowExpertName();                                // Èìÿ ýêñïåðòà
   Prefix=Exp_Name+"_M"+Period();                              // Ïðåôèêñ äëÿ èì¸í îáúåêòîâ
   Magic=GetMagic(Exp_Name+Symbol(),Period());                 // Ìàãèê îðäåðîâ
   NameGL_Equ=Prefix+"_GL_Equ";
   NameGL_Add=Prefix+"_GL_Add";
   NameGL_Bln=Prefix+"_GL_Bln";
   NameGL_BAdd=Prefix+"_GL_BAdd";
   if(!GlobalVariableCheck(NameGL_Equ)) {                      // Åñëè íåòó ãëîáàëüíîé ïåðåìåííîé òåðìèíàëà ñ èìåíåì NameGL_Equ
      EquStart=AccountEquity();                                // Ñòàðòîâûé ýêâèòè = ýêâèòè
      EquAdd=NormalizeDouble(EquStart/100*PercentEquityForClose,dg); // Ïðîöåíò îò ñðåäñòâ, íà êîòîðûé îíè äîëæíû óâåëè÷èòüñÿ äëÿ çàêðûòèÿ
      BlnStart=AccountBalance();
      BlnAdd=NormalizeDouble(BlnStart/100*PercentBalanceForClose,dg);
      GlobalVariableSet(NameGL_Equ,EquStart);                  // Ñîçäàäèì ãëîáàëüíóþ ïåðåìåííóþ òåðìèíàëà è ïðèñâîèì åé çíà÷åíèå ýêâèòè
      GlobalVariableSet(NameGL_Add,EquAdd);
      GlobalVariableSet(NameGL_Bln,BlnStart);                  // Ñîçäàäèì ãëîáàëüíóþ ïåðåìåííóþ òåðìèíàëà è ïðèñâîèì åé çíà÷åíèå áàëàíñà
      GlobalVariableSet(NameGL_BAdd,BlnAdd);
      }
   else {
      EquStart=GlobalVariableGet(NameGL_Equ);       // Åñëè ïåðåìåííàÿ òåðìèíàëà óæå åñòü, òî ñòàðòîâûé ýêâèòè = çíà÷åíèþ ýòîé ïåðåìåííîé
      EquAdd=GlobalVariableGet(NameGL_Add);
      BlnStart=GlobalVariableGet(NameGL_Bln);       // Åñëè ïåðåìåííàÿ òåðìèíàëà óæå åñòü, òî ñòàðòîâûé áàëàíñ = çíà÷åíèþ ýòîé ïåðåìåííîé
      BlnAdd=GlobalVariableGet(NameGL_BAdd);
      }
   p1=GlobalVariableGet(NameGL_Equ);
   p2=GlobalVariableGet(NameGL_Add);
   EquClose=NormalizeDouble(p1+p2,dg);
   p1=GlobalVariableGet(NameGL_Bln);
   p2=GlobalVariableGet(NameGL_BAdd);
   BlnClose=NormalizeDouble(p1+p2,dg);
   if (PercentEquityForClose<=0)  PercentEquityForClose=PointX;
   if (PercentBalanceForClose<=0) PercentBalanceForClose=PointX;
   if (NumberLossPoseForClose<=0) NumberLossPoseForClose=1;
   if (DistanceSetOrder<=0)       DistanceSetOrder=Level_old+1;
//==============================================================================
// ------------- Çàïîëíåíèå ìàññèâîâ äàííûìè î öåíîâûõ óðîâíÿõ ----------------+
//==============================================================================
   if (NumberUpLevels<2) NumberUpLevels=2;
   if (NumberDnLevels<2) NumberDnLevels=2;
   ArrayResize(MassUpLev, NumberUpLevels);                     // Óâåëè÷èì ðàçìåðû ìàññèâîâ ...
   ArrayResize(MassDnLev, NumberDnLevels);                     // ... ïîä êîëè÷åñòâî óðîâíåé
   ArrayInitialize(MassCtLev, 0);                              // Èíèöèàëèçèðóåì ìàññèâ íóëÿìè
   ArrayInitialize(MassUpLev, 0);                              // Èíèöèàëèçèðóåì ìàññèâ íóëÿìè
   ArrayInitialize(MassDnLev, 0);                              // Èíèöèàëèçèðóåì ìàññèâ íóëÿìè
   CenterLevel=pa;
   MassCtLev[0][0]=CenterLevel;
   SetLevels();
   return(0);
}
//==============================================================================
int deinit()                              // Ñïåö. ôóíêöèÿ deinit()
{
// -------- Áëîê óäàëåíèÿ âñåõ îáúåêòîâ, ïîñòðîåííûõ ñîâåòíèêîì íà ãðàôèêå --------
   string Name_Del[1]; 
   int Quant_Del=0;                    
   int Quant_Objects=ObjectsTotal();   
   int LenPref=StringLen(Prefix);
   ArrayResize(Name_Del,Quant_Objects);
   for(int k=0; k<Quant_Objects; k++) {
         string Obj_Name=ObjectName(k);   
         string Head=StringSubstr(Obj_Name,0,LenPref);
         if (Head==Prefix) {                              
               Quant_Del+=1;        
               Name_Del[Quant_Del-1]=Obj_Name;
            }
     }
   for(int i=0; i<Quant_Del; i++)    
      ObjectDelete(Name_Del[i]); 
// ----- Êîíåö áëîêà óäàëåíèÿ âñåõ îáúåêòîâ, ïîñòðîåííûõ ñîâåòíèêîì íà ãðàôèêå -----
   if (!IsTesting()) Comment("");                                 // Óäàëåíèå êîììåíòàðèåâ (íå ïðè îòëàäêå)
   else if (IsTesting())                                          // Åñëè â òåñòåðå, òî ...
      if(GlobalVariableCheck(NameGL_Equ)) {                       // ... åñëè åñòü ãëîáàëüíàÿ ïåðåìåííàÿ òåðìèíàëà ñ èìåíåì NameGL_Equ ...
         GlobalVariableDel(NameGL_Equ);                           // ... óäàëèì å¸
         GlobalVariableDel(NameGL_Add);
         }
   return;                                                        // Âûõîä èç deinit()
}
//==============================================================================
int start()
{
   int i;
   double p1, p2;
   tf=Period();
   sy=Symbol();
   pa=MarketInfo(sy,MODE_ASK);
   pb=MarketInfo(sy,MODE_BID);
   sp=MarketInfo(sy,MODE_SPREAD);
   Level_new=MarketInfo(sy,MODE_STOPLEVEL );                      // Ïîñëåäíåå ìèíèìàëüíîå çíà÷åíèå óðîâíÿ óñòàíîâêè ñòîïîâ
   if (Level_old!=Level_new) {                                    // Íîâîå íå ðàâíî ñòàðîìó, çíà÷èò èçìåíèëñÿ óðîâåíü
      Level_old=Level_new;                                        // Íîâîå "ñòàðîå çíà÷åíèå"
      if (DistanceSetOrder<=Level_new)       DistanceSetOrder=Level_new+1;
      }
   p1=GlobalVariableGet(NameGL_Equ);
   p2=GlobalVariableGet(NameGL_Add);
   EquClose=NormalizeDouble(p1+p2,dg);
   if (UseEquClose)
   if (AccountEquity()>=EquClose) {
      CloseLoss(NumberLossPoseForClose);
      EquStart=AccountEquity();
      GlobalVariableSet(NameGL_Equ,EquStart);
      }
   p1=GlobalVariableGet(NameGL_Bln);
   p2=GlobalVariableGet(NameGL_BAdd);
   BlnClose=NormalizeDouble(p1+p2,dg);
   if (UseBalanceClose)
   if (AccountBalance()>=BlnClose) {
      int NumberLossPose=0;
      double pr=0;
      for (i=0; i<OrdersTotal(); i++) {
         if (OrderSelect(i,SELECT_BY_POS)) {
            if (OrderMagicNumber()!=Magic)   continue;
            if (OrderSymbol()!=sy)           continue;
            if (OrderType()>1)               continue;
            if (OrderProfit()+OrderSwap()<pr) 
               ClosePosWithMaxLossInCurrency(sy, Magic);
            }
         }
      BlnStart=AccountBalance();
      BlnAdd=NormalizeDouble(BlnStart/100*PercentBalanceForClose,dg);
      GlobalVariableSet(NameGL_Bln,BlnStart);
      GlobalVariableSet(NameGL_BAdd,BlnAdd);
      }
//==============================================================================
// ------------------- Âûâîä äèñòàíöèé StopLevel íà ãðàôèê --------------------+
//==============================================================================
   color cl=FireBrick;
   string RectUP=Prefix+"_RectUp_StLevel";
   double pUP1=pa;
   double pUP2=NormalizeDouble(pa+Level_new*PointX,dg);
   SetRectangle(cl, RectUP, Time[3], pUP1, Time[0]+3*Period()*60, pUP2);
   string RectDN=Prefix+"_RectDn_StLevel";
   double pDN1=pb;
   double pDN2=NormalizeDouble(pb-Level_new*PointX,dg);
   SetRectangle(cl, RectDN, Time[3], pDN1, Time[0]+3*Period()*60, pDN2);
//==============================================================================
// ----------------- Îòñëåæèâàíèå óðîâíåé îòíîñèòåëüíî öåíû -------------------+
//==============================================================================
   if (pa>NormalizeDouble(CenterLevel+DistanceSetOrder*PointX,dg)) {
      CenterLevel=NormalizeDouble(CenterLevel+DistanceSetOrder*PointX,dg);
      MassCtLev[0][0]=CenterLevel;
      SetLevels();
      }
   if (pb<NormalizeDouble(CenterLevel-DistanceSetOrder*PointX,dg)) {
      CenterLevel=NormalizeDouble(CenterLevel-DistanceSetOrder*PointX,dg);
      MassCtLev[0][0]=CenterLevel;
      SetLevels();
      }
//==============================================================================
// ----------------- Ïðîâåðêà ïðèñóòñòâèÿ îðäåðîâ íà óðîâíÿõ-------------------+
//==============================================================================
   if (!ExistOrdersByPrice(Symbol(), -1, Magic, MassCtLev[0][0])) SetOrders(0, 0);
   for (i=0; i<MassUpLen; i++) {
      if (!ExistOrdersByPrice(Symbol(), -1, Magic, MassUpLev[i][0])) SetOrders(i, +1);
      }
   for (i=0; i<MassDnLen; i++) {
      if (!ExistOrdersByPrice(Symbol(), -1, Magic, MassDnLev[i][0])) SetOrders(i, -1);
      }
   informations();

   return(0);  // -------------------- Âûõîä èç start() -----------------------+
}

//==============================================================================
// --------------------------------- ÔÓÍÊÖÈÈ ----------------------------------+
//==============================================================================
//==============================================================================
// ---------------------------- Ôóíêöèè ñîâåòíèêà -----------------------------+
//==============================================================================
double SetOrders(int Lev, int Direction) {
   double Level, pp, tp, Res, sslev=NormalizeDouble((Level_new+sp)*PointX,dg);
   string co;
   if (Direction==0) {                                               // Åñëè ïðîâåðÿåì öåíòðàëüíûé óðîâåíü
      if (NormalizeDouble(pa-MassCtLev[0][0],dg)>sslev) {            // Åñëè Ask âûøå óðîâíÿ íà ðàçìåð ÑòîïËåâåë+ñïðåä, ...
         co=Prefix+"_BuyLimit_Öåíòðàëüíûé";
         pp=NormalizeDouble(MassCtLev[0][0],dg);
         tp=NormalizeDouble(pp+DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_BUYLIMIT, Lots, pp, 0, tp, Magic, co);
         Res=pp;
         co=Prefix+"_SellStop_Öåíòðàëüíûé";
         pp=NormalizeDouble(MassCtLev[0][0]-sp*PointX,dg);
         tp=NormalizeDouble(pp-DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_SELLSTOP, Lots, pp, 0, tp, Magic, co);
         }
      if (NormalizeDouble(MassCtLev[0][0]-pa,dg)>sslev) {            // Åñëè Ask íèæå óðîâíÿ íà ðàçìåð ÑòîïËåâåë+ñïðåä, ...
         co=Prefix+"_BuyStop_Öåíòðàëüíûé";
         pp=NormalizeDouble(MassCtLev[0][0],dg);
         tp=NormalizeDouble(pp+DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_BUYSTOP, Lots, pp, 0, tp, Magic, co);
         Res=pp;
         co=Prefix+"_SellLimit_Öåíòðàëüíûé";
         pp=NormalizeDouble(MassCtLev[0][0]-sp*PointX,dg);
         tp=NormalizeDouble(pp-DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_SELLLIMIT, Lots, pp, 0, tp, Magic, co);
         }
      }
   if (Direction>0) {                                                // Åñëè ïðîâåðÿåì âåðõíèå óðîâíè
      if (NormalizeDouble(pa-MassUpLev[Lev][0],dg)>sslev) {          // Åñëè Ask âûøå óðîâíÿ íà ðàçìåð ÑòîïËåâåë+ñïðåä, ...
         co=Prefix+"_BuyLimit_Óðîâåíü_"+Lev;
         pp=NormalizeDouble(MassUpLev[Lev][0],dg);
         tp=NormalizeDouble(pp+DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_BUYLIMIT, Lots, pp, 0, tp, Magic, co);
         Res=pp;
         co=Prefix+"_SellStop_Óðîâåíü_"+Lev;
         pp=NormalizeDouble(MassUpLev[Lev][0]-sp*PointX,dg);
         tp=NormalizeDouble(pp-DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_SELLSTOP, Lots, pp, 0, tp, Magic, co);
         }
      if (NormalizeDouble(MassUpLev[Lev][0]-pa,dg)>sslev) {          // Åñëè Ask íèæå óðîâíÿ íà ðàçìåð ÑòîïËåâåë+ñïðåä, ...
         co=Prefix+"_BuyStop_Óðîâåíü_"+Lev;
         pp=NormalizeDouble(MassUpLev[Lev][0],dg);
         tp=NormalizeDouble(pp+DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_BUYSTOP, Lots, pp, 0, tp, Magic, co);
         Res=pp;
         co=Prefix+"_SellLimit_Óðîâåíü_"+Lev;
         pp=NormalizeDouble(MassUpLev[Lev][0]-sp*PointX,dg);
         tp=NormalizeDouble(pp-DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_SELLLIMIT, Lots, pp, 0, tp, Magic, co);
         }
      }
   if (Direction<0) {                                                // Åñëè ïðîâåðÿåì íèæíèå óðîâíè
      if (NormalizeDouble(pa-MassDnLev[Lev][0],dg)>sslev) {          // Åñëè Ask âûøå óðîâíÿ íà ðàçìåð ÑòîïËåâåë+ñïðåä, ...
         co=Prefix+"_BuyLimit_Óðîâåíü_"+Lev;
         pp=NormalizeDouble(MassDnLev[Lev][0],dg);
         tp=NormalizeDouble(pp+DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_BUYLIMIT, Lots, pp, 0, tp, Magic, co);
         Res=pp;
         co=Prefix+"_SellStop_Óðîâåíü_"+Lev;
         pp=NormalizeDouble(MassDnLev[Lev][0]-sp*PointX,dg);
         tp=NormalizeDouble(pp-DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_SELLSTOP, Lots, pp, 0, tp, Magic, co);
         }
      if (NormalizeDouble(MassDnLev[Lev][0]-pa,dg)>sslev) {          // Åñëè Ask íèæå óðîâíÿ íà ðàçìåð ÑòîïËåâåë+ñïðåä, ...
         co=Prefix+"_BuyStop_Óðîâåíü_"+Lev;
         pp=NormalizeDouble(MassDnLev[Lev][0],dg);
         tp=NormalizeDouble(pp+DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_BUYSTOP, Lots, pp, 0, tp, Magic, co);
         Res=pp;
         co=Prefix+"_SellLimit_Óðîâåíü_"+Lev;
         pp=NormalizeDouble(MassDnLev[Lev][0]-sp*PointX,dg);
         tp=NormalizeDouble(pp-DistanceSetOrder*PointX,dg);
         SetOrder(sy, OP_SELLLIMIT, Lots, pp, 0, tp, Magic, co);
         }
      }
   return(Res);
}
//+----------------------------------------------------------------------------+
void SetLevels() {
   int i;
   double step, lev;
   MassCtLev[0][0]=CenterLevel;
   string NameLevelCT=Prefix+"_CenterLevel_";                  // Èìÿ öåíòðàëüíîé ëèíèè
   SetArrow(4, MediumSpringGreen, NameLevelCT, Time[0], CenterLevel, 0);
   
   for (i=0; i<NumberUpLevels; i++) {
      step=((i+1)*DistanceSetOrder)*PointX;                    // Øàã ïðèðàùåíèÿ öåíû
      lev=NormalizeDouble(MassCtLev[0][0]+step,dg);                // Öåíîâîå çíà÷åíèå i-ãî óðîâíÿ
      MassUpLev[i][0]=lev;                                     // Çàïîëíèì ìàññèâ
// -------------------- Âûâîä âåðõíèõ óðîâíåé íà ãðàôèê -----------------------+
      clUP=DeepSkyBlue;                                        // Öâåò âåðõíèõ óðîâíåé
      string NameLevelUP=Prefix+"_UpLevel_"+DoubleToStr(i,0);  // Èìÿ ëèíèè
      SetArrow(4, clUP, NameLevelUP, Time[0], lev, 0);         // Íàðèñóåì i-óðîâåíü
      }
   for (i=0; i<NumberDnLevels; i++) {
      step=((i+1)*DistanceSetOrder)*PointX;                    // Øàã ïðèðàùåíèÿ öåíû
      lev=NormalizeDouble(MassCtLev[0][0]-step,dg);                // Öåíîâîå çíà÷åíèå i-ãî óðîâíÿ
      MassDnLev[i][0]=lev;                                     // Çàïîëíèì ìàññèâ
// -------------------- Âûâîä íèæíèõ óðîâíåé íà ãðàôèê ------------------------+
      clDN=Gold;                                               // Öâåò íèæíèõ óðîâíåé
      string NameLevelDN=Prefix+"_DnLevel_"+DoubleToStr(i+1,0);// Èìÿ ëèíèè
      SetArrow(4, clDN, NameLevelDN, Time[0], lev, 0);         // Åãî íèç
      }
   MassUpLen=ArrayRange(MassUpLev,0);
   MassDnLen=ArrayRange(MassDnLev,0);
   HighestLev=MassUpLev[MassUpLen-1][0];
   LowestLev =MassDnLev[MassDnLen-1][0];
// -------------------- Óäàëåíèå ëèøíèõ êðàéíèõ îðäåðîâ ------------------------+
   bool fd;
   int  it, err;
   for (i=0; i<OrdersTotal(); i++) {
      if (OrderSelect(i, SELECT_BY_POS)) {
         if (OrderMagicNumber()!=Magic)   continue;
         if (OrderSymbol()!=sy)           continue;
         if (OrderType()>1 && OrderType()<6) {
            if (NormalizeDouble(OrderOpenPrice()-HighestLev+DistanceSetOrder*PointX,dg)>0 ||
                NormalizeDouble(LowestLev-DistanceSetOrder*PointX-OrderOpenPrice(),dg)>0) {
               for (it=1; it<=NumberOfTry; it++) {
                  if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
                  while (!IsTradeAllowed()) Sleep(5000);
                  fd=OrderDelete(OrderTicket(), clDelete);
                  if (fd) {
                     if (UseSound) PlaySound(SoundSuccess); break; 
                        } 
                  else {
                     err=GetLastError();
                     Print("Error(",err,") delete order ",GetNameOP(OrderType()), ": ",ErrorDescription(err),", try ",it);
                     Sleep(1000*5);
                     }
                  }
               }
            }
         }
      }
   return;
}
//+----------------------------------------------------------------------------+
void CloseLoss(int numLoss) {
   for (int i=0; i<numLoss; i++) ClosePosWithMaxLossInCurrency(sy, Magic);
}
//+----------------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
void informations() {
   string Text, nmEqu, font;
   color  cl;
   int    angle, xDist, yDist, size;
//+----------------------------------------------------------------------------+
   Text="Áàëàíñ ñ÷¸òà: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_Balance";
   angle=2; xDist=10; yDist=70;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(AccountBalance(),2); // ×èñëîâîå çíà÷åíèå áàëàíñà
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_AccBalance";
   angle=2; xDist=150; yDist=70;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
   Text="Ñâîáîäíûå ñðåäñòâà: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_Equity";
   angle=2; xDist=10; yDist=50;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(AccountEquity(),2); // ×èñëîâîå çíà÷åíèå ýêâèòè
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_AccEquity";
   angle=2; xDist=150; yDist=50;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
   Text="Óáûòî÷íûõ Buy: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_LossBuy";
   angle=2; xDist=10; yDist=10;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(NumLossPos(OP_BUY),0);
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_LossBuy";
   angle=2; xDist=150; yDist=10;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
   Text="Çàêðûòèå íà óðîâíå: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_CloseBalance";
   angle=2; xDist=220; yDist=70;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(BlnClose,2); // ×èñëîâîå çíà÷åíèå ýêâèòè
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_ClsBalance";
   angle=2; xDist=350; yDist=70;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
   Text="Çàêðûòèå íà óðîâíå: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_CloseEquity";
   angle=2; xDist=220; yDist=50;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(EquClose,2); // ×èñëîâîå çíà÷åíèå ýêâèòè
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_ClsEquity";
   angle=2; xDist=350; yDist=50;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
   Text="Óáûòî÷íûõ Sell: ";
   cl=LightBlue;
   nmEqu=Prefix+"_txt_LossSell";
   angle=2; xDist=220; yDist=10;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
   
   Text=DoubleToStr(NumLossPos(OP_SELL),0);
   cl=NavajoWhite;
   nmEqu=Prefix+"_num_LossSell";
   angle=2; xDist=350; yDist=10;
   font="Arial";
   size=10;
   SetText(Text, cl, nmEqu, angle, xDist, yDist, font, size);
//+----------------------------------------------------------------------------+
}
//==============================================================================
// ----------------------------- Òîðãîâûå ôóíêöèè -----------------------------+
//==============================================================================
void SetOrder(string sy, int op, double ll, double pp,
              double sl=0, double tp=0, int mn=0, string co="", datetime ex=0) {
  color    cl=IIFc(op==OP_BUYLIMIT || op==OP_BUYSTOP, clOpenBuy, clOpenSell);
  datetime ot;
  double   pa, pb, mp;
  int      err, it, ticket, msl;

  if (sy=="" || sy=="0") sy=Symbol();
  msl=MarketInfo(sy, MODE_STOPLEVEL);
  if (co=="") co=WindowExpertName()+" "+GetNameTF(Period());
  if (ex>0 && ex<TimeCurrent()) ex=0;
  for (it=1; it<=NumberOfTry; it++) {
    if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) {
      Print("SetOrder(): Îñòàíîâêà ðàáîòû ôóíêöèè");
      break;
    }
    while (!IsTradeAllowed()) Sleep(5000);
    RefreshRates();
    ot=TimeCurrent();
    ticket=OrderSend(sy, op, ll, pp, Slippage, sl, tp, co, mn, ex, cl);
    if (ticket>0) {
      if (UseSound) PlaySound(SoundSuccess); break;
    } else {
      err=GetLastError();
      if (err==128 || err==142 || err==143) {
        Sleep(1000*66);
        if (ExistOrders(sy, op, mn, ot)) {
          if (UseSound) PlaySound(SoundSuccess); break;
        }
        Print("Error(",err,") set order: ",ErrorDescription(err),", try ",it);
        continue;
      }
      if (UseSound) PlaySound(SoundError);
      mp=MarketInfo(sy, MODE_POINT);
      pa=MarketInfo(sy, MODE_ASK);
      pb=MarketInfo(sy, MODE_BID);
      if (pa==0 && pb==0) Message("SetOrder(): Ïðîâåðüòå â îáçîðå ðûíêà íàëè÷èå ñèìâîëà "+sy);
      Print("Error(",err,") set order: ",ErrorDescription(err),", try ",it);
      Print("Ask=",pa,"  Bid=",pb,"  sy=",sy,"  ll=",ll,"  op=",GetNameOP(op),
            "  pp=",pp,"  sl=",sl,"  tp=",tp,"  mn=",mn);
      // Íåïðàâèëüíûå ñòîïû
      if (err==130) {
        // Êîððåêòèðîâêà öåíîâûõ óðîâíåé
        if (modeSetOrders==1) {
          Sleep(1000*5.3);
          switch (op) {
            case OP_BUYLIMIT:
              if (pp>pa-msl*mp) pp=pa-msl*mp;
              if (sl>pp-(msl+1)*mp) sl=pp-(msl+1)*mp;
              if (tp>0 && tp<pp+(msl+1)*mp) tp=pp+(msl+1)*mp;
              break;
            case OP_BUYSTOP:
              if (pp<pa+(msl+1)*mp) pp=pa+(msl+1)*mp;
              if (sl>pp-(msl+1)*mp) sl=pp-(msl+1)*mp;
              if (tp>0 && tp<pp+(msl+1)*mp) tp=pp+(msl+1)*mp;
              break;
            case OP_SELLLIMIT:
              if (pp<pb+msl*mp) pp=pb+msl*mp;
              if (sl>0 && sl<pp+(msl+1)*mp) sl=pp+(msl+1)*mp;
              if (tp>pp-(msl+1)*mp) tp=pp-(msl+1)*mp;
              break;
            case OP_SELLSTOP:
              if (pp>pb-msl*mp) pp=pb-msl*mp;
              if (sl>0 && sl<pp+(msl+1)*mp) sl=pp+(msl+1)*mp;
              if (tp>pp-(msl+1)*mp) tp=pp-(msl+1)*mp;
              break;
          }
          Print("SetOrder(): Ñêîððåêòèðîâàíû öåíîâûå óðîâíè");
          continue;
        }
        // Âõîä ïî òåêóùèì öåíàì
        if (modeSetOrders==2) {
          Print("SetOrder(): Âõîä ïî òåêóùèì öåíàì");
          if (op==OP_BUYLIMIT || op==OP_BUYSTOP) OpenPosition(sy, OP_BUY, ll, sl, tp, mn, co);
          if (op==OP_SELLLIMIT || op==OP_SELLSTOP) OpenPosition(sy, OP_SELL, ll, sl, tp, mn, co);
          break;
        }
      }
      // Áëîêèðîâêà ðàáîòû ñîâåòíèêà
      if (err==2 || err==64 || err==65 || err==133) {
        gbDisabled=True; break;
      }
      // Äëèòåëüíàÿ ïàóçà
      if (err==4 || err==131 || err==132) {
        Sleep(1000*300); break;
      }
      // Ñëèøêîì ÷àñòûå çàïðîñû (8) èëè ñëèøêîì ìíîãî çàïðîñîâ (141)
      if (err==8 || err==141) Sleep(1000*100);
      if (err==139 || err==140 || err==148) break;
      // Îæèäàíèå îñâîáîæäåíèÿ ïîäñèñòåìû òîðãîâëè
      if (err==146) while (IsTradeContextBusy()) Sleep(1000*11);
      // Îáíóëåíèå äàòû èñòå÷åíèÿ
      if (err==147) {
        ex=0; continue;
      }
      if (err!=135 && err!=138) Sleep(1000*7.7);
    }
  }
}
//+----------------------------------------------------------------------------+
void OpenPosition(string sy, int op, double ll, double sl=0, double tp=0, int mn=0, string co="") {
  color    clOpen;
  datetime ot;
  double   pp, pa, pb;
  int      dg, err, it, ticket=0;

  if (sy=="" || sy=="0") sy=Symbol();
  if (op==OP_BUY) clOpen=clOpenBuy; else clOpen=clOpenSell;
  if (co=="") co=WindowExpertName()+" "+GetNameTF(Period());
  for (it=1; it<=NumberOfTry; it++) {
    if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) {
      Print("OpenPosition(): Function stopped");
      break;
    }
    while (!IsTradeAllowed()) Sleep(5000); //Sleep_RND(5000);
    RefreshRates();
    dg=MarketInfo(sy, MODE_DIGITS);
    pa=MarketInfo(sy, MODE_ASK);
    pb=MarketInfo(sy, MODE_BID);
    if (op==OP_BUY) pp=pa; else pp=pb;
    pp=NormalizeDouble(pp, dg);
    ot=TimeCurrent();
    if (MarketWatch)
      ticket=OrderSend(sy, op, ll, pp, Slippage, 0, 0, co, mn, 0, clOpen);
    else
      ticket=OrderSend(sy, op, ll, pp, Slippage, sl, tp, co, mn, 0, clOpen);
    if (ticket>0) {
      if (UseSound) PlaySound(SoundSuccess); break;
    } else {
      err=GetLastError();
      if (UseSound) PlaySound(SoundError);
      if (pa==0 && pb==0) Message("Check in the MarketWatch presence of the symbol "+sy);
      // Âûâîä ñîîáùåíèÿ îá îøèáêå
      Print("Error(",err,") opening position: ",ErrorDescription(err),", try ",it);
      Print("Ask=",pa," Bid=",pb," sy=",sy," ll=",ll," op=",GetNameOP(op),
            " pp=",pp," sl=",sl," tp=",tp," mn=",mn);
      // Áëîêèðîâêà ðàáîòû ñîâåòíèêà
      if (err==2  ||                // Îáùàÿ îøèáêà
          err==64 ||                // Ñ÷åò çàáëîêèðîâàí
          err==65 ||                // Íåïðàâèëüíûé íîìåð ñ÷åòà
          err==133)                 // Òîðãîâëÿ çàïðåùåíà
          {
        gbDisabled=True; break;     // Îòêëþ÷åíèå ñîâåòíèêà
      }
      // Äëèòåëüíàÿ ïàóçà
      if (err==4   ||               // Òîðãîâûé ñåðâåð çàíÿò
          err==131 ||               // Íåïðàâèëüíûé îáúåì
          err==132)                 // Ðûíîê çàêðûò
          {
        Sleep(1000*300); break; // Sleep_RND(1000*300);
      }
      if (err==128 ||               // Èñòåê ñðîê îæèäàíèÿ ñîâåðøåíèÿ ñäåëêè
          err==142 ||               // Îðäåð ïîñòàâëåí â î÷åðåäü
          err==143)                 // Îðäåð ïðèíÿò äèëåðîì ê èñïîëíåíèþ
          {
        Sleep(1000*66.666); // Sleep_RND(1000*66.666);
        if (ExistPositions(sy, op, mn, ot)) {
          if (UseSound) PlaySound(SoundSuccess); break;
        }
      }
      if (err==140  ||              // Ðàçðåøåíà òîëüêî ïîêóïêà
          err==148  ||              // Êîëè÷åñòâî îòêðûòûõ è îòëîæåííûõ îðäåðîâ äîñòèãëî ïðåäåëà, óñòàíîâëåííîãî áðîêåðîì
          err==4110 ||              // Äëèííûå ïîçèöèè íå ðàçðåøåíû. Íåîáõîäèìî ïðîâåðèòü ñâîéñòâà ýêñïåðòà
          err==4111)                // Êîðîòêèå ïîçèöèè íå ðàçðåøåíû. Íåîáõîäèìî ïðîâåðèòü ñâîéñòâà ýêñïåðòà
          break;
      if (err==141) /*Sleep(1000*100);*/ Sleep_RND(1000*100); // Ñëèøêîì ìíîãî çàïðîñîâ
      if (err==145) /*Sleep(1000*17);*/  Sleep_RND(1000*17);  // Ìîäèôèêàöèÿ çàïðåùåíà, òàê êàê îðäåð ñëèøêîì áëèçîê ê ðûíêó
      if (err==146) while (IsTradeContextBusy()) /*Sleep(1000*11);*/ Sleep_RND(1000*11);  // Ïîäñèñòåìà òîðãîâëè çàíÿòà
      if (err!=135) /*Sleep(1000*7.7);*/ Sleep_RND(1000*7.7);                             // Öåíà èçìåíèëàñü
    }
  }
  if (MarketWatch && ticket>0 && (sl>0 || tp>0)) {
    if (OrderSelect(ticket, SELECT_BY_TICKET)) ModifyOrder(-1, sl, tp);
  }
}
//+----------------------------------------------------------------------------+
void ModifyOrder(double pp=-1, double sl=0, double tp=0, datetime ex=0,color cl=CLR_NONE) {
  bool   fm;
              cl=IIFc(OrderType()==OP_BUY
              || OrderType()==OP_BUYLIMIT
              || OrderType()==OP_BUYSTOP, clModifyBuy, clModifySell);
  double op, pa, pb, os, ot;
  int    dg=MarketInfo(OrderSymbol(), MODE_DIGITS), er, it;

  if (pp<=0) pp=OrderOpenPrice();
  if (sl<0 ) sl=OrderStopLoss();
  if (tp<0 ) tp=OrderTakeProfit();
  
  pp=NormalizeDouble(pp, dg);
  sl=NormalizeDouble(sl, dg);
  tp=NormalizeDouble(tp, dg);
  op=NormalizeDouble(OrderOpenPrice() , dg);
  os=NormalizeDouble(OrderStopLoss()  , dg);
  ot=NormalizeDouble(OrderTakeProfit(), dg);

  if (pp!=op || sl!=os || tp!=ot) {
    for (it=1; it<=NumberOfTry; it++) {
      if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
      while (!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      fm=OrderModify(OrderTicket(), pp, sl, tp, ex, cl);
      if (fm) {
        if (UseSound) PlaySound(SoundSuccess); break;
      } else {
        er=GetLastError();
        if (UseSound) PlaySound(SoundError);
        pa=MarketInfo(OrderSymbol(), MODE_ASK);
        pb=MarketInfo(OrderSymbol(), MODE_BID);
        Print("Error(",er,") modifying order: ",ErrorDescription(er),", try ",it);
        Print("Ask=",pa,"  Bid=",pb,"  sy=",OrderSymbol(),
              "  op="+GetNameOP(OrderType()),"  pp=",pp,"  sl=",sl,"  tp=",tp);
        Sleep(1000*10);
      }
    }
  }
}
//+----------------------------------------------------------------------------+
void ClosePosWithMaxLossInCurrency(string sy="", int mn=-1) {
   double pr=0;
   int    i, k=OrdersTotal(), np=-1;

   for (i=k-1; i>=0; i--) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
         if (OrderSymbol()!=sy)        continue;
         if (OrderType()>1)            continue;
         if (OrderMagicNumber()!=mn)   continue;
         if (pr>OrderProfit()+OrderSwap()) {
            pr=OrderProfit()+OrderSwap();
            np=i;
            }
         }
      }
   if (np>=0) {
      if (OrderSelect(np, SELECT_BY_POS, MODE_TRADES)) {
         ClosePosBySelect();
         }
      }
   return;
}
//+----------------------------------------------------------------------------+
void ClosePosBySelect() {
  bool   fc;
  color  clClose;
  double ll, pa, pb, pp;
  int    err, it;

  if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
    for (it=1; it<=NumberOfTry; it++) {
      if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
      while (!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      pa=MarketInfo(OrderSymbol(), MODE_ASK);
      pb=MarketInfo(OrderSymbol(), MODE_BID);
      if (OrderType()==OP_BUY) {
        pp=pb; clClose=clCloseBuy;
      } else {
        pp=pa; clClose=clCloseSell;
      }
      ll=OrderLots();
      fc=OrderClose(OrderTicket(), ll, NormalizeDouble(pp,dg), Slippage, clClose);
      if (fc) {
        if (UseSound) PlaySound(SoundSuccess); break;
      } else {
        err=GetLastError();
        if (err==146) while (IsTradeContextBusy()) Sleep(1000*11);
        Print("Error(",err,") Close ",GetNameOP(OrderType())," ",
              ErrorDescription(err),", try ",it);
        Print(OrderTicket(),"  Ask=",pa,"  Bid=",pb,"  pp=",pp);
        Print("sy=",OrderSymbol(),"  ll=",ll,"  sl=",OrderStopLoss(),
              "  tp=",OrderTakeProfit(),"  mn=",OrderMagicNumber());
        Sleep(1000*5);
      }
    }
  } else Print("Íåêîððåêòíàÿ òîðãîâàÿ îïåðàöèÿ. Close ",GetNameOP(OrderType()));
}
//==============================================================================
// ------------------------- Âñïîìîãàòåëüíûå ôóíêöèè --------------------------+
//==============================================================================
void Sleep_RND(int _Pausa)
  {
   MathSrand(TimeLocal());
   MathRand();
   Sleep(MathRound(_Pausa*MathRand()/32767+_Pausa/5));
   return;
  }
//+----------------------------------------------------------------------------+
color IIFc(bool condition, color ifTrue, color ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}
//+----------------------------------------------------------------------------+
string GetNameTF(int TimeFrame=0) {
  if (TimeFrame==0) TimeFrame=Period();
  switch (TimeFrame) {
    case PERIOD_M1:  return("M1");
    case PERIOD_M5:  return("M5");
    case PERIOD_M15: return("M15");
    case PERIOD_M30: return("M30");
    case PERIOD_H1:  return("H1");
    case PERIOD_H4:  return("H4");
    case PERIOD_D1:  return("Daily");
    case PERIOD_W1:  return("Weekly");
    case PERIOD_MN1: return("Monthly");
    default:         return("UnknownPeriod");
  }
}
//+----------------------------------------------------------------------------+
void Message(string m) 
{
   static string prevMessage="";
   Comment(m);
   if (StringLen(m)>0 && PrintEnable) {
      if (AllMessages || prevMessage!=m) {
         prevMessage=m;
         Print(m);
         }
      }
}
//+----------------------------------------------------------------------------+
string GetNameOP(int op) 
{
   switch (op) {
      case OP_BUY      : return("Buy");
      case OP_SELL     : return("Sell");
      case OP_BUYLIMIT : return("Buy Limit");
      case OP_SELLLIMIT: return("Sell Limit");
      case OP_BUYSTOP  : return("Buy Stop");
      case OP_SELLSTOP : return("Sell Stop");
      default          : return("Unknown Operation");
      }
}
//+----------------------------------------------------------------------------+
int GetMagic(string symbolstring, int multiplier) {
   int res=0;
   int len=StringLen(symbolstring);
   for(int i=0; i<len; i++)
       res+=StringGetChar(symbolstring,i);      
   return(res*multiplier);
}
//==============================================================================
// ------------------------ Ôóíêöèè äëÿ ïîèñêà äàííûõ--------------------------+
//==============================================================================
int NumLossPos(int type) {
   int    numloss=0;
   for (int i=0; i<OrdersTotal(); i++) {
      if (OrderSelect(i, SELECT_BY_POS)) {
         if (OrderType()!=type)           continue;
         if (OrderSymbol()!=sy)           continue;
         if (OrderMagicNumber()!=Magic)   continue;
         if (OrderProfit()+OrderSwap()+OrderCommission()<0) numloss++;
         }
      }
   return(numloss);
}
//+----------------------------------------------------------------------------+
bool ExistOrders(string sy="", int op=-1, int mn=-1, datetime ot=0) {
  int i, k=OrdersTotal(), ty;
 
  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      ty=OrderType();
      if (ty>1 && ty<6) {
        if ((OrderSymbol()==sy || sy=="") && (op<0 || ty==op)) {
          if (mn<0 || OrderMagicNumber()==mn) {
            if (ot<=OrderOpenTime()) return(True);
          }
        }
      }
    }
  }
  return(False);
}
//+----------------------------------------------------------------------------+
bool ExistPositions(string sy="", int op=-1, int mn=-1, datetime ot=0) 
{
   int i, k=OrdersTotal();
   if (sy=="0") sy=Symbol();
   for (i=0; i<k; i++) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
         if (OrderSymbol()!=sy)        continue;
         if (OrderType()!=op)          continue;
         if (OrderMagicNumber()!=mn)   continue;
         if (ot<=OrderOpenTime()) return(True);
         }
      }
  return(False);
}
//+----------------------------------------------------------------------------+
bool ExistOrdersByPrice(string sy="", int op=-1, int mn=-1, double pp=-1) {
   int d, i, k=OrdersTotal();

   for (i=0; i<k; i++) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
         if (OrderSymbol()!=sy)        continue;
         if (OrderMagicNumber()!=mn)   continue;
         if (OrderType()>=0 && OrderType()<6) {
            d=MarketInfo(OrderSymbol(), MODE_DIGITS);
            pp=NormalizeDouble(pp, d);
            if (pp==NormalizeDouble(OrderOpenPrice(), d)) return(True);
            }
         }
      }
   return(False);
}
//==============================================================================
// --------------------------- Ãðàôè÷åñêèå ôóíêöèè ----------------------------+
//==============================================================================
void SetArrow(int cd, color cl, string nm="", datetime t1=0, double p1=0, int sz=0) {
   if (nm=="") nm=DoubleToStr(Time[0], 0);
   if (t1<=0) t1=Time[0];
   if (p1<=0) p1=Bid;
   if (ObjectFind(nm)<0) ObjectCreate(nm, OBJ_ARROW, 0, 0, 0);
   ObjectSet(nm, OBJPROP_TIME1    , t1);
   ObjectSet(nm, OBJPROP_PRICE1   , p1);
   ObjectSet(nm, OBJPROP_ARROWCODE, cd);
   ObjectSet(nm, OBJPROP_COLOR    , cl);
   ObjectSet(nm, OBJPROP_WIDTH    , sz);
}
//+----------------------------------------------------------------------------+
void SetRectangle(color cl, string nm="", datetime t1=0, double p1=0, datetime t2=0, double p2=0, int sz=0) {
   if (nm=="") nm=DoubleToStr(Time[0], 0);
   if (t1<=0) t1=Time[10];
   if (p1<=0) p1=Ask;
   if (t2<=0) t2=Time[0];
   if (p2<=0) p2=Ask+Level_new*PointX;
   if (ObjectFind(nm)<0) ObjectCreate(nm, OBJ_RECTANGLE, 0, 0, 0, 0, 0);
   ObjectSet(nm, OBJPROP_TIME1    , t1);
   ObjectSet(nm, OBJPROP_PRICE1   , p1);
   ObjectSet(nm, OBJPROP_TIME2    , t2);
   ObjectSet(nm, OBJPROP_PRICE2   , p2);
   ObjectSet(nm, OBJPROP_COLOR    , cl);
   ObjectSet(nm, OBJPROP_WIDTH    , sz);
}
//+----------------------------------------------------------------------------+
void SetText(string Text, color cl, string nm, int angle, int x, int y, string font, int sz=0) {
   if (ObjectFind(nm)<0) ObjectCreate(nm, OBJ_LABEL, 0, 0, 0);
   ObjectSet(nm, OBJPROP_CORNER   , angle);
   ObjectSet(nm, OBJPROP_XDISTANCE, x);
   ObjectSet(nm, OBJPROP_YDISTANCE, y);
   ObjectSet(nm, OBJPROP_WIDTH    , sz);
   ObjectSetText(nm, Text, sz, font, cl);
   }
//+----------------------------------------------------------------------------+