#include <Mql4Book\Timer.mqh>
CTimer Timer;

// Input variables
input bool UserTimer = true;
input int StartHour = 9;
input int StartMinute = 0;
input int EndHour = 19;
input int EndMinute = 0;
input bool UseLocalTime = false;

input int MagicNumber = 101;                        
input int Slippage = 20;
input double LotSize = 0.1;

input int StopLoss = 200;

input int KPeriod = 14;
input int DPeriod = 3;
input int Slowing = 3;
input ENUM_MA_METHOD StochMethod = MODE_SMA;
input ENUM_STO_PRICE StochPrice = STO_LOWHIGH;

input int FastPeriod = 12;
input int SlowPeriod = 26;
input int SignalPeriod = 9;
input ENUM_APPLIED_PRICE iMacPrice = PRICE_CLOSE;

input int ADXPeriod = 13;
input ENUM_APPLIED_PRICE DMIPrice = PRICE_CLOSE;

input double pointsBE = 200;      
input double profit = 0;   

// Global variables
int gBuyTicket,gSellTicket;

void OnTick()   
{
   // Check timer
   bool timerEnabled = true;
   
   if(UserTimer == true)
   {
      timerEnabled = Timer.DailyTimer(StartHour,StartMinute,EndHour,EndMinute,UseLocalTime);
   }
   
   // Creating and modifying pivot points
   datetime timeStart = CreateDateTime(0,0);	
   datetime timeEnd = CreateDateTime(23,0);
   int timeHour = TimeHour(TimeCurrent());

   // I clear the monday pivot problem (where it takes a false hour from saturday and uses it for mondays pivots)     
   int weekday = DayOfWeek();
   int shift = 0; 
   if(weekday == 1) shift = 2; // On monday i make shift = 2 
   if(weekday != 1) shift = 1;
   
   // Creating pivots
   double yclose = iClose(_Symbol,PERIOD_D1,shift); 
   double yhigh = iHigh(_Symbol,PERIOD_D1,shift); 
   double ylow = iLow(_Symbol,PERIOD_D1,shift); 

   string ob_R3 = "r3line "+TimeToStr(timeStart);    
   string ob_R2 = "r2line "+TimeToStr(timeStart);   
   string ob_R1 = "r1line "+TimeToStr(timeStart); 
   string ob_Pivot = "pivotline "+TimeToStr(timeStart);    
   string ob_S1 = "s1line "+TimeToStr(timeStart);    
   string ob_S2 = "s2line "+TimeToStr(timeStart);
   string ob_S3 = "s3line "+TimeToStr(timeStart);  
   
   string ob_MidR2 = "midr2line "+TimeToStr(timeStart);    
   string ob_MidR1 = "midr1line "+TimeToStr(timeStart);   
   string ob_MidPivot = "midPivotline "+TimeToStr(timeStart); 
   string ob_MidS1 = "mids1line "+TimeToStr(timeStart);    
   string ob_MidS2 = "mids2line "+TimeToStr(timeStart);    
   string ob_MidS3 = "mids3line "+TimeToStr(timeStart);   
   
   // Calculation main pivots
   double pivot = MathAbs((yhigh + ylow + yclose)/3);   // objects must be declared in this order
   double S1 = MathAbs(2 * pivot - yhigh);
   double S2 = MathAbs(pivot - (yhigh - ylow));
   double S3 = MathAbs(S1 - (yhigh - ylow));
   double R1 = MathAbs(2 * pivot - ylow);
   double R2 = MathAbs(pivot + (yhigh - ylow));
   double R3 = MathAbs(R1 + (yhigh - ylow));

   // Calculation mid pivots
   double midR2 = MathAbs((R3 - R2) / 2 + R2);
   double midR1 = MathAbs((R2 - R1) / 2 + R1);
   double midPivot = MathAbs((R1 - pivot) / 2 + pivot);        
   double midS1 = MathAbs((pivot - S1) / 2 + S1);
   double midS2 = MathAbs((S1 - S2) / 2 + S2);
   double midS3 = MathAbs((S2 - S3) / 2 + S3); 

   // Creating and modifying main pivot style
   bool objectR3 = ObjectCreate(ob_R3,OBJ_TREND,0,timeStart,R3,timeEnd,R3); 
   bool objectR2 = ObjectCreate(ob_R2,OBJ_TREND,0,timeStart,R2,timeEnd,R2); 
   bool objectR1 = ObjectCreate(ob_R1,OBJ_TREND,0,timeStart,R1,timeEnd,R1);    
   bool objectPivot = ObjectCreate(ob_Pivot,OBJ_TREND,0,timeStart,pivot,timeEnd,pivot);
   bool objectS1 = ObjectCreate(ob_S1,OBJ_TREND,0,timeStart,S1,timeEnd,S1);   
   bool objectS2 = ObjectCreate(ob_S2,OBJ_TREND,0,timeStart,S2,timeEnd,S2);       
   bool objectS3 = ObjectCreate(ob_S3,OBJ_TREND,0,timeStart,S3,timeEnd,S3);         

   // Creating and modifying mid pivot style
   bool objectMidR2 = ObjectCreate(ob_MidR2,OBJ_TREND,0,timeStart,midR2,timeEnd,midR2); 
   bool objectMidR1 = ObjectCreate(ob_MidR1,OBJ_TREND,0,timeStart,midR1,timeEnd,midR1);    
   bool objectMidPivot = ObjectCreate(ob_MidPivot,OBJ_TREND,0,timeStart,midPivot,timeEnd,midPivot);     
   bool objectMidS1 = ObjectCreate(ob_MidS1,OBJ_TREND,0,timeStart,midS1,timeEnd,midS1);   
   bool objectMidS2 = ObjectCreate(ob_MidS2,OBJ_TREND,0,timeStart,midS2,timeEnd,midS2);  
   bool objectMidS3 = ObjectCreate(ob_MidS3,OBJ_TREND,0,timeStart,midS3,timeEnd,midS3);          
   
   ObjectSet(ob_R3,OBJPROP_RAY,false);  
   ObjectSet(ob_R2,OBJPROP_RAY,false);  
   ObjectSet(ob_R1,OBJPROP_RAY,false);  
   ObjectSet(ob_Pivot,OBJPROP_RAY,false);  
   ObjectSet(ob_S1,OBJPROP_RAY,false);  
   ObjectSet(ob_S2,OBJPROP_RAY,false);  
   ObjectSet(ob_S3,OBJPROP_RAY,false);
   
   ObjectSet(ob_MidR2,OBJPROP_RAY,false);  
   ObjectSet(ob_MidR1,OBJPROP_RAY,false);  
   ObjectSet(ob_MidPivot,OBJPROP_RAY,false);  
   ObjectSet(ob_MidS1,OBJPROP_RAY,false);
   ObjectSet(ob_MidS2,OBJPROP_RAY,false);  
   ObjectSet(ob_MidS3,OBJPROP_RAY,false);  
     
   ObjectSet(ob_R3,OBJPROP_STYLE,STYLE_SOLID);  
   ObjectSet(ob_R2,OBJPROP_STYLE,STYLE_SOLID);  
   ObjectSet(ob_R1,OBJPROP_STYLE,STYLE_SOLID);  
   ObjectSet(ob_Pivot,OBJPROP_STYLE,STYLE_SOLID);
   ObjectSet(ob_Pivot,OBJPROP_WIDTH,2);   // Extra width added
   ObjectSet(ob_S1,OBJPROP_STYLE,STYLE_SOLID);  
   ObjectSet(ob_S2,OBJPROP_STYLE,STYLE_SOLID);  
   ObjectSet(ob_S3,OBJPROP_STYLE,STYLE_SOLID); 
 
   ObjectSet(ob_MidR2,OBJPROP_STYLE,STYLE_DASH);  
   ObjectSet(ob_MidR1,OBJPROP_STYLE,STYLE_DASH);  
   ObjectSet(ob_MidPivot,OBJPROP_STYLE,STYLE_DASH);  
   ObjectSet(ob_MidS1,OBJPROP_STYLE,STYLE_DASH);  
   ObjectSet(ob_MidS2,OBJPROP_STYLE,STYLE_DASH);  
   ObjectSet(ob_MidS3,OBJPROP_STYLE,STYLE_DASH);       

   static bool tradeEnabled = false;
   
   // Find the highs and lows to spot triangle formation   
   int highest1 = iHighest(NULL,0,MODE_HIGH,3,1);        
   double highestHigh1 = High[highest1];    
   int highest2 = iHighest(NULL,0,MODE_HIGH,5,4);        
   double highestHigh2 = High[highest2];    
   int highest3 = iHighest(NULL,0,MODE_HIGH,10,9);        
   double highestHigh3 = High[highest3];    

   int lowest1 = iLowest(NULL,0,MODE_LOW,3,1);        
   double lowestLow1 = Low[lowest1];   
   int lowest2 = iLowest(NULL,0,MODE_LOW,5,4);        
   double lowestLow2 = Low[lowest2];     
   int lowest3 = iLowest(NULL,0,MODE_LOW,10,9);        
   double lowestLow3 = Low[lowest3];    

   // New 3 Bar Triangle
   double high1 = iHigh(_Symbol,PERIOD_H1,1);   
   double high3 = iHigh(_Symbol,PERIOD_H1,3);  
   double low1 = iLow(_Symbol,PERIOD_H1,1);   
   double low3 = iLow(_Symbol,PERIOD_H1,3); 
    
   bool upperTriangle = (highestHigh3 > highestHigh2 && highestHigh2 > highestHigh1);   
   bool lowerTriangle = (lowestLow3 < lowestLow2 && lowestLow2 < lowestLow1);
   //bool triangleAngle = (highestHigh3 - highestHigh1 > 50 * _Point && lowestLow1 - lowestLow3 > 50 * _Point);
   bool triangleAngle = (highestHigh3 - highestHigh2 > 15 * _Point && highestHigh2 - highestHigh1 > 15 * _Point && lowestLow2 - lowestLow3 > 15 * _Point && lowestLow1 - lowestLow2 > 15 * _Point);   
 
   bool barTriangle = (high1 < high3 && low1 > low3);
 
   if(timerEnabled == true && barTriangle == true) tradeEnabled = true; 
   
   // Stradle order condition  
   if(tradeEnabled == true)
   {
      static int barCount = TimeMinute(TimeCurrent());
      barCount++;
         
      // Stochastic Settings to Object and close price from last bar               
      double stochastic1 = iStochastic(NULL,_Period,KPeriod,DPeriod,Slowing,StochMethod,StochPrice,MODE_MAIN,1);   
      double signal1 = iStochastic(NULL,_Period,KPeriod,DPeriod,Slowing,StochMethod,StochPrice,MODE_SIGNAL,1);  
      double stochastic2 = iStochastic(NULL,_Period,KPeriod,DPeriod,Slowing,StochMethod,StochPrice,MODE_MAIN,3);   
      double signal2 = iStochastic(NULL,_Period,KPeriod,DPeriod,Slowing,StochMethod,StochPrice,MODE_SIGNAL,3);  
       
      double iMacMain1 = iMACD(NULL,0,FastPeriod,SlowPeriod,SignalPeriod,iMacPrice,MODE_MAIN,1);
      double iMacSignal1 = iMACD(NULL,0,FastPeriod,SlowPeriod,SignalPeriod,iMacPrice,MODE_SIGNAL,1);
      double iMacMain2 = iMACD(NULL,0,FastPeriod,SlowPeriod,SignalPeriod,iMacPrice,MODE_MAIN,3);
      double iMacSignal2 = iMACD(NULL,0,FastPeriod,SlowPeriod,SignalPeriod,iMacPrice,MODE_SIGNAL,3);
      
      double iMacMain1Big = iMACD(NULL,PERIOD_M30,FastPeriod,SlowPeriod,SignalPeriod,iMacPrice,MODE_MAIN,1);
      double iMacSignal1Big = iMACD(NULL,PERIOD_M30,FastPeriod,SlowPeriod,SignalPeriod,iMacPrice,MODE_SIGNAL,1);
      double iMacMain2Big = iMACD(NULL,PERIOD_M30,FastPeriod,SlowPeriod,SignalPeriod,iMacPrice,MODE_MAIN,3);
      double iMacSignal2Big = iMACD(NULL,PERIOD_M30,FastPeriod,SlowPeriod,SignalPeriod,iMacPrice,MODE_SIGNAL,3);
      
      // DMI Settings to Object and close price from last bar               
      double adxBig1 = iADX(NULL,PERIOD_M30,ADXPeriod,DMIPrice,MODE_MAIN,1);
      double minusdiBig1 = iADX(NULL,PERIOD_M30,ADXPeriod,DMIPrice,MODE_MINUSDI,1);
      double plusdiBig1 = iADX(NULL,PERIOD_M30,ADXPeriod,DMIPrice,MODE_PLUSDI,1);
      double adxBig2 = iADX(NULL,PERIOD_M30,ADXPeriod,DMIPrice,MODE_MAIN,3);
      double minusdiBig2 = iADX(NULL,PERIOD_M30,ADXPeriod,DMIPrice,MODE_MINUSDI,3);
      double plusdiBig2 = iADX(NULL,PERIOD_M30,ADXPeriod,DMIPrice,MODE_PLUSDI,3);

      bool stochBull = (stochastic1 > signal1 && stochastic2 > signal2);
      bool stochBear = (stochastic1 < signal1 && stochastic2 < signal2);

      bool iMacBull = (iMacSignal1 > iMacSignal2);
      bool iMacBear = (iMacSignal1 < iMacSignal2);      

      bool iMacBullBig = (iMacSignal1Big > iMacSignal2Big);
      bool iMacBearBig = (iMacSignal1Big < iMacSignal2Big);
          
      bool trendEnabled = (adxBig1 > 30 && adxBig2 > 30 && adxBig1 > adxBig2);   
      bool dmiLongsEnabled = (trendEnabled == true && plusdiBig1 > minusdiBig1);
      bool dmiShortsEnabled = (trendEnabled == true && plusdiBig1 < minusdiBig1);
      
      // Rules if stoch and macd show signal along with either macdbigger or dmibigger adx > 30 then trade is allowed    
      
      // Buy order condition                               
      if(barCount < 14 && stochBull == true && iMacBull == true && (iMacBullBig == true || dmiLongsEnabled == true) && gBuyTicket == 0)
      {
         // Close sell order
         for(int order = 0; order <= OrdersTotal() - 1; order++)    // for loop finds any open orders
         {                      
            bool select = OrderSelect(order,SELECT_BY_POS);   // selects the open order (Order index or order ticket depending on the second parameter.)(SELECT_BY_POS - index in the order pool) 
         
            if(OrderType() == OP_SELL && OrderMagicNumber() == MagicNumber && select == true) // checking its a sell checking magicnumber matches and it has selected an order
            {
               // Close order
               bool closed = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed);  // Notice you can input functions written OrderTicket() as parameters
               if(closed == true) order--;  // order -- decrements order from 1 to 0 so it will stop iterating
            }
         } 
              
         // Open buy order                                                                                      Section 5
         gBuyTicket = OrderSend(_Symbol,OP_BUY,LotSize,Ask,Slippage,0,0,"Buy order",MagicNumber,0,clrGreen); 
         gSellTicket = 0;    
                        
         // Add stop loss to buy order
         if(gBuyTicket > 0 && StopLoss > 0)
         {
            bool select = OrderSelect(gBuyTicket,SELECT_BY_TICKET);
         
            // Calculate stop loss & take profit
            double stopLoss = 0;
            if(StopLoss > 0) stopLoss = OrderOpenPrice() - (StopLoss * _Point);
         
            // Verify stop loss & take profit
            double stopLevel = MarketInfo(_Symbol,MODE_STOPLEVEL) * _Point;
         
            RefreshRates();
            double upperStopLevel = Ask + stopLevel;
            double lowerStopLevel = Bid - stopLevel;
         
            if(stopLoss >= lowerStopLevel && stopLoss  != 0) stopLoss = lowerStopLevel - _Point; 
         
            // Modify order
            bool modify = OrderModify(gBuyTicket,0,stopLoss,0,0); 
         }           
      }
      
      // Vice versa for sell      
      if(barCount < 14 && stochBear == true && iMacBear == true && (iMacBearBig == true || dmiShortsEnabled == true) && gSellTicket == 0)
      {
         // Close buy order
         for(int order = 0; order <= OrdersTotal() - 1; order++)
         {
            bool select = OrderSelect(order,SELECT_BY_POS);
         
            if(OrderType() == OP_BUY && OrderMagicNumber() == MagicNumber && select == true)
            {
               // Close order
               bool closed = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrRed);          
               if(closed == true) order--;
            }
         }
                    
         // Open sell order
         gSellTicket = OrderSend(_Symbol,OP_SELL,LotSize,Bid,Slippage,0,0,"Sell order",MagicNumber,0,clrRed);
         gBuyTicket = 0;    

         // Add stop loss to sell order
         if(gSellTicket > 0 && StopLoss > 0)
         {
            bool select = OrderSelect(gSellTicket,SELECT_BY_TICKET);
         
            // Calculate stop loss & take profit
            double stopLoss = 0;
            if(StopLoss > 0) stopLoss = OrderOpenPrice() + (StopLoss * _Point);
         
            // Verify stop loss & take profit
            double stopLevel = MarketInfo(_Symbol,MODE_STOPLEVEL) * _Point;
         
            RefreshRates();
            double upperStopLevel = Ask + stopLevel;
            double lowerStopLevel = Bid - stopLevel;

            if(stopLoss <= upperStopLevel && stopLoss != 0) stopLoss = upperStopLevel + _Point; 
         
            // Modify order
            bool modify = OrderModify(gSellTicket,0,stopLoss,0,0);
         }      
      }
  
      // Reset after count   
      if(barCount > 14 && OrdersTotal() == 0)
      {
         barCount = 0;   // reset if barcount ends or if a trade is opened
         tradeEnabled = false; 
         gSellTicket = 0;
         gBuyTicket = 0;
      }
   }
      
   // Stop Management Using Pivots              
   for(int order = 0; order <= OrdersTotal() - 1; order++)
   {
      bool select = OrderSelect(order,SELECT_BY_POS);  
      
      if(OrderMagicNumber() == MagicNumber && select == true)
      {          
         RefreshRates();
           
         // Check buy order for stop placement
         if(OrderType() == OP_BUY)
         {
            static int barCount = TimeMinute(TimeCurrent()); // Counts each bar from order open
            barCount++;  
            
            int highest = iHighest(NULL,0,MODE_HIGH,barCount,0);   
            double highestHigh = High[highest];        
      
            // Pivots to close on Buy Order 
            if(highestHigh > R3) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen);
            if(highestHigh > midR2 && Bid < R2 + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen);                                         
            if(highestHigh > R2 && Bid < midR1 + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen);            
            if(highestHigh > midR1 && Bid < R1 + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen);                             
            if(highestHigh > R1 && Bid < midPivot + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen);                
            if(highestHigh > midPivot && Bid < pivot + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen);                                         
            if(highestHigh > pivot && Bid < midS1 + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen); 
            if(highestHigh > midS1 && Bid < S1 + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen); 
            if(highestHigh > S1 && Bid < midS2 + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen); 
            if(highestHigh > midS2 && Bid < S2 + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen);                                                                                                        
            if(highestHigh > S2 && Bid < midS3 + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen);
            if(highestHigh > midS3 && Bid < S3 + 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrGreen);               
         }
            
         // Check sell order for stop placement
         if(OrderType() == OP_SELL)
         {
            static int barCount = TimeMinute(TimeCurrent()); // Creating this static variable I can use this to count each bar from order open
            barCount++;  
            
            int lowest = iLowest(NULL,0,MODE_LOW,barCount,0);   
            double lowestLow = Low[lowest];             
            
            // Pivots to close on Sell Order            
            if(lowestLow < midR2 && Ask > R3 - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed); 
            if(lowestLow < R2 && Ask > midR2 - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed); 
            if(lowestLow < midR1 && Ask > R2 - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed); 
            if(lowestLow < R1 && Ask > midR1 - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed);                 
            if(lowestLow < midPivot && Ask > R1 - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed);                             
            if(lowestLow < pivot && Ask > midPivot - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed);
            if(lowestLow < midS1 && Ask > pivot - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed);             
            if(lowestLow < S1 && Ask > midS1 - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed);
            if(lowestLow < midS2 && Ask > S1 - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed);               
            if(lowestLow < S2 && Ask > midS2 - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed); 
            if(lowestLow < midS3 && Ask > S2 - 30 * _Point) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed);  
            if(lowestLow < S3) bool orderclose = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed);                  
         }   
      }
   }
   
   if(timeHour == 23 && OrdersTotal() > 0)
   {
      for(int order = 0; order <= OrdersTotal() - 1; order++)
      {
         bool select = OrderSelect(order,SELECT_BY_POS);
         
         if(OrderType() == OP_BUY && OrderMagicNumber() == MagicNumber && select == true)
         {
            // Close order
            bool closed = OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,clrRed);          
            if(closed == true) order--;
         }
         
         if(OrderType() == OP_SELL && OrderMagicNumber() == MagicNumber && select == true) // checking its a sell checking magicnumber matches and it has selected an order
         {
            // Close order
            bool closed = OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,clrRed);  // Notice you can input functions written OrderTicket() as parameters
            if(closed == true) order--;  // order -- decrements order from 1 to 0 so it will stop iterating
         }         
      }
   } 
   
   // BreakEven Stop   
   for(int order = 0; order <= OrdersTotal() - 1; order++)
   {
      bool select = OrderSelect(order,SELECT_BY_POS);
      bool setBreakEvenStop = false;
      
      double breakEvenStop = 0;   
      double currentProfit = 0;

      double orderStopLoss = OrderStopLoss();   
      double minProfit = pointsBE * _Point;
      
      // Check buy order for stop placement         
      if(OrderType() == OP_BUY)
      {
         breakEvenStop = OrderOpenPrice() + (profit * _Point); 
         breakEvenStop = NormalizeDouble(breakEvenStop,_Digits);
            
         orderStopLoss = NormalizeDouble(orderStopLoss,_Digits); 
                        
         currentProfit = Bid - OrderOpenPrice();
         currentProfit = NormalizeDouble(currentProfit,_Digits);
 
         if(breakEvenStop > orderStopLoss && currentProfit >= minProfit)
         {
            setBreakEvenStop = true;
         }                                
      } 
      
      // Check sell order for stop placement 
      if(OrderType() == OP_SELL)
      {
         breakEvenStop = OrderOpenPrice() - (profit * _Point); 
         breakEvenStop = NormalizeDouble(breakEvenStop,_Digits);
             
         orderStopLoss = NormalizeDouble(orderStopLoss,_Digits); 
                 
         currentProfit = OrderOpenPrice() - Ask;
         currentProfit = NormalizeDouble(currentProfit,_Digits);  

         if(breakEvenStop < orderStopLoss && currentProfit >= minProfit)
         {
            setBreakEvenStop = true;
         }         
      }
         
      if(setBreakEvenStop == true)
      {
         select = OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice(),OrderTakeProfit(),0);
      }                 
   }                                                                                   
}