//+------------------------------------------------------------------+
//|                                        Quantum London Trading EA |
//|                                      Copyright 2012, CompanyName |
//|              http://www.forexfactory.com/showthread.php?t=552185 |
//+------------------------------------------------------------------+ 
#property strict
#property link "http://www.forexfactory.com/showthread.php?t=551382"
input int mn=2015; //Magic Number
input string comm="QLT142C_";//Order Comment
input bool fulltime=true; //Trade 24/7
input string a="-----------"; //If Trade 24/7 = false then:
input string open="07:00"; // Trading Window Start Time (Broker)
input string close="13:00"; // Trading Window End Time (Broker)
input bool stop=false;//Stop after each cycle
input int tf=1;//Time Frame (minutes)
input bool fifo=false;//Use FIFO Rule
input bool mon=true;//Trade on Monday
input bool tue=true;//Trade on Tuesday
input bool wed=true;//Trade on Wednesday
input bool thurs=true;//Trade on Thursday
input bool fri=true;//Trade on Friday
input int xcandles=0;//Only trade every X candles
input int qd=325;//Quantum eintDepth3
extern string    A023 = "Параметры SDA";
extern int Len = 150;
extern int HistoryBars = 500;
extern bool ModeHL = TRUE;
extern string i1 = "===настройки режимов===";
extern bool ModeOnline = TRUE;
extern bool ModeinFile = FALSE;
extern bool ModeHistory = FALSE;
extern string i2 = "===настройки оповещения===";
extern double UrovenSignal = 15.0;
extern bool alert = TRUE;
extern bool sound = FALSE;
extern bool email = FALSE;
extern bool GV = FALSE;
input string l="-----------"; // Set up lots and/or grid for trades
input double T1=0.01; //Trades 1-12
input double T2=0.02; //Trades 13-21
input double T3=0.05; //Trades 22-29
input double T4=0.13; //Trades 30-36
input double T5=0.34; //Trades 37-39
input double T6=0.89; //Trade 40 & >
input bool grid=false;//Use Grid
input bool drawgrid=false;//Draw Grid Lines
input int grid1size=0; //Grid 1 Size (Eg. 100)
input int grid1inc=0; //Grid 1 Increment (Space between entries)
input int grid1maxtrades=0; //Max Trades For Grid 1
input double grid1lots=0; //Grid 1 Lots
input int grid2size=0; //Grid 2 Size (Eg. 100)
input int grid2inc=0; //Grid 2 Increment (Space between entries)
input int grid2maxtrades=0; //Max Trades For Grid 2
input double grid2lots=0; //Grid 2 Lots
input int grid3size=0; //Grid 3 Size (Eg. 100)
input int grid3inc=0; //Grid 3 Increment (Space between entries)
input int grid3maxtrades=0; //Max Trades For Grid 3
input double grid3lots=0; //Grid 3 Lots
input bool ber=false;//Use Break Even Recovery
input double percbedd=0;//% Equity Draw Down to Activate Break Even Recovery
bool beractive=false;
input int pointstp=0;//Points Take Profit (Eg. 100)
input double dollartp=0;//$ Take Profit (Eg. 100)
input double percequitytp=0;//% Equity Take Profit (Eg. 10)
input int pointssl=0;//Points Stop Loss (Eg. -100)
input double dollarsl=0;//$ Stop Loss (Eg. -50)
input double percequitysl=0;//% Equity Stop Loss (Eg. -10)
input bool debug=false;//Debug Mode

input int TimeZone=2;

input bool DoCheckClose=true;
input double CheckTime=11.00;
input double GeneralProfit_First=50;

input bool DoProfitClose=true;
input double GeneralProfit_Second=100;

input bool DoTimeClose=true;
input double CloseTime=14.00;

input bool DoSLClose=true;
input double GeneralSL=-20;

double   lots,prevorderprice;
datetime curtime,prevtime,curday,prevday;
bool     donefortheday;
double   initialstartbuy,initialstartsell;
double   digits;
int      openorders;

int      SgSDA = 0;

