Market_Capture_v9_08

//-----------------------------------------------------------------------------+
//                   Programming by
#property copyright "Copyright © 2010, Trishkin Artyom A."
#property link      "support@goldsuccess.ru"
//                   Skype: Artmedia70
//-----------------------------------------------------------------------------+
#include <stdlib.mqh>
#include <stderror.mqh>
#include <WinUser32.mqh>
//==============================================================================
// --------------------------- Ïåðåìåííûå ñîâåòíèêà ---------------------------+
//==============================================================================
extern string P_Expert= "-- Experts Variables --";
extern double Lots=0.1;                                        // Ëîò
extern int    CloseProfit=700;                                 // Ðàçìåð TakeProfit â ïóíêòàõ
extern int    DeltaOpenPositions=50;                           // Äèñòàíöèÿ îòêðûòèÿ ïîçèöèé â ïï
extern int    DeltaStopPositions=30;                           // Äèñòàíöèÿ ñòîïà ïîçèöèé â ïï
//------- Ïàðàìåòðû èñïîëíåíèÿ òîðãîâûõ ïðèêàçîâ ------------------------------+
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;
string   Prefix, Exp_Name;
string   sy;
double   pa, pb, GL_Max_new, GL_Max_old, GL_Min_new, GL_Min_old;
double   LevelB, LevelS, StopB, StopS, PointX;
bool     FirstStart  =  true;
bool     WaitSigB    =  false,
         WaitSigS    =  false,
         ReadyTradeB =  false,
         ReadyTradeS =  false,
         WriteWSB    =  false,
         WriteWSS    =  false,
         WriteRTB    =  false,
         WriteRTS    =  false;
