Gena v2.4

//+------------------------------------------------------------------------------+
//|                                                                     Gena.mq4 |
//|                                                    Copyright © 2009 gorby777 |
//|                                                      gorby_e-mail@rambler.ru |
//|Îñîáîå ÑÏÀÑÈÁÎ Êèìó Èãîðþ Â. (aka KimIV,  http://www.kimiv.ru) çà åãî ôóíêöèè |
//+------------------------------------------------------------------------------+
#property copyright "Copyright © 2009 gorby777"
#property link      "gorby_e-mail@rambler.ru"

extern int     Hour_          =  0;                // ×àñ íà÷àëà òîðãîâëè
extern int     Delta          =  20;               // Óðîâåíü îò áàçîâîé öåíû äî öåíû îòêðûòèÿ îòëîæåííèêà
extern double  xD             =  1;                // Êîýôô. ê Delta äëÿ òðàëà
extern int     TakeProfit     =  70;              // È òàê ïîíÿòíî
extern bool    MM             =  true;             // È òàê ïîíÿòíî

extern string  s0             =  "---Trailing---";
extern bool    Trailing       =  true;             // È òàê ïîíÿòíî
extern bool    TrailProfitOnly   =  true;          // Òðàëèòü òîëüêî ïðîôèò


extern string  s1             =  "---Trading---";
extern bool    StopTrading    =  false;            // Ïðèîñòàíîâêà òîðãîâëè âðó÷íóþ
static bool    TradeAllowed   =  true;             // Îñòàíîâêà òîðãîâëè ñîâåòíèêîì

int            TrailingStep   =  1;                // Øàã òðàëà â ïóíêòàõ
double         ContinuousLot  =  0.1;              // Ðàçìåð ïîñòîÿííîãî ëîòà ïðè ÌÌ=false
int            TStop.Buy      =  0;                // Ðàçìåð òðàëà â ïóíêòàõ äëÿ ïîêóïîê
int            TStop.Sell     =  0;                // Ðàçìåð òðàëà â ïóíêòàõ äëÿ ïðîäàæ
double         BuyStopPrice   =  0.0;
double         SellStopPrice  =  0.0;
bool           Check_5Digits  =  false;
int            modeSetOrders  =  0;                //  0 - ïî çàäàííîé öåíå
                                                   //  1 - ñêîððåêòèðîâàòü öåíû
                                                   //  2 - âõîä ïî òåêóùèì öåíàì
static int     LastHour;
static int     Magic,
               MagicOfName,
               MagicOfSymbol;
int            Slippage       =  0;
double         Point_;
string         symbol,
               ExpertName,
               AccNumber;