bool tumb=false;
bool profit_tumb=false;
bool EnableTrade=true;
string commnt = comm+ DoubleToStr(mn, 0);;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
   DeleteLines();
   if(stop==true)
      CreateButton();
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int deinit()
  {
   DeleteLines();
   ObjectDelete(0,"start");
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   digits=1;
   if(Digits==5 || Digits==3)
     {
      digits=10;
     }

   if(debug)
     {
      if(IsTradeAllowed()==false)
         Alert("Broker does not allow EA to trade");
     }
//+------------------------------------------------------------------+
   double t_Hour;
   double t_time = NormalizeDouble((Minute()),2);                       // Переводим минуты в Double.
   
   if(Hour()+TimeZone > 23)                                             // Корректируем часы с добавкой Часового пояса
      t_Hour = TimeZone-(24-Hour());
   else
      t_Hour=Hour()+TimeZone;
   
   t_time = t_Hour +(NormalizeDouble((t_time/100),2));                  // Переводим минуты в сотую часть после запятой и добавляем часы.
   
   if (t_time < 0.1)
      EnableTrade=true;
      
   if (t_time < CheckTime)
   {
      tumb=true;
      profit_tumb=false;
   }
   
   if(tumb && F_OrdersTotal()>0)
   {
      if(t_time>CheckTime)                                              // Если время больше заданного 
      {
         if(!profit_tumb)                                               // Если выключенно закрытие по общему профиту
         {
            if(TotalProfit()>GeneralProfit_First && DoCheckClose)       // Если общий профит ордеров положительный
            {
                  CloseAll();                                           // Закрываем все ордера
                  tumb=false;  
            }
            else
               profit_tumb=true;                                        // Иначе - включаем закрытие по общему профиту
         }      

         if(DoProfitClose)
            if(profit_tumb && TotalProfit()>GeneralProfit_Second)           // Если включенно закрытие по общему профиту и общий профит больше заданного
            {
               CloseAll();                                                 // Закрываем все ордера
               tumb=false;
            }
      } 
      
      if(DoTimeClose)
         if(t_time>CloseTime)
            if(F_OrdersTotal()>0)
            {
               CloseAll();
               tumb=false;
            }   
   }    
//+------------------------------------------------------------------+   
   if(DoSLClose && F_OrdersTotal()>0 && TotalProfit()<GeneralSL)
      CloseAll();
//+------------------------------------------------------------------+
   CheckCloseTrades();

   if(grid==true &&
      (grid1size==0 || grid2size==0 || grid3size==0))
     {
      Alert("Please set ALL grid sizes");
      return(0);
     }

   openorders=0;
   for(int j=OrdersTotal()-1;j>=0;j--)
     {
      if(!OrderSelect(j,SELECT_BY_POS,MODE_TRADES))
         continue;
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
        {
         openorders+=1;
        }
     }

   double g1s=(grid1size*digits)*Point;
   double g2s=(grid2size*digits)*Point;
   double g3s=(grid3size*digits)*Point;

//Open trades after Trading Window Start Time and before Trading Window End Time
   for(int i=OrdersTotal()-1;i>=0;i--)
     {
      if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         continue;
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
        {
         prevorderprice=OrderOpenPrice();
         break;
        }
     }

   bool buttonstarted=ObjectGetInteger(0,"start",OBJPROP_STATE);

   curtime=iTime(Symbol(),tf,0);
   if((stop==true && buttonstarted==true && openorders<=0) || stop==false || openorders>0)
     {
      if(((iTime(Symbol(),1,0)>=StrToTime(open) && iTime(Symbol(),1,0)<StrToTime(close)) || (fulltime==true)) && curtime>prevtime)
        {
         bool cantrade=true;
         int grid1trades,grid2trades,grid3trades;
         SgSDA = 0;
         SgSDA = CheckSDA();

         if ((iCustom(Symbol(),tf,"Quantum",qd,0,1)>0) && (SgSDA == 1))
           {
            if(debug)
               Alert("Quantum Buy Signal detected --- checking other conditions...");
            //Alert(prevorderprice);

            if(grid==true && OrdersTotal()>0)
              {
               for(int j=OrdersTotal()-1;j>=0;j--)
                 {
                  if(!OrderSelect(j,SELECT_BY_POS,MODE_TRADES))
                     continue;
                  if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
                    {
                     if(OrderOpenPrice()>initialstartbuy-g1s)
                       {
                        grid1trades+=1;
                       }
                     if(OrderOpenPrice()<=initialstartbuy-g1s && OrderOpenPrice()>initialstartbuy-g1s-g2s)
                       {
                        grid2trades+=1;
                       }
                     if(OrderOpenPrice()<=initialstartbuy-g1s-g2s && OrderOpenPrice()>initialstartbuy-g1s-g2s-g3s)
                       {
                        grid3trades+=1;
                       }
                    }
                 }
              }
            if((grid==true) && Ask>initialstartbuy-g1s && ((grid1trades>=grid1maxtrades && grid1maxtrades>0) || (prevorderprice>0 && prevorderprice-((grid1inc*digits)*Point)<=Ask)))
               cantrade=false;
            if((grid==true) && Ask<=initialstartbuy-g1s && Ask>initialstartbuy-g1s-g2s && ((grid2trades>=grid2maxtrades && grid2maxtrades>0) || (prevorderprice-((grid2inc*digits)*Point)<=Ask)))
               cantrade=false;
            if((grid==true) && Ask<=initialstartbuy-g1s-g2s && Ask>initialstartbuy-g1s-g2s-g3s && ((grid3trades>=grid3maxtrades && grid3maxtrades>0) || (prevorderprice-((grid2inc*digits)*Point)<=Ask)))
               cantrade=false;

            if(debug && cantrade==false)
               Alert("Trade Cancelled because of Grid Conditions");

            if(mon==false && DayOfWeek()==1)
               cantrade=false;
            if(tue==false && DayOfWeek()==2)
               cantrade=false;
            if(wed==false && DayOfWeek()==3)
               cantrade=false;
            if(thurs==false && DayOfWeek()==4)
               cantrade=false;
            if(fri==false && DayOfWeek()==5)
               cantrade=false;

            if(debug && cantrade==false)
               Alert("Trade Cancelled because of week Conditions");

            if(xcandles>0)
              {
               int lastorderbar;
               for(int i=OrdersTotal()-1;i>=0;i--)
                 {
                  if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
                     continue;
                  if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
                    {
                     lastorderbar=iBarShift(Symbol(),tf,OrderOpenTime(),false);
                     break;
                    }
                 }

               if(lastorderbar<xcandles && OrdersTotal()>0)
                 {
                  cantrade=false;
                  if(debug)
                     Alert("Trade Cancelled because of X Candles Conditions");
                 }
              }

            if(cantrade==true)
              {
               lots=GetLots(Ask,"Buy");
               if(stop==true)
                 {
                  ObjectSetInteger(0,"start",OBJPROP_STATE,false);
                 }
               if(lots>0)
                 {
                  RefreshRates();
                  //+------------------------------------------------------------------+
                  if(EnableTrade)
                  {
                     if(!OrderSend(Symbol(),OP_BUY,lots,Ask,10,0,0,commnt,mn,0,0))
                        Alert("OrderSend Error: ",GetLastError());
                     if(debug)
                        Alert("Trade should definitely have happened!");
                  }   
                  //+------------------------------------------------------------------+
                 }
               int bopenorders;
               for(int s=OrdersTotal()-1;s>=0;s--)
                 {
                  if(!OrderSelect(s,SELECT_BY_POS,MODE_TRADES))
                     continue;
                  if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
                    {
                     bopenorders+=1;
                    }
                 }
               if(bopenorders<=1 && bopenorders>0)
                 {
                  initialstartbuy=Ask;
                  initialstartsell=0;
                  if(drawgrid==true)
                    {
                     Alert("Grid should have been drawn");
                     DrawGrid(initialstartbuy,"Buy");
                    }
                 }
              }
           }
         if ((iCustom(Symbol(),tf,"Quantum",qd,1,1)>0) && (SgSDA == -1))
           {
            if(debug)
               Alert("Quantum Sell Signal detected --- checking other conditions...");
            cantrade=true;
            if(grid==true && OrdersTotal()>0)
              {
               for(int j=OrdersTotal()-1;j>=0;j--)
                 {
                  if(!OrderSelect(j,SELECT_BY_POS,MODE_TRADES))
                     continue;
                  if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
                    {
                     if(OrderOpenPrice()<initialstartsell+g1s)
                       {
                        grid1trades+=1;
                       }
                     if(OrderOpenPrice()>=initialstartsell+g1s && OrderOpenPrice()<initialstartsell+g1s+g2s)
                       {
                        grid2trades+=1;
                       }
                     if(OrderOpenPrice()>=initialstartsell+g1s+g2s && OrderOpenPrice()<initialstartsell+g1s+g2s+g3s)
                       {
                        grid3trades+=1;
                       }
                    }
                 }
              }
            if((grid==true) && Bid<initialstartsell+g1s && ((grid1trades>=grid1maxtrades && grid1maxtrades>0) || (prevorderprice>0 && prevorderprice+((grid1inc*digits)*Point)>=Bid)))
               cantrade=false;
            if((grid==true) && Bid>=initialstartsell-g1s && Bid<initialstartsell+g1s+g2s && ((grid2trades>=grid2maxtrades && grid2maxtrades>0) || (prevorderprice+((grid2inc*digits)*Point)>=Bid)))
               cantrade=false;
            if((grid==true) && Bid>=initialstartsell-g1s-g2s && Bid<initialstartsell+g1s+g2s+g3s && ((grid3trades>=grid3maxtrades && grid3maxtrades>0) || (prevorderprice+((grid3inc*digits)*Point)>=Bid)))
               cantrade=false;

            if(debug && cantrade==false)
               Alert("Trade Cancelled because of Grid Conditions");

            if(mon==false && DayOfWeek()==1)
               cantrade=false;
            if(tue==false && DayOfWeek()==2)
               cantrade=false;
            if(wed==false && DayOfWeek()==3)
               cantrade=false;
            if(thurs==false && DayOfWeek()==4)
               cantrade=false;
            if(fri==false && DayOfWeek()==5)
               cantrade=false;

            if(debug && cantrade==false)
               Alert("Trade Cancelled because of week Conditions");

            if(xcandles>0)
              {
               OrderSelect(OrdersTotal()-1,SELECT_BY_POS,MODE_TRADES);
               int lastorderbar;
               if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
                 {
                  lastorderbar=iBarShift(Symbol(),tf,OrderOpenTime(),false);
                 }
               if(lastorderbar<xcandles && OrdersTotal()>0)
                 {
                  cantrade=false;
                  if(debug)
                     Alert("Trade Cancelled because of  X Candles Condition");
                 }
              }

            if(cantrade==true)
              {
               if(stop==true)
                 {
                  ObjectSetInteger(0,"start",OBJPROP_STATE,false);
                 }
               lots=GetLots(Bid,"Sell");
               if(lots>0)
                 {
                  RefreshRates();
                  //+------------------------------------------------------------------+
                  if(EnableTrade)
                  {
                     if(!OrderSend(Symbol(),OP_SELL,lots,Bid,10,0,0,commnt,mn,0,0))
                        Alert("OrderSend Error: ",GetLastError());
                     if(debug)
                        Alert("Trade should definitely have opened now!");
                  }   
                  //+------------------------------------------------------------------+   
                 }
               int sopenorders;
               for(int v=OrdersTotal()-1;v>=0;v--)
                 {
                  if(!OrderSelect(v,SELECT_BY_POS,MODE_TRADES))
                     continue;
                  if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
                    {
                     sopenorders+=1;
                    }
                 }
               if(sopenorders<=1 && sopenorders>0)
                 {
                  initialstartsell=Bid;
                  initialstartbuy=0;
                  if(drawgrid==true)
                    {
                     Alert("Grid should have been drawn");
                     DrawGrid(initialstartsell,"Sell");
                    }
                 }
              }
           }
        }
     }
   prevtime=iTime(Symbol(),tf,0);
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double GetLots(double price,string dir)
  {
   int numtrades;
   double retlots;

   for(int c=OrdersTotal()-1;c>=0;c--)
     {
      if(!OrderSelect(c,SELECT_BY_POS,MODE_TRADES))
         continue;
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
        {
         numtrades+=1;
        }
     }

   if(grid==false)
     {
      if(numtrades>=0 && numtrades<12)
         retlots=T1;
      if(numtrades>=12 && numtrades<21)
         retlots=T2;
      if(numtrades>=21 && numtrades<29)
         retlots=T3;
      if(numtrades>=29 && numtrades<36)
         retlots=T4;
      if(numtrades>=36 && numtrades<39)
         retlots=T5;
      if(numtrades>=39)
         retlots=T6;
     }

   if(grid==true)
     {

      double g1s=(grid1size*digits)*Point;
      double g2s=(grid2size*digits)*Point;
      double g3s=(grid3size*digits)*Point;

      if(numtrades<=0)
         retlots=grid1lots;

      if(numtrades>0)
        {
         if(dir=="Buy")
           {
            if(price>initialstartbuy-g1s)
               retlots=grid1lots;
            if(price>=initialstartbuy-g1s-g2s && price<initialstartbuy-g1s)
               retlots=grid2lots;
            if(price>=initialstartbuy-g1s-g2s-g3s && price<initialstartbuy-g1s-g2s)
               retlots=grid3lots;
            if(price<initialstartbuy-g1s-g2s-g3s)
               retlots=grid3lots;
           }

         if(dir=="Sell")
           {
            if(price<initialstartsell+g1s)
               retlots=grid1lots;
            if(price<=initialstartsell+g1s+g2s && price>initialstartsell+g1s)
               retlots=grid2lots;
            if(price<=initialstartsell+g1s+g2s+g3s && price>initialstartsell+g1s+g2s)
               retlots=grid3lots;
            if(price>=initialstartsell+g1s+g2s+g3s)
               retlots=grid3lots;
           }
        }
     }
   if(retlots>0)
     {
      int min_size_digits;

      //check account type (micro / mini / normal)
      if(MarketInfo(Symbol(),MODE_LOTSTEP)==0.001)
         min_size_digits=3;
      if(MarketInfo(Symbol(),MODE_LOTSTEP)==0.01)
         min_size_digits=2;
      if(MarketInfo(Symbol(),MODE_LOTSTEP)==0.05)
         min_size_digits=2;
      if(MarketInfo(Symbol(),MODE_LOTSTEP)==0.1)
         min_size_digits=1;
      if(MarketInfo(Symbol(),MODE_LOTSTEP)==1)
         min_size_digits=0;

      //retlots=NormalizeDouble(retlots,2);
      if(retlots<MarketInfo(Symbol(),MODE_MINLOT))
         retlots=MarketInfo(Symbol(),MODE_MINLOT);
      if(retlots>MarketInfo(Symbol(),MODE_MAXLOT))
         retlots=MarketInfo(Symbol(),MODE_MAXLOT);
      retlots=MathFloor(retlots/MarketInfo(Symbol(),MODE_LOTSTEP))*MarketInfo(Symbol(),MODE_LOTSTEP);
      if(MarketInfo(Symbol(),MODE_LOTSTEP)==0.05)
        {
         int templots=retlots*100;
         double remainder=templots%5;
         templots=templots-remainder;
         retlots = templots;
         retlots/=100;
        }
     }
   return(retlots);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CheckCloseTrades()
  {
   bool closeonsell,closeonbuy;
   int runningpoints;
   double runningprofit;
   bool CloseTrades=false;

   closeonsell=false;
   closeonbuy=false;

   for(int a=OrdersTotal()-1;a>=0;a--)
     {
      if(!OrderSelect(a,SELECT_BY_POS,MODE_TRADES))
         continue;
      if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn)
        {
         if(OrderType()==OP_BUY)
           {
            runningpoints+=(Bid-OrderOpenPrice())/Point;
            runningprofit+=OrderProfit()+OrderCommission()+OrderSwap();
            closeonsell=true;
           }
         if(OrderType()==OP_SELL)
           {
            runningpoints+=(OrderOpenPrice()-Bid)/Point;
            runningprofit+=OrderProfit()+OrderCommission()+OrderSwap();
            closeonbuy=true;
           }
        }
     }

   if((runningprofit<=dollarsl && dollarsl<0) || (runningprofit>=dollartp && dollartp>0))// && dollarsl<0)
      CloseTrades=true;

   if((AccountEquity()<=(AccountBalance()+((AccountBalance()*percequitysl)/100)) && percequitysl<0) || (AccountEquity()>=(AccountBalance()+((AccountBalance()*percequitytp)/100)) && percequitytp>0))
      CloseTrades=true;

   if((runningpoints<=pointssl && pointssl<0) || (runningpoints>=pointstp && pointstp>0))
      CloseTrades=true;

   if(AccountEquity()<=(AccountBalance()+((AccountBalance()*percbedd)/100)) && ber==true)
      beractive=true;

   if(runningprofit>=0 && beractive==true)
      CloseTrades=true;

   if((iCustom(Symbol(),tf,"Quantum",qd,1,1)>0 && closeonsell==true) || (CloseTrades==true))
     {
      DeleteLines();
      if(fifo==false)
        {
         for(int b=OrdersTotal()-1;b>=0;b--)
           {
            if(!OrderSelect(b,SELECT_BY_POS,MODE_TRADES))
               continue;
            if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn && OrderType()==OP_BUY)
              {
               RefreshRates();
               if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0,0))
                  Alert("OrderClose Error: ",GetLastError());
               else
                  EnableTrade=false;   
              }
           }
        }
      if(fifo==true)
        {
         int TradeList[][2];
         int ctTrade=0;
         for(int x=OrdersTotal()-1;x>=0;x--)
           {
            if(!OrderSelect(x,SELECT_BY_POS,MODE_TRADES))
               continue;
            if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn && OrderType()==OP_BUY)
              {
               ctTrade++;
               ArrayResize(TradeList,ctTrade);
               TradeList[ctTrade-1][0]=OrderOpenTime();
               TradeList[ctTrade-1][1]=OrderTicket();
              }
           }
         ArraySort(TradeList,WHOLE_ARRAY,0,MODE_ASCEND);
         for(int i=0; i<ctTrade; i++)
           {
            OrderSelect(TradeList[i][1],SELECT_BY_TICKET);
            RefreshRates();
            if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0,0))
               Alert("OrderClose Error: ",GetLastError());
            else
               EnableTrade=false;    
           }
        }
     }
   if((iCustom(Symbol(),tf,"Quantum",qd,0,1)>0 && closeonbuy==true) || (CloseTrades==true))
     {
      DeleteLines();
      if(fifo==false)
        {
         for(int c=OrdersTotal()-1;c>=0;c--)
           {
            if(!OrderSelect(c,SELECT_BY_POS,MODE_TRADES))
               continue;
            if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn && OrderType()==OP_SELL)
              {
               RefreshRates();
               if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0,0))
                  Alert("OrderClose Error: ",GetLastError());
               else
                  EnableTrade=false;
              }
           }
        }
      if(fifo==true)
        {
         int TradeList2[][2];
         int ctTrade2=0;
         for(int h=OrdersTotal()-1;h>=0;h--)
           {
            if(!OrderSelect(h,SELECT_BY_POS,MODE_TRADES))
               continue;
            if(OrderSymbol()==Symbol() && OrderMagicNumber()==mn && OrderType()==OP_SELL)
              {
               ctTrade2++;
               ArrayResize(TradeList2,ctTrade2);
               TradeList2[ctTrade2-1][0]=OrderOpenTime();
               TradeList2[ctTrade2-1][1]=OrderTicket();
              }
           }
         ArraySort(TradeList2,WHOLE_ARRAY,0,MODE_ASCEND);
         for(int i=0; i<ctTrade2; i++)
           {
            OrderSelect(TradeList2[i][1],SELECT_BY_TICKET);
            RefreshRates();
            if(!OrderClose(OrderTicket(),OrderLots(),OrderClosePrice(),0,0))
               Alert("OrderClose Error: ",GetLastError());
            else
               EnableTrade=false;   
           }
        }
     }
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawGrid(double price,string dir)
  {
   Alert("Were the grid lines drawn?");
   if(dir=="Buy")
     {
      ObjectCreate(0,"Initial Grid",OBJ_HLINE,0,iTime(Symbol(),1,0),price);
      ObjectCreate(0,"Grid 1",OBJ_HLINE,0,iTime(Symbol(),1,0),price-((grid1size*digits)*Point));
      ObjectCreate(0,"Grid 2",OBJ_HLINE,0,iTime(Symbol(),1,0),price-(((grid1size+grid2size)*digits)*Point));
      ObjectCreate(0,"Grid 3",OBJ_HLINE,0,iTime(Symbol(),1,0),price-(((grid1size+grid2size+grid3size)*digits)*Point));
     }
   if(dir=="Sell")
     {
      ObjectCreate(0,"Initial Grid",OBJ_HLINE,0,iTime(Symbol(),1,0),price);
      ObjectCreate(0,"Grid 1",OBJ_HLINE,0,iTime(Symbol(),1,0),price+((grid1size*digits)*Point));
      ObjectCreate(0,"Grid 2",OBJ_HLINE,0,iTime(Symbol(),1,0),price+(((grid1size+grid2size)*digits)*Point));
      ObjectCreate(0,"Grid 3",OBJ_HLINE,0,iTime(Symbol(),1,0),price+(((grid1size+grid2size+grid3size)*digits)*Point));
     }
   return;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DeleteLines()
  {
   ObjectDelete(0,"Initial Grid");
   ObjectDelete(0,"Grid 1");
   ObjectDelete(0,"Grid 2");
   ObjectDelete(0,"Grid 3");
   return;
  }
//+------------------------------------------------------------------+
void CreateButton()
  {
   ObjectCreate(ChartID(),"start",OBJ_BUTTON,0,0,0);
   ObjectSetInteger(ChartID(),"start",OBJPROP_COLOR,clrWhite);
   ObjectSetInteger(ChartID(),"start",OBJPROP_BGCOLOR,clrGreen);
   ObjectSetInteger(ChartID(),"start",OBJPROP_CORNER,CORNER_LEFT_LOWER);
   ObjectSetInteger(ChartID(),"start",OBJPROP_XSIZE,100);
   ObjectSetInteger(ChartID(),"start",OBJPROP_YSIZE,20);
   ObjectSetInteger(ChartID(),"start",OBJPROP_STATE,false);
   ObjectSetString(ChartID(),"start",OBJPROP_FONT,"Arial");
   ObjectSetString(ChartID(),"start",OBJPROP_TEXT,"Start next cycle");
   ObjectSetInteger(ChartID(),"start",OBJPROP_FONTSIZE,8);
   ObjectSetInteger(ChartID(),"start",OBJPROP_SELECTABLE,0);
   return;
  }
//+------------------------------------------------------------------+
int F_OrdersTotal()
{
   int OrdersTotalResult = 0;
 
   for(int i=0;i<OrdersTotal();i++)
   { 
      if(OrderSelect(i, SELECT_BY_POS))
         if(OrderMagicNumber() == mn) 
            OrdersTotalResult++;
   }
 
   return(OrdersTotalResult);
}
//= Закрываем все ордера =============================================================================================================================
void CloseAll()
{
   int ticket, i;

   EnableTrade=false;
   
   for(i=OrdersTotal()-1;i>=0;i--)                                                              // Проходимся по всем ордерам
      if(OrderSelect(i, SELECT_BY_POS))
         if(OrderMagicNumber() == mn)
            CloseOrder(i);                                                                      // Закрываем ордер
}
//= Закрываем указаный ордер ========================================================================================================================
void CloseOrder(int i)
{
   int ticket;

   OrderSelect(i,SELECT_BY_POS,MODE_TRADES);                                                       // Выбираем ордер
   if(OrderType()<2)                                                                               // Если тип ордера Buy или Sell
   {
      if(OrderType()==OP_BUY)                                                                      // Если ордер Buy
      {
         RefreshRates();
         ticket=OrderClose(OrderTicket(),OrderLots(),Bid,3,Lime);                                  // Закрываем ордер
         Sleep(1000);                                                                              // Пауза на закрытие
      }
      if(OrderType()==OP_SELL)                                                                     // Если ордер Sell
      {
         RefreshRates();
         ticket=OrderClose(OrderTicket(),OrderLots(),Ask,3,Lime);                                  // Закрываем ордер
         Sleep(1000);                                                                              // Пауза на закрытие
      }
   }   
}
//===================================================================================================================================================
int TotalProfit()
{
   double TotalResult = 0;
 
   for(int i=0;i<OrdersTotal();i++)
   { 
      if(OrderSelect(i, SELECT_BY_POS))
         if(OrderMagicNumber() == mn) 
            TotalResult=TotalResult+OrderProfit();
   }
 
   return(TotalResult);
}


//------------------------------------------------
int CheckSDA()
{
   double SDAUp  = iCustom(Symbol(), 0, "SDA v 3.2", Len, HistoryBars, ModeHL, i1, ModeOnline, ModeinFile, ModeHistory, 
                     i2, UrovenSignal, alert, sound, email, GV, 0, 1);
   double SDADn  = iCustom(Symbol(), 0, "SDA v 3.2", Len, HistoryBars, ModeHL, i1, ModeOnline, ModeinFile, ModeHistory, 
                     i2, UrovenSignal, alert, sound, email, GV, 1, 1);
   
   if (SDADn > SDAUp) if (SDADn >= UrovenSignal) return(-1);  // sell
   if (SDAUp > SDADn) if (SDAUp >= UrovenSignal) return(1);   // buy   
   return(0);
}
//++++++++++++++++++++++++++++++++++++++++++++++++