//==============================================================================
//---------------------- Ïåðåìåííûå äëÿ ôóíêöèé--------------------------------+
//==============================================================================
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()
{
   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+"_"+GetNameTF(Period());                    // Ïðåôèêñ äëÿ èì¸í îáúåêòîâ
   Magic=GetMagic(Exp_Name+Symbol(),Period());                 // Ìàãèê îðäåðîâ
//==============================================================================
// ---------------- Ïîèñê èñòîðè÷åñêîãî ìèíèìóìà è ìàêñèìóìà ------------------+
//==============================================================================
   GL_Max_old=iHigh(sy,PERIOD_MN1,iHighest(sy,PERIOD_MN1,MODE_HIGH));
   GL_Min_old=iLow (sy,PERIOD_MN1, iLowest(sy,PERIOD_MN1,MODE_LOW));
   Print("Èñòîðè÷åñêèé ìèíèìóì = ",GL_Min_old,"; Èñòîðè÷åñêèé ìàêñèìóì = ",GL_Max_old);
   DeltaStopPositions=MathAbs(DeltaStopPositions);
// -----------------------------------------------------------------------------   
   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("");                                 // Óäàëåíèå êîììåíòàðèåâ (íå ïðè îòëàäêå)
   return;                                                        // Âûõîä èç deinit()
}
//==============================================================================
int start()
{
   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 (CloseProfit<=Level_new) CloseProfit=Level_new+1;
//==============================================================================
// --------- Îïðåäåëåíèå óðîâíåé ïîêóïêè è ïðîäàæè ïðè ïåðâîì ñòàðòå ----------+
//==============================================================================
   color  cl;
   string nm, co;
   double sl;
   if (FirstStart) {
      GL_Max_new=iHigh(sy,PERIOD_MN1,iHighest(sy,PERIOD_MN1,MODE_HIGH));
      GL_Min_new=iLow (sy,PERIOD_MN1, iLowest(sy,PERIOD_MN1,MODE_LOW));
      GL_Max_old=GL_Max_new;
      GL_Min_old=GL_Min_new;
      SetLevels();
      if (pa<LevelB) {
         ReadyTradeB=true; 
//         ReadyTradeS=false;
         }
      if (pb>LevelS) {
         ReadyTradeS=true; 
//         ReadyTradeB=false;
         }
      if (ReadyTradeB) 
      if (pa>=LevelB) {
         sl=StopB;
         co="Ïåðâûé ñòàðò: Buy îò óðîâíÿ_"+DoubleToStr(LevelB,dg);
         if (!ExistPositions(sy, OP_BUY, Magic)) {
            Print("Ïåðâûé ñòàðò: Ask âûøå óðîâíÿ ",DoubleToStr(LevelB,dg), ", ïîêóïàåì");
            OpenPosition(sy, OP_BUY, Lots, sl, 0, Magic, co);
            if (ExistPositions(sy, OP_BUY, Magic)) {
               WaitSigB=true;
               WaitSigS=true;
               ReadyTradeB=false;
               FirstStart=false;
               }
            }
         }
      if (ReadyTradeS) 
      if (pb<=LevelS) {
         sl=StopS;
         co="Ïåðâûé ñòàðò: Sell îò óðîâíÿ_"+DoubleToStr(LevelS,dg);
         if (!ExistPositions(sy, OP_SELL, Magic)) {
            Print("Ïåðâûé ñòàðò: Bid íèæå óðîâíÿ ",DoubleToStr(LevelS,dg), ", ïðîäà¸ì");
            OpenPosition(sy, OP_SELL, Lots, sl, 0, Magic, co);
            if (ExistPositions(sy, OP_SELL, Magic)) {
               WaitSigS=true;
               WaitSigB=true;
               ReadyTradeS=false;
               FirstStart=false;
               }
            }
         }
      }
   if (FirstStart) return(0);
//==============================================================================
// ----------------- Îòñëåæèâàíèå öåíû îòíîñèòåëüíî óðîâíåé -------------------+
//==============================================================================
   if (pb>GL_Max_new) {
      WaitSigS=true;
//      WaitSigB=false;
      if (!WriteWSB) {
         if (!ExistPositions(sy, OP_SELL, Magic))
            Print("Öåíà âûøå ìàêñèìàëüíîãî óðîâíÿ ",DoubleToStr(GL_Max_new,dg),", æä¸ì ñèãíàëà íà ïðîäàæó");
         else Print("Öåíà âûøå ìàêñèìàëüíîãî óðîâíÿ ",DoubleToStr(GL_Max_new,dg),", ñëåäóþùàÿ ïîçèöèÿ Sell áóäåò îòêðûòà ïîñëå äîñòèæåíèÿ öåíîé íîâîãî ìàêñèìàëüíîãî óðîâíÿ");
         WriteWSB=true;
         WriteWSS=false;
         }
      }
   if (pa<GL_Min_new) {
      WaitSigB=true;
//      WaitSigS=false;
      if (!WriteWSS) {
         if (!ExistPositions(sy, OP_BUY, Magic))
            Print("Öåíà íèæå ìèíèìàëüíîãî óðîâíÿ ",DoubleToStr(GL_Min_new,dg),", æä¸ì ñèãíàëà íà ïîêóïêó");
         else Print("Öåíà íèæå ìèíèìàëüíîãî óðîâíÿ ",DoubleToStr(GL_Min_new,dg),", ñëåäóþùàÿ ïîçèöèÿ Buy áóäåò îòêðûòà ïîñëå äîñòèæåíèÿ öåíîé íîâîãî ìèíèìàëüíîãî óðîâíÿ");
         WriteWSS=true;
         WriteWSB=false;
         }
      }
   //--------------------------------   
   if (WaitSigB) 
   if (pa<LevelB) {
      ReadyTradeB=true; 
//      ReadyTradeS=false;
      if (!WriteRTB) Print("Ãîòîâû ê ïîêóïêå, æä¸ì ïåðåñå÷åíèÿ óðîâíÿ ",DoubleToStr(LevelB,dg));
      WriteRTB=true;
      WriteRTS=false;
      }
   if (WaitSigS) 
   if (pb>LevelS) {
      ReadyTradeS=true;
//      ReadyTradeB=false;
      if (!WriteRTS) Print("Ãîòîâû ê ïðîäàæå, æä¸ì ïåðåñå÷åíèÿ óðîâíÿ ",DoubleToStr(LevelS,dg));
      WriteRTS=true;
      WriteRTB=false;
      }
   //--------------------------------   
   if (ReadyTradeB) 
   if (pa>=LevelB) {
      sl=StopB;
      co="Buy îò óðîâíÿ_"+DoubleToStr(LevelB,dg);
      if (!ExistPositions(sy, OP_BUY, Magic)) {
         Print("Ask âûøå óðîâíÿ ",DoubleToStr(LevelB,dg), ", ïîêóïàåì");
         OpenPosition(sy, OP_BUY, Lots, sl, 0, Magic, co);
         }
      }
   if (ReadyTradeS) 
   if (pb<=LevelS) {
      sl=StopS;
      co="Sell îò óðîâíÿ_"+DoubleToStr(LevelS,dg);
      if (!ExistPositions(sy, OP_SELL, Magic)) {
         Print("Bid íèæå óðîâíÿ ",DoubleToStr(LevelS,dg), ", ïðîäà¸ì");
         OpenPosition(sy, OP_SELL, Lots, sl, 0, Magic, co);
         }
      }
//==============================================================================
// ------------------ Îòñëåæèâàíèå ïðîôèòà îòêðûòûõ ïîçèöèé -------------------+
//==============================================================================
   int i, pr=0;
   for (i=0; i<OrdersTotal(); i++) {
      if (OrderSelect(i,SELECT_BY_POS)) {
         if (OrderMagicNumber()!=Magic)   continue;
         if (OrderType()>1)               continue;
         if (OrderSymbol()!=sy)           continue;
         double p=MarketInfo(OrderSymbol(), MODE_POINT);
         if (OrderType()==OP_BUY)  {
            pr=(MarketInfo(OrderSymbol(), MODE_BID)-OrderOpenPrice())/p;
            if (pr>=CloseProfit) {
               Print("Ïîçèöèÿ Buy ñ òèêåòîì, ",OrderTicket()," äîñòèãëà çàäàííîé ïðèáûëè â ",CloseProfit," ïóíêòîâ, çàêðûâàåì å¸");
               ClosePosBySelect();
               if (!ExistPositions(sy, OP_BUY, Magic)) {
                  WaitSigB=true;
                  GL_Min_new=iLow (sy,PERIOD_MN1, iLowest(sy,PERIOD_MN1,MODE_LOW));
                  if (GL_Min_new!=GL_Min_old) {
                     Print("Ìèíèìàëüíûé óðîâåíü èçìåíèëñÿ, áûë ",GL_Min_old,", ñòàë ",GL_Min_new, ", äëÿ îòêðûòèÿ Buy áóäåì æäàòü ïåðåñå÷åíèÿ ýòîãî óðîâíÿ");
                     SetLevels();
                     GL_Min_old=GL_Min_new;
                     WaitSigB=false;
                     }
                  ReadyTradeB=false;
                  WriteWSB=false;
                  WriteRTB=false;
                  }
               }
            }
         if (OrderType()==OP_SELL) {
            pr=(OrderOpenPrice()-MarketInfo(OrderSymbol(), MODE_ASK))/p;
            if (pr>=CloseProfit) {
               Print("Ïîçèöèÿ Sell ñ òèêåòîì, ",OrderTicket()," äîñòèãëà çàäàííîé ïðèáûëè â ",CloseProfit," ïóíêòîâ, çàêðûâàåì å¸");
               ClosePosBySelect();
               if (!ExistPositions(sy, OP_SELL, Magic)) {
                  WaitSigS=true;
                  GL_Max_new=iHigh(sy,PERIOD_MN1,iHighest(sy,PERIOD_MN1,MODE_HIGH));
                  if (GL_Max_new!=GL_Max_old) {
                     Print("Ìàêñèìàëüíûé óðîâåíü èçìåíèëñÿ, áûë ",GL_Max_old,", ñòàë ",GL_Max_new, ", äëÿ îòêðûòèÿ Sell áóäåì æäàòü ïåðåñå÷åíèÿ ýòîãî óðîâíÿ");
                     SetLevels();
                     GL_Max_old=GL_Max_new;
                     WaitSigS=false;
                     }
                  ReadyTradeS=false;
                  WriteWSS=false;
                  WriteRTS=false;
                  }
               }
            }
         }
      }
   //--------------------------------   

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

//==============================================================================
// --------------------------------- ÔÓÍÊÖÈÈ ----------------------------------+
//==============================================================================
//==============================================================================
// ---------------------------- Ôóíêöèè ñîâåòíèêà -----------------------------+
//==============================================================================
void SetLevels() {
   color  cl;
   string nm;
   cl=LightSkyBlue;
   nm=Prefix+"_HighestLevel";
   SetHLine(cl, nm, GL_Max_new);
   cl=Goldenrod;
   nm=Prefix+"_LowestLevel";
   SetHLine(cl, nm, GL_Min_new);
   //--------------------------------   
   LevelB=NormalizeDouble(GL_Min_new+DeltaOpenPositions*PointX,dg);
   LevelS=NormalizeDouble(GL_Max_new-DeltaOpenPositions*PointX,dg);
   StopB =NormalizeDouble(GL_Min_new-DeltaStopPositions*PointX,dg);
   StopS =NormalizeDouble(GL_Max_new+DeltaStopPositions*PointX,dg);
   if (LevelB-Level_new*PointX<=StopB) StopB=NormalizeDouble(LevelB-(Level_new+1)*PointX,dg);
   if (LevelS+Level_new*PointX>=StopS) StopS=NormalizeDouble(LevelS+(Level_new+1)*PointX,dg);
   //--------------------------------   
   cl=Chartreuse;
   nm=Prefix+"_LevelForBuy";
   SetHLine(cl, nm, LevelB, 2);
   cl=Gold;
   nm=Prefix+"_LevelForSell";
   SetHLine(cl, nm, LevelS, 2);
   //--------------------------------   
   cl=Red;
   nm=Prefix+"_LevelStopBuy";
   SetHLine(cl, nm, StopB, 1);
   cl=Red;
   nm=Prefix+"_LevelStopSell";
   SetHLine(cl, nm, StopS, 1);
   return;
}
//==============================================================================
// ----------------------------- Òîðãîâûå ôóíêöèè -----------------------------+
//==============================================================================
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 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);
}
//==============================================================================
// ------------------------ Ôóíêöèè äëÿ ïîèñêà äàííûõ--------------------------+
//==============================================================================
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);
}
//==============================================================================
// --------------------------- Ãðàôè÷åñêèå ôóíêöèè ----------------------------+
//==============================================================================
void SetHLine(color cl, string nm="", double p1=0, int st=0, int wd=1) {
  if (ObjectFind(nm)<0) ObjectCreate(nm, OBJ_HLINE, 0, 0,0);
  ObjectSet(nm, OBJPROP_PRICE1, p1);
  ObjectSet(nm, OBJPROP_COLOR , cl);
  ObjectSet(nm, OBJPROP_STYLE , st);
  ObjectSet(nm, OBJPROP_WIDTH , wd);
}
//+----------------------------------------------------------------------------+