color          clOpenBuy      =  LightBlue;         // Öâåò çíà÷êà îòêðûòèÿ ïîêóïêè
color          clOpenSell     =  LightCoral;        // Öâåò çíà÷êà îòêðûòèÿ ïðîäàæè
color          clCloseBuy     =  Blue;              // Öâåò çíà÷êà çàêðûòèÿ ïîêóïêè
color          clCloseSell    =  Red;               // Öâåò çíà÷êà çàêðûòèÿ ïðîäàæè
color          clModifyBuy    =  Aqua;              // Öâåò çíà÷êà ìîäèôèêàöèè ïîêóïêè
color          clModifySell   =  Tomato;            // Öâåò çíà÷êà ìîäèôèêàöèè ïðîäàæè
bool           MarketWatch    =  True;              // Çàïðîñû ïîä èñïîëíåíèå "Market Watch".
static bool    SetFlag        =  false;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int init(){
   symbol            =  Symbol();
   ExpertName        =  WindowExpertName();
   AccNumber         =  DoubleToStr(AccountNumber(),0);
   MagicOfName       =  0;

   for(int i=StringLen(ExpertName)-1;i>=0;i--)                                                                 //Ñîñòàâíîé ìàãèê:
      MagicOfName=MagicOfName+StringGetChar(ExpertName,i)*(i+1);                                               //ó÷èòûâàåò èìÿ ýêñïåðòà è
   MagicOfSymbol=StringGetChar(symbol,0)*StringGetChar(symbol,5)+                                              //íàçâàíèå òîðãóåìîé ïàðû
      StringGetChar(symbol,1)*StringGetChar(symbol,4)+
      StringGetChar(symbol,2)*StringGetChar(symbol,3);
   Magic=MagicOfSymbol+MagicOfName;
   
   if (!GlobalVariableCheck(symbol+"_Price")) GlobalVariableSet(symbol+"_Price",0);                            //Íà ñëó÷àé àâàðèéíîãî âûõîäà  
   if (!GlobalVariableCheck(symbol+"_Time")) GlobalVariableSet(symbol+"_Time",0);                              //îðãàíèçóåì ãëîáàëüíûå ïåðåìåííûå 
   if (!GlobalVariableCheck(symbol+"_Ticket")) GlobalVariableSet(symbol+"_Ticket",-1);                         //äëÿ ñîõðàíåíèÿ êðèòè÷åñêèõ äàííûõ

   if (!GlobalVariableCheck("Risk")) GlobalVariableSet("Risk",2);                                              //Óðîâåíü ðèñêà äëÿ ìóëüòèâàëþòíîé òîðãîâëè  
     
   Point_=Point;
   if(Check_5Digits == true && (Digits == 3 || Digits == 5)){                                                  //Äëÿ êîððåêòíîé ðàáîòû ñ 5-þ çíàêàìè
      Alert("Digits=", Digits, " Broker quotes given in 5-digit mode. \"Point\" will be multiplied by 10");    //â êîòèðîâêàõ
      Point_ = 10*Point;
   int ticket=GlobalVariableGet(symbol+"_Ticket");
   Restart(ticket);                                                                                            //Åñëè ïåðåçàïóñê òåðìèíàëà
   }
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int deinit(){

}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int start(){   
   if(!TradeAllowed || StopTrading)return(0);                                                                  //Òîðãîâàòü - íå òîðãîâàòü
                                                                    
/*   if(LastHour!=Hour() && symbol=="GBPJPY"){                                                                 //Åæå÷àñíî ðîáîò øëåò íàì äîêëàä
      double am=AccountMargin();                                                                               //î ñîñòîÿíèè ñ÷åòà
      if(AccountMargin()==0)am=1;
      SendMail(DoubleToStr(AccountNumber(),0)+" "+symbol+" "+TimeToStr(TimeCurrent(),TIME_MINUTES),
         DoubleToStr(AccountEquity(),0)+", Level "+DoubleToStr(100*AccountEquity()/am,0)+"%");
      LastHour=Hour();
   }*/ 
    
   int Minute5 = MathMod(Minute(),5);                                                                          //Íå ñóåòèìñÿ, çà ðûíêîì
   if(Minute5 == 0){                                                                                           //ïðèñìàòðèâàåì êàæäûå 5 ìèíóò                         
      int spread = MarketInfo(symbol,MODE_SPREAD);
      static int ticket;
      int orders=0;      
      for(int i=OrdersTotal()-1;i>=0;i--){                                                                     //Ïîäñ÷åò îðäåðîâ
         OrderSelect(i,SELECT_BY_POS);
         if(OrderMagicNumber()!=Magic) continue;   
         orders++;
      }
      switch(orders){
         case 0:  InitPrice();                                                                                 //Óñòàíîâêà áàçîâûõ öåíû è âðåìåíè
                  double base=GlobalVariableGet(symbol+"_Price");                                              //èëè (-1) îáíóëåíèå, åñëè îðäåðà íåò
                  Comment("Robot is ready.", "\n",                                                         
                     "Starting time ... ",TimeToStr(GlobalVariableGet(symbol+"_Time"),TIME_MINUTES),"\n", 
                     "Base price ... ", NormalizeDouble(base,Digits),"\n",
                     "Delta ... ", NormalizeDouble(Delta,0));
                  if(base!=0){   
                     datetime DateExp=GlobalVariableGet(symbol+"_Time")+86400;                                 //Ðåñòàðò, åñëè â òå÷åíèå ñóòîê                     
                     if(TimeCurrent()>DateExp){                                                                //îðäåð íå óñòàíîâëåí
                        Restart(-1);
                        return(0);
                     }
                     if(Ask >= base+Delta*Point_){
                        BuyStopPrice=base+(Delta+spread)*Point_;                                                        //Óñòàíîâêà öåíû îòêðûòèÿ áàéñòîï îðäåðà
                        SellStopPrice=base-Delta*Point_;                                                       //Óñòàíîâêà öåíû îòêðûòèÿ ñåëëñòîï îðäåðà
                        ticket = OrderSend_(symbol, OP_SELLSTOP, Lot(), SellStopPrice, Slippage, 
                           base+spread*Point,                                                                  //Óñòàíîâêà îòëîæåííèêà
                           SellStopPrice - TakeProfit*Point_, ExpertName, Magic,DateExp,Red);
                           Restart(ticket);                                                                    //Âîçâðàò â èñõîäíîå ñîñòîÿíèå ïðè                           
                           return(0);                                                                          //ïðè óñòàíîâëåííîì îðäåðå
                     }
                     if(Bid<=base-Delta*Point_){
                        BuyStopPrice=base+Delta*Point_;
                        SellStopPrice=base-Delta*Point_; 
                        ticket = OrderSend_(symbol, OP_BUYSTOP, Lot(), BuyStopPrice, Slippage, base, 
                           BuyStopPrice + TakeProfit*Point_, ExpertName, Magic,DateExp,Blue);
                           Restart(ticket);
                           return(0);
                     }
                  }
                  return(0);
         case 1:  Comment("");                                                                                 //Óäàëåíèå ïðåæíåãî êîììåíòà
                  ticket=GlobalVariableGet(symbol+"_Ticket");                                                  //Ïîëó÷àåì ¹ òèêåòà ðàáî÷åãî îðäåðà
                  if(ticket<=0)return(0);
                  OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES);
                  if(OrderType()==OP_SELLSTOP)
                     if(Ask>=OrderStopLoss() + TakeProfit*Point_){
                        Restart(-1);return(0);                                                                 //Ðåñòàðò, åñëè öåíà ïîøëà "íå òóäà"
                     }  
                  if(OrderType()==OP_BUYSTOP)
                     if(Bid<=OrderStopLoss() - TakeProfit*Point_){
                        Restart(-1);return(0);
                     }   
                  if(Trailing)Trailing(ticket,Magic,xD*Delta);                                                 //Òðåéëèíã ïîçèöèè
                  return(0);
         default: ticket=GlobalVariableGet(symbol+"_Ticket");                                                  //Ïîëó÷àåì ¹ òèêåòà ðàáî÷åãî îðäåðà
                  OrderDelete_(-1,Magic,ticket,-1);                                                            //Óäàëÿåì "ìóñîð"
                  return(0);
      }
   }         
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
bool InitPrice(){                                                                                              //Ô-öèÿ óñòàíîâêè áàçîâûõ ïàðàìåòðîâ
   if (Hour()==Hour_ && !SetFlag){                                                                             
      GlobalVariableSet(symbol+"_Price",iOpen(symbol,60,0));                                                   //Ñîõðàíÿåò áàçîâóþ öåíó
      GlobalVariableSet(symbol+"_Time",TimeCurrent());                                                         //è âðåìÿ íà÷àëà òîðãîâëè
      SetFlag=true;   
   }
   return(SetFlag);
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
double Lot(){
   if(!MM)return(ContinuousLot);
   double Risk=GlobalVariableGet("Risk");
   double tick=MarketInfo(symbol,MODE_TICKVALUE);                                                              //Ô-öèÿ ðàññ÷èòûâàåò ëîò òàêèì îáðàçîì, 
   double lot= NormalizeDouble(AccountEquity()*Risk/(2*Delta*100*tick),2);                                     //÷òî ëîññ ðàâåí óñòàíîâëåííîìó
   if(lot<0.01){                                                                                               //ïðîöåíòó îò äåïîçèòà
      TradeAllowed=false; 
      Alert(symbol,". NO MONEY!"); 
      lot=0;
   }
   return(lot);
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
bool Restart(int ticket){                                                                                      //Ô-öèÿ âîçâðàòà ê èñõîäíîìó ñîñòîÿíèþ
   OrderDelete_(-1,Magic,ticket,-1);                                                                           //Óäàëåíèå îðäåðîâ, êðîìå ticket
   GlobalVariableSet(symbol+"_Price",0);                                                                       //Îáíóëåíèå áàçîâîé öåíû
   GlobalVariableSet(symbol+"_Ticket",ticket);                                                                 //Ñîõðàíåíèå òèêåòà ðàáîòàþùåãî îðäåðà
   SetFlag=false;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+----------------------------------------------------------------------------+
//|  Àâòîð    : Êèì Èãîðü Â. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    op - îïåðàöèÿ                   (-1   - ëþáîé îðäåð)                    |
//|    mn - MagicNumber                (-1   - ëþáîé ìàãèê)                    |
//|    tkt1,tkt2- ïðîïóñòèòü           (-1   - óäàëèòü âñå)                    |
//+----------------------------------------------------------------------------+
bool OrderDelete_(int op=-1, int mn=-1, int tkt1=-1, int tkt2=-1) {
  bool res=true;
  int  err, i, it, k=OrdersTotal(), ot;

  for (i=k-1; i>=0; i--){
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)){
      if(OrderTicket()==tkt1 || OrderTicket()==tkt2)continue;
      ot=OrderType();
      if (ot>1 && ot<6){
        if (op<0 || ot==op){
          if (mn<0 || OrderMagicNumber()==mn){
            for (it=1; it<=5; it++){
              if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
              while (!IsTradeAllowed()) Sleep(5000);
              res=OrderDelete(OrderTicket(), Yellow);
              if (res) break;
              else {
                err=GetLastError();
                Print("Error(",err,"), failed delete order",", try ",it);
                Sleep(5000);
              }
            }
          }
        }
      }
    }
  }
  return(res);
}
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    sy - íàèìåíîâàíèå èíñòðóìåíòà   (NULL èëè "" - òåêóùèé ñèìâîë)          |
//|    op - îïåðàöèÿ                                                           |
//|    ll - ëîò                                                                |
//|    pp - öåíà                                                               |
//|    slip-ñëèïïàäæ
//|    sl - óðîâåíü ñòîï                                                       |
//|    tp - óðîâåíü òåéê                                                       |
//|    co - êîììåíòàðèé
//|    mn - Magic Number                                                       |
//|    ex - Ñðîê èñòå÷åíèÿ                                                        |
//|                                                         |
//+----------------------------------------------------------------------------+
int OrderSend_(string sy, int op, double ll, double pp,double Slippage,
              double sl=0, double tp=0,  string co="",int mn=0, datetime ex=0, color cl=0) {
  cl=IIFc(op==OP_BUYLIMIT || op==OP_BUYSTOP, clOpenBuy, clOpenSell);
  datetime ot;
  double   pa, pb, mp;
  int      err, it, ticket, msl;


  msl=MarketInfo(sy, MODE_STOPLEVEL);

  if (ex>0 && ex<TimeCurrent()) ex=0;
  for (it=1; it<=5; it++) {
    if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) {
      Print("SetOrder(): Îñòàíîâêà ðàáîòû ôóíêöèè");
      break;
    }
    while (!IsTradeAllowed()) Sleep(5000);
    RefreshRates();
    ot=TimeCurrent();
    pp=NormalizeDouble(pp,Digits);
    sl=NormalizeDouble(sl,Digits);
    tp=NormalizeDouble(tp,Digits);
    ticket=OrderSend(sy, op, ll, pp, Slippage, sl, tp, co, mn, ex, cl);
    if (ticket>0) {
       break;
    } else {
      err=GetLastError();
      if (err==128 || err==142 || err==143) {
        Sleep(1000*66);
        if (OrderExist_(sy, op, mn, ot)) {
           break;
        }
        Print("Error(",err,") set order: ",", try ",it);
        continue;
      }
      
      mp=MarketInfo(sy, MODE_POINT);
      pa=MarketInfo(sy, MODE_ASK);
      pb=MarketInfo(sy, MODE_BID);

      Print("Error(",err,") set order: ",", try ",it);
      Print("Ask=",pa,"  Bid=",pb,"  sy=",sy,"  ll=",ll,"  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) {
        TradeAllowed=false; 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);
    }
  }
return(ticket);
}
//+----------------------------------------------------------------------------+
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    sy - íàèìåíîâàíèå èíñòðóìåíòà   (""   - ëþáîé ñèìâîë,                   |
//|                                     NULL - òåêóùèé ñèìâîë)                 |
//|    op - îïåðàöèÿ                   (-1   - ëþáîé îðäåð)                    |
//|    mn - MagicNumber                (-1   - ëþáîé ìàãèê)                    |
//|    ot - âðåìÿ îòêðûòèÿ             ( 0   - ëþáîå âðåìÿ óñòàíîâêè)          |
//+----------------------------------------------------------------------------+
bool OrderExist_(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);
}
//|  Îïèñàíèå : Âîçâðàùàåò îäíî èç äâóõ çíà÷åíèé âçàâèñèìîñòè îò óñëîâèÿ.      |
//+----------------------------------------------------------------------------+
color IIFc(bool condition, color ifTrue, color ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}
//+----------------------------------------------------------------------------+
//|  Àâòîð    : Êèì Èãîðü Â. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Âåðñèÿ   : 10.04.2008                                                     |
//|  Îïèñàíèå : Îòêðûâàåò ïîçèöèþ ïî ðûíî÷íîé öåíå.                            |
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    sy - íàèìåíîâàíèå èíñòðóìåíòà   (NULL èëè "" - òåêóùèé ñèìâîë)          |
//|    op - îïåðàöèÿ                                                           |
//|    ll - ëîò                                                                |
//|    sl - óðîâåíü ñòîï                                                       |
//|    tp - óðîâåíü òåéê                                                       |
//|    mn - MagicNumber                                                        |
//|    co - êîììåíòàðèé                                                        |
//+----------------------------------------------------------------------------+
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 (op==OP_BUY) clOpen=clOpenBuy; else clOpen=clOpenSell;
  for (it=1; it<=5; it++) {
    if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) {
      Print("OpenPosition(): Îñòàíîâêà ðàáîòû ôóíêöèè");
      break;
    }
    while (!IsTradeAllowed()) Sleep(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) {
       break;
    } else {
      err=GetLastError();
      
      
      // Âûâîä ñîîáùåíèÿ îá îøèáêå
      Print("Error(",err,") opening position: ",", try ",it);
      Print("Ask=",pa," Bid=",pb," sy=",sy," ll=",ll," op=",
            " pp=",pp," sl=",sl," tp=",tp," mn=",mn);
      // Áëîêèðîâêà ðàáîòû ñîâåòíèêà
      if (err==2 || err==64 || err==65 || err==133) {
        TradeAllowed=false; break;
      }
      // Äëèòåëüíàÿ ïàóçà
      if (err==4 || err==131 || err==132) {
        Sleep(1000*300); break;
      }
      if (err==128 || err==142 || err==143) {
        Sleep(1000*66.666);
        if (ExistPositions(sy, op, mn, ot)) {
           break;
        }
      }
      if (err==140 || err==148 || err==4110 || err==4111) break;
      if (err==141) Sleep(1000*100);
      if (err==145) Sleep(1000*17);
      if (err==146) while (IsTradeContextBusy()) Sleep(1000*11);
      if (err!=135) Sleep(1000*7.7);
    }
  }
  if (MarketWatch && ticket>0 && (sl>0 || tp>0)) {
    if (OrderSelect(ticket, SELECT_BY_TICKET)) OrderModify_(-1, sl, tp);
  }
}
//+----------------------------------------------------------------------------+
//|  Âåðñèÿ   : 06.03.2008                                                     |
//|  Îïèñàíèå : Âîçâðàùàåò ôëàã ñóùåñòâîâàíèÿ ïîçèöèé                          |
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    sy - íàèìåíîâàíèå èíñòðóìåíòà   (""   - ëþáîé ñèìâîë,                   |
//|                                     NULL - òåêóùèé ñèìâîë)                 |
//|    op - îïåðàöèÿ                   (-1   - ëþáàÿ ïîçèöèÿ)                  |
//|    mn - MagicNumber                (-1   - ëþáîé ìàãèê)                    |
//|    ot - âðåìÿ îòêðûòèÿ             ( 0   - ëþáîå âðåìÿ îòêðûòèÿ)           |
//+----------------------------------------------------------------------------+
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 || sy=="") {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) {
              if (ot<=OrderOpenTime()) return(True);
            }
          }
        }
      }
    }
  }
  return(False);
}
//+----------------------------------------------------------------------------+
//|  Âåðñèÿ   : 28.11.2006                                                     |
//|  Îïèñàíèå : Ìîäèôèêàöèÿ îäíîãî ïðåäâàðèòåëüíî âûáðàííîãî îðäåðà.           |
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    pp - öåíà óñòàíîâêè îðäåðà                                              |
//|    sl - öåíîâîé óðîâåíü ñòîïà                                              |
//|    tp - öåíîâîé óðîâåíü òåéêà                                              |
//|    ex - äàòà èñòå÷åíèÿ                                                     |
//+----------------------------------------------------------------------------+
bool OrderModify_(double pp=-1, double sl=0, double tp=0, datetime ex=0) {
  bool   fm=true;
  color  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<=5; it++) {
      if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
      while (!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      fm=OrderModify(OrderTicket(), pp, sl, tp, ex, cl);
      if (fm){
         return(true);
      } 
      else {
        er=GetLastError();

        pa=MarketInfo(OrderSymbol(), MODE_ASK);
        pb=MarketInfo(OrderSymbol(), MODE_BID);
        Print("Error(",er,") modifying order: ",", try ",it);
        Print("Ask=",pa,"  Bid=",pb,"  sy=",OrderSymbol(),"  pp=",pp,"  sl=",sl,"  tp=",tp);
        Sleep(1000*10);
      }
    }
  }
   return(fm);
}
//+----------------------------------------------------------------------------+
//|  Àâòîð    : Êèì Èãîðü Â. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Âåðñèÿ   : 11.09.2008                                                     |
//|  Îïèñàíèå : Ñîïðîâîæäåíèå ïîçèöèé ïðîñòûì òðàëîì                           |
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    sy - íàèìåíîâàíèå èíñòðóìåíòà   ( ""  - ëþáîé ñèìâîë,                   |
//|                                     NULL - òåêóùèé ñèìâîë)                 |
//|    op - îïåðàöèÿ                   ( -1  - ëþáàÿ ïîçèöèÿ)                  |
//|    mn - MagicNumber                ( -1  - ëþáîé ìàãèê)                    |
//|    Delta - ðàçìåð òðàëà            ( -1  - extern     )                    |
//+----------------------------------------------------------------------------+
void Trailing(int ticket, int mn=-1, double TStop=-1) {
   double pp;
  
   if(TStop>0){
      TStop.Buy=NormalizeDouble(TStop,0);
      TStop.Sell=NormalizeDouble(TStop,0);
   }

   OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES);
   if (mn<0 || OrderMagicNumber()==mn) {
      if (OrderType()==OP_BUY) {
         pp=MarketInfo(OrderSymbol(), MODE_BID);
         if (!TrailProfitOnly || pp-OrderOpenPrice()>TStop.Buy*Point_) {
            if (OrderStopLoss()<pp-(TStop.Buy+TrailingStep-1)*Point_) {
               ModifyOrder(-1, pp-TStop.Buy*Point_, -1);
            }
         }
      }
      if (OrderType()==OP_SELL) {
         pp=MarketInfo(OrderSymbol(), MODE_ASK);
         if (!TrailProfitOnly || OrderOpenPrice()-pp>TStop.Sell*Point_) {
            if (OrderStopLoss()>pp+(TStop.Sell+TrailingStep-1)*Point_ || OrderStopLoss()==0) {
               ModifyOrder(-1, pp+TStop.Sell*Point_, -1);
            }
         }
      }
   }
}

//+----------------------------------------------------------------------------+

//+----------------------------------------------------------------------------+
//|  Àâòîð    : Êèì Èãîðü Â. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Âåðñèÿ   : 28.11.2006                                                     |
//|  Îïèñàíèå : Ìîäèôèêàöèÿ îäíîãî ïðåäâàðèòåëüíî âûáðàííîãî îðäåðà.           |
//+----------------------------------------------------------------------------+
//|  Ïàðàìåòðû:                                                                |
//|    pp - öåíà óñòàíîâêè îðäåðà                                              |
//|    sl - öåíîâîé óðîâåíü ñòîïà                                              |
//|    tp - öåíîâîé óðîâåíü òåéêà                                              |
//|    ex - äàòà èñòå÷åíèÿ                                                     |
//+----------------------------------------------------------------------------+
void ModifyOrder(double pp=-1, double sl=0, double tp=0, datetime ex=0) {
  bool   fm;
  color  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<=5; it++) {
      if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
      while (!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      fm=OrderModify(OrderTicket(), pp, sl, tp, ex, cl);
      if (fm) {
        break;
      } else {
        er=GetLastError();
        pa=MarketInfo(OrderSymbol(), MODE_ASK);
        pb=MarketInfo(OrderSymbol(), MODE_BID);
        Print("Error(",er,") modifying order, try ",it);
        Print("Ask=",pa,"  Bid=",pb,"  sy=",OrderSymbol(),
              "  pp=",pp,"  sl=",sl,"  tp=",tp);
        Sleep(1000*10);
      }
    }
  }
}