Navigation:Home > Content >

Straddle&Trail_v3.31_GBPUSD.mq4

Time: 2015-04-25 | Download file:Straddle&Trail_v3.31_GBPUSD.mq4

//+-----------------------------------------------------------------------------+
//|                                                   Straddle&Trail GBPUSD.mq4 |
//|                                                    Copyright © 2006, Yannis |
//|                                            CREATED BY:     [email protected] |
//+-----------------------------------------------------------------------------+
//+           v3.30  OPTIMIZED FOR GBP/USD   by [email protected]              +
//+-----------------------------------------------------------------------------+

///////////////////////////////////////////////////////////////////////////////// 
//////////////////////////// READ ME CAREFULLY //////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// TRY IT FIRST ON A DEMO ACCOUNT UNTIL YOU FULLY UNDERSTAND HOW IT WORKS AND  //
// VERIFY YOURSELF THAT IT WORKS CORRECTLY BEFORE PUTTING REAL MONEY IN IT.    //
// THE AUTHOR (that's me :-)) CANNOT BE HELD RESPONSIBLE FOR ANY DAMAGE OR LOSS /
//                   ***  USE IT AT YOUR OWN RISK  ***                         //
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// The ea can manage at the same time manually entered trades at any time (they have a magic number of 0)
// AND/OR a straddle (Long and Short pending positions - Stop orders) that is placed for a news event
// at a specific time of the day by the ea. If you want to use only it as a Trailing expert for your manual
// entries i would suggest to set the "Enable.News.Trading" parameter to False (it is by default).
//
// The manual trades are checked against Symbol() and MagicNumber=0 so if you have other experts running 
// on the same pair assuming they assign a magic number > 0 to the trades, you won't have any problems between 
// the manual trades and those from your expert. 
//
// The trades entered by the expert are checked against Symbol() Period() and an automatically given Magic Number
// so here also absolutely no problem if you have other experts running. 
//
// The positions are tracked through the PosCounter() procedure
// which checks for :   b.ticket  / s.ticket    ==> Ticket # from Orders actually triggered BY THE EA, if any, otherwise = 0.
//                      b.ticketP / s.ticketP   ==> Ticket # from Pending Stop Orders NOT TRIGGERED (the straddle).
//                      b.ticketM / s.ticketM   ==> Ticket # from Orders entered Manually.
// The manually entered positions are tracked as far as SL, TP, BE, partial exits and Trail are concerned, 
// and are totally unaffected by the straddle.
//
/////////////////////////////////////////////////////////////////////////////////
//////////////////  BASIS SETTINGS AND HOW TO USE IT ////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// IF YOU WANT TO USE THE EXPERT FOR NEWS EVENTS, MAKE USRE TO SET "Enable.News.Trading" TO TRUE 
// AND "Place.Straddle.Immediately" TO FALSE. IN THAT CASE, ONCE A POSITION IS TRIGGERED, THE EA 
// WILL NOT PLACE ANOTHER STRADDLE AGAIN UNTIL YOU INITIALIZE IT (BY CHANGING TIME FRAME OR 
// DISABLING AND ENABLING THE EA AGAIN.
// 
// IF YOU WANT TO USE THE EXPERT FOR STRADDLING A NARROW RANGE BREAKOUT, UNRELATED TO NEWS, 
// MAKE SURE TO SET "Enable.News.Trading" TO FALSE AND "Place.Straddle.Immediately" TO TRUE. 
// IN THAT CASE, ONCE A POSITION IS TRIGGERED AND CLOSED AT ANY POINT, THE EA WILL PUT A
// NEW STRADDLE AGAIN. 
// 
// IF YOU WANT THE EXPERT TO SIMPLY TAKE CARE OF YOUR MANUAL POSITION AND TOTALLY DISABLE ANY OTHER STRADDLE
// FEATURES, MAKE SURE TO SET "Enable.News.Trading" TO FALSE AND "Place.Straddle.Immediately" TO FALSE. 
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
//
//
// The Stop Orders entered before the news release, either immediately if "Pre.Event.Entry.Minutes"=0 or
// xx minutes before the event and they are tracked and adjusted ONCE EVERY MINUTE, from the moment
// they are entered by the ea until a few minutes before the event (specified by "Stop.Adjusting.Min.Before.Event" parameter) 
// modifying their entry price, stop loss and take profit, according to current Bid and Ask, if "Adjust.Pending.Orders"=True.
// Once one of them is triggered, the opposite one is removed if "Remove.Opposite.Order" = True.
// 
// Another way of entering a straddle is by setting the "Place.Straddle.Immediately" to True. In that case,
// The time event settings will be ignored and the long and short pending orders that will be entered immediately
// will not be adjusted according to price like they are when this parameter is set to false and we use the ea for
// news release. This is to be used as a narrow range, low volume breakout strategy like for instance during a ranging 
// Asian period.
//
// The "ShutDown.NOW" parameter will shut down all the trades specified by "ShutDown.What" parameter.
// On the ea's input tab you can see the possible values but here they are again as a reference.
// ShutDown.What ==>    0=Everything, 1=All Triggered Positions,  2=Triggered Long
//                      3=Triggered Short, 4=All Pending Positions, 5=Pending Long, 6=Pending Short
// If "ShutDown.Current.Pair.Only" then the ea will close all trades for the pair on which this parameter was set to true
// otherwise it will close ALL the trades on ALL the pairs. 
/////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////// Note 2 ////////////////////////////////////////// 
// The ea will check the minimum distance allowed from the broker 
// against the trail, stop loss and take profit values specified by the user
// in the expert parameters tab. If these values are below the allowed distance
// they will be automatically adjusted to that minimum value
/////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////// Note 3 ////////////////////////////////////////// 
// Scaling Out.
// Assuming we have a position triggered with 3 lots, either manually or through the Straddle. 
// If we set the "Take.Out.Lots" parameter to 1, then each time the position will be in
// profit by the number of pips specified by "Trail.Pips" parameter, the expert will close 
// 1 lot. Another "Trail.Pips" profit later, it will close another lot etc...
// The Trail.Pips parameter is used in this case as steps for each lot to be taken out
// So if we use 3 lots and "Trail.Pips" is set to 15, then if all goes well, we will have
// 1 lot closed at +15, the second at +30 and the 3rd at +45. All this can be combined
// with the other trailing parameters below.
/////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////// Note 4 ////////////////////////////////////////// 
// How to use the ea so it takes over manually entered trades.
// As soon as a position is manually initiated, the expert will check a few things. 
// 1. if your position has no SL or TP, it will modify the position and use the StopLoss.Pips
//    and the TakeProfit.Pips to place SL and TP.
// 2. Assuming you want to trail a position at 15 pips distance, all you have to do is
//    set the "Trail.Pips" parameter to 15 or to any other value you see fit.
// 3. You will find also 3 other parameters which are related to how the trail will behave
//    a) "Trail.Starts.After.BreakEven" If set to true, then your trailing will only start
//       after breakeven is accomplished. This parameter is independent from next 2.
//    b) "Move.To.BreakEven.at.pips" You specify here the amount of pips which once your
//       trade is xx pips in profit the ea will move your SL to breakeven. This means
//       that if you set it to 10, the ea will move to B/E once you are at +10.
//    c) "Move.To.BreakEven.Lock.pips" Amount of pips to secure once B/E is reached.
//       If you set it to 1, then with the previous parameter set to 10, this means
//       the expert will move your SL at +1 once your trade is at +10
//
// So let's see some scenarios:
// Assuming we want to simply trail a position by 20 pips we can set:
// Trail.Pips=20
// Trail.Starts.After.BreakEven=False
// Move.To.BreakEven.Lock.pips= ANYTHING it isn't needed
// Move.To.BreakEven.at.pips  = ANYTHING it isn't needed
//
// Assuming we want to trail a position by 15 pips and just securing 1 pip
// once 10 pips of profit are made:
// Trail.Pips=15
// Trail.Starts.After.BreakEven=False
// Move.To.BreakEven.Lock.pips=1
// Move.To.BreakEven.at.pips  =10
//
// Assuming we want to trail a position by 15 pips but only after 
// price moves 20 pips in our favor. We also want to at that point
// to secure 5 pips:
// Trail.Pips=15
// Trail.Starts.After.BreakEven=True
// Move.To.BreakEven.Lock.pips=5
// Move.To.BreakEven.at.pips  =20
//
// I guess you've go the idea
/////////////////////////////////////////////////////////////////////////////////////


#include  
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////// EA PARAMETERS / USER INPUTS /////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
extern bool    ShutDown.NOW=False;                 // If true ALL POSITIONS (open and/or pending) will be closed/deleted
                                                   // based on "ShutDown.What" flag below
                                                   // This parameter is the first on the list so the user can access it
                                                   // as quickly as possible.
extern string  sStr00=" 0=Everything               ";
extern string  sStr01=" 1=All Triggered Positions  ";
extern string  sStr02=" 2=Triggered Long           ";
extern string  sStr03=" 3=Triggered Short          ";
extern string  sStr04=" 4=All Pending Positions    ";
extern string  sStr05=" 5=Pending Long             ";
extern string  sStr06=" 6=Pending Short            ";
extern int     ShutDown.What=0;
extern bool    ShutDown.Current.Pair.Only=True;    // If true, ALL trades for CURRENT pair will be shutdown (no matter what time frame).
                                                   // If False, ALL trades on ALL pairs will be shutdown.
extern string  sStr1="=== POSITION DETAILS ===";
extern double  Lots = 1;
extern double  Take.Out.Lots  = 0;               // When Target is reached, ea will close this amount of lots
                                                   // extending next target by 'Trail.Pips'
extern int     Slippage=3;
extern int     StopLoss.Pips=30;                   // Initial stop loss. 
extern int     TakeProfit.Pips=60;                 // Initial take profit.
extern int     Trail.Pips=15;                      // Trail.
extern bool    Trail.Starts.After.BreakEven=false;  // if true trailing will start after a profit of "Move.To.BreakEven.at.pips" is made

extern int     Move.To.BreakEven.Lock.pips=5;      // Pips amount to lock once trade is in profit 
                                                   // by the number of pips specified with "Move.To.BreakEven.at.pips"
                                                   // Unused if Trail.Starts.After.BreakEven=False

extern int     Move.To.BreakEven.at.pips=15;       // trades in profit will move to entry price + Move.To.BreakEven.Lock.pips as soon as trade 
                                                   // is at entry price + Move.To.BreakEven.at.pips
                                                                 
                                                   // i.e. Entry price on a long order is @ 1.2100
                                                   // when price reaches 1.2110 (Entry price + "Move.To.BreakEven.at.pips")
                                                   // the ea will lock 1 pip moving sl 
                                                   // at 1.2101 (Entry price+ "Move.To.BreakEven.Lock.pips=1")

extern string  sStr2="=== NEWS EVENT ===";
extern bool    Enable.News.Trading=true;          // If set to False, the ea works only as a 'trailer' on manual trades.

extern int     Distance.From.Price=35;             // Initial distance from price for the 2 pending orders.

extern int     Event.Start.Hour=7;                // Event start time = Hour.      Broker's time.

extern int     Event.Start.Minutes=1;             // Event start time = Minutes.   Broker's time.
                                                   // IF YOU WANT TO DISABLE THE "NEWS" FEATURE (the straddle)
                                                   // SET BOTH PARAMETERS TO 0.

extern int     Pre.Event.Entry.Minutes=1;         // Number of minutes before event where the ea will place the straddle.
                                                   // If set to 0, the ea will place the straddle immediately when activated,
                                                   // otherwise xx minutes specified here before above Event start time.

extern int     Stop.Adjusting.Min.Before.Event=2;  // Minutes before the event where the EA will stop adjusting
                                                   // the pending orders. The smallest value is 1 min.

extern bool    Remove.Opposite.Order=false;         // if true, once the 1st of the 2 pending orders is triggered, 
                                                   // the opposite pending one is removed otherwise left as is.

extern bool    Adjust.Pending.Orders=false;         // if true, once the pending orders are placed at
                                                   // "Pre.Event.Start.Minutes" minutes before the event's time, 
                                                   // the ea will try to adjust the orders ONCE EVERY MINUTE until
                                                   // "Stop.Adjusting.Min.Before.Event" minutes before the release where
                                                   // it will stay put. 

extern bool    Place.Straddle.Immediately=False;   // if true, the straddle will be placed immediately once the 
                                                   // expert is activated. This overrides previous 'News Events' 
                                                   // settings for placing the long and short pending orders and 
                                                   // in that case, the positions WILL NOT BE ADJUSTED. 
                                                   // The "Enable.News.Trading" parameter is also bypassed.
                                                   // This is to be used as a "quiet" range breakout, for example if we 
                                                   // want to play a "regular" breakout during Asian Session for example
                                                   // or at any other time of the day where the market is rangebound
                                                   
extern bool    MoneyManagement=false;
extern int     Risk           =5;

extern string  EOD            ="0000";                                                   

/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////// EA PARAMETERS / USER INPUTS /////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

int  EODHour;
int  EODMinute;
bool CloseAllComplete=false;

int iMinimum,Last.Ticket,b.ticket,s.ticket,b.ticketP,s.ticketP,b.ticketM,s.ticketM,Magic,OpenTrades,ActualPipsProfit,ActualPipsProfitM,tr;
int Retry,HourNow,MinutesNow,LastMin,MyErr,OpenPositions,OpenLongM,OpenShortM,OpenLong,OpenShort,OpenLongP,OpenShortP;
string comment=" Straddle&Trail GBPUSD",ScreenComment="Straddle&Trail v3.30 GBPUSD",NewsLabel="",sHour,sMin;
bool SupplyMagicNumber=True,IsOK=False,TradeInitiated;
double LongEntryLevel,ShortEntryLevel,SL,TP,NextTargetM, NextTarget;

int init()
{  comments();
   if ((Event.Start.Hour>=0) && (Event.Start.Hour<=9)) sHour="0";
   else sHour="";
   if ((Event.Start.Minutes>=0) && (Event.Start.Minutes<=9)) sMin="0";
   else sMin="";
   if (!Enable.News.Trading) NewsLabel=ServerTime()+"  No News Event Scheduled";
   else NewsLabel=(ServerTime()+"    NEWS SCHEDULED FOR ("+sHour+Event.Start.Hour+":"+sMin+Event.Start.Minutes+")");
   ObjectDelete("Yannis");
   YannisCustomText( "Yannis", 15, 15,1);
   ObjectSetText( "Yannis", "[email protected]"  , 10, "Times New Roman", Yellow );
   ObjectDelete("Yannis2");
   YannisCustomText( "Yannis2", 15, 15,3);
   ObjectSetText( "Yannis2", NewsLabel , 10, "Tahoma", Yellow );
   TradeInitiated=False;
   return(0);
}

int deinit()
{  ObjectDelete("Yannis");
   ObjectDelete("Yannis2");
   return(0);
}

int start()
{  

//----------- Money Management feature, added by Azmel
   if (MoneyManagement)
   {
      if (Risk<1 || Risk>100)
      {
         Comment("Invalid Risk Value.");
         return(0);
      }
      else
      {
         Lots=MathFloor((AccountFreeMargin()*AccountLeverage()*Risk*Point*100)/(Ask*MarketInfo(Symbol(),MODE_LOTSIZE)*MarketInfo(Symbol(),MODE_MINLOT)))*MarketInfo(Symbol(),MODE_MINLOT);
      }
   }
//----------- end of Money Management subroutine.   

//----------- Close Trade on EOD time.
   if (StringLen(EOD)==4)
   {
      EODHour=StrToInteger(StringSubstr(EOD,0,2));
      EODMinute=StrToInteger(StringSubstr(EOD,2,2));
      if (EODHour<0 || EODHour>23 || EODMinute<0 || EODMinute>59)
      {
         Comment("EOD Time Error.");
         return(0);
      }
      else
      {
         if (Hour()==EODHour && Minute()>=EODMinute)
         {
            if (CloseAllComplete==false)
            {
               if (TotalOrders()==0)
               {
                  CloseAllComplete=true;
               }
               else
               {
                  CloseAllOrders();
                  return(0);
               }
            }
         }
         else
         {
            CloseAllComplete=false;
         }
      }
   }
//----------- end of Close Trade on EOD time subroutine.

   iMinimum=MarketInfo(Symbol(),MODE_STOPLEVEL); // check the minimum pip distance allowed from broker for sl and tp
   int EventAboutToStart=IsItEventTime();
   if ((Event.Start.Hour>=0) && (Event.Start.Hour<=9)) sHour="0";
   else sHour="";
   if ((Event.Start.Minutes>=0) && (Event.Start.Minutes<=9)) sMin="0";
   else sMin="";
   if (!Enable.News.Trading) NewsLabel=ServerTime()+"  No News Event Scheduled";
   else NewsLabel=(ServerTime()+"    NEWS SCHEDULED FOR ("+sHour+Event.Start.Hour+":"+sMin+Event.Start.Minutes+")");
   Magic=CalcMagic  (Symbol(),Period());
   if (StopLoss.Pips  0)) ShutDownAllTrades(ShutDown.What);

   PosCounter(); 
   CheckInitialSLTP(); // If a position is entered without initial SL / TP then place the initial stops
   
   // If no open or pending positions, AND the event start hour and minute is not 0, place the 2 pending orders
   //    If Pre.Event.Entry.Minutes=0 (immediately) or
   //    else Pre event minutes before event time  
   if ( ((IsTimeToPlaceEntries()) && (Enable.News.Trading) && (!TradeInitiated)) || (Place.Straddle.Immediately))
   {  if ((s.ticketP==0) && 
          (b.ticketP==0) && 
          (s.ticket ==0) && 
          (b.ticket ==0)) PlaceTheStraddle();   
   }
   
   PosCounter(); 
   // If both pending orders are placed and no trades actually opened 
   // and we are not into the specified minutes before the event, then we adjust our positions
   // according to current price automatically every new minute
   if ((EventAboutToStart==0) && 
       (s.ticketP >0)         && 
       (b.ticketP >0)         && 
       (s.ticket ==0)         && 
       (b.ticket ==0)         &&
       (MinutesNow!=LastMin)  &&
       (Adjust.Pending.Orders)&&
       (Enable.News.Trading)  &&
       (!Place.Straddle.Immediately)) AdjustPendingOrders(); 
      
   // If parameter "Remove.Opposite.Order" is set to True, remove non triggered opposite pending order
   PosCounter();
   if (Remove.Opposite.Order)
   {  if (((s.ticket>0) && (b.ticketP>0)) || 
          ((b.ticket>0) && (s.ticketP>0))) RemoveOppositePending();
   }
   
   // If a position is triggered, either manual or from ea, trail it.
   PosCounter();
   if ((s.ticket>0) || (b.ticket>0) || (b.ticketM>0) || (s.ticketM>0))
   {  if (Move.To.BreakEven.at.pips!=0) MoveToBreakEven(); // Check if must secure position
      ScaleOut();                                          // Check if we can partially close a position  
      Trail.Stop();                                        // Check trailing methods
   }

   comments();
   return(0);
}
  
bool IsTimeToPlaceEntries()
{  return (((Pre.Event.Entry.Minutes==0) || ( (HourNow==Event.Start.Hour)                                 && 
                                              (MinutesNow>=(Event.Start.Minutes-Pre.Event.Entry.Minutes)) &&
                                              (MinutesNow<=Event.Start.Minutes)
                                            )
           ) && (Event.Start.Hour>0) && (Event.Start.Minutes>0)
          );
}

int IsItEventTime()
{  HourNow   =TimeHour  (CurTime());
   MinutesNow=TimeMinute(CurTime());

   ////////////////////////////////////////////
   if ((HourNowEvent.Start.Hour))           return (0); 
   if ((HourNow==Event.Start.Hour) && (MinutesNow>Event.Start.Minutes))    return (0); 
   // Will return 0 if the event is not started or is over.
   ////////////////////////////////////////////
   
   if (Stop.Adjusting.Min.Before.Event<1)          Stop.Adjusting.Min.Before.Event=1;
   if (Stop.Adjusting.Min.Before.Event>Period())   Stop.Adjusting.Min.Before.Event=Period();
   
   return ( (HourNow==Event.Start.Hour)                                          && 
            (MinutesNow>=(Event.Start.Minutes-Stop.Adjusting.Min.Before.Event))  &&
            (MinutesNow<=Event.Start.Minutes)
          ); 
   // Will return 0 hence allowing the ea to adjust its pending orders until minutes reaches 
   // range between (Event.Start.Minutes-Stop.Adjusting.Min.Before.Event) and Event.Start.Minutes range where the ea will return 1.
   // For example if the event is scheduled for 12.40, and we have set the 
   // Stop.Adjusting.Min.Before.Event parameter to 2, then until 12.27:59 the ea will adjust the pending orders.
   // From 12.28 and after it will stop adjusting and stay put.
}

void PlaceTheStraddle() 
{  int Retry=0;
   if (!((Place.Straddle.Immediately) || ((Enable.News.Trading) && (!TradeInitiated)))) return(0);
   double ShortEntryLevel, LongEntryLevel, TP, SL;
   if (StopLoss.Pips  ==0) StopLoss.Pips  =999;
   if (TakeProfit.Pips==0) TakeProfit.Pips=999;
   
   while (s.ticketP==0)
   {  while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
      RefreshRates();
      ShortEntryLevel=NormalizeDouble(Bid-(Distance.From.Price*Point),Digits);
      SL             =NormalizeDouble(ShortEntryLevel+(StopLoss.Pips*Point),Digits);
      TP             =NormalizeDouble(ShortEntryLevel-(TakeProfit.Pips*Point),Digits);
      Last.Ticket=OrderSend(  Symbol()          ,
                              OP_SELLSTOP       ,
                              Lots              ,
                              ShortEntryLevel   ,
                              Slippage          ,
                              SL                ,
                              TP                ,
                              "Straddle&Trail "+DoubleToStr(Period(),0)+"min ",
                              Magic             ,
                              0                 ,
                              OrangeRed);
      if (Last.Ticket<=0) 
      {  Print("Error opening SellStop  ",ErrorDescription(GetLastError()),"  Ask=",Ask,"   Bid=",Bid,"   Entry @ ",ShortEntryLevel,"   SL=",SL,"    TP=",TP); 
      }
      PosCounter();
   }
   while (b.ticketP==0)
   {  Retry=0;
      while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
      RefreshRates();
      LongEntryLevel =NormalizeDouble(Ask+(Distance.From.Price*Point),Digits);
      SL             =NormalizeDouble(LongEntryLevel-(StopLoss.Pips*Point),Digits);
      TP             =NormalizeDouble(LongEntryLevel+(TakeProfit.Pips*Point),Digits);
      Last.Ticket=OrderSend(  Symbol()          ,
                              OP_BUYSTOP        ,
                              Lots              ,
                              LongEntryLevel    ,
                              Slippage          ,
                              SL                ,
                              TP                ,
                              "Straddle&Trail "+DoubleToStr(Period(),0)+"min ",
                              Magic             ,
                              0                 ,
                              RoyalBlue);
      if (Last.Ticket<=0) 
      {  Print("Error opening BuyStop  ",ErrorDescription(GetLastError()),"  Ask=",Ask,"   Bid=",Bid,"   Entry @ ",LongEntryLevel,"   SL=",SL,"    TP=",TP); 
      }
      PosCounter();
   }
}

void RemoveOppositePending()
{  if (b.ticketP>0) 
   {  OrderSelect(b.ticketP,SELECT_BY_TICKET);
      Retry=0; while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
      OrderDelete(b.ticketP);
      int MyErr=GetLastError();
      if (MyErr>0) Print("Error Removing Long Pending Order ticket=",b.ticketP,"  ",ErrorDescription(GetLastError())); 
   }   
   if (s.ticketP>0) 
   {  OrderSelect(s.ticketP,SELECT_BY_TICKET);
      Retry=0; while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
      OrderDelete(s.ticketP);
      MyErr=GetLastError();
      if (MyErr>0) Print("Error Removing Short Pending Order ticket=",s.ticketP,"  ",ErrorDescription(GetLastError())); 
   }   
}

void AdjustPendingOrders()
{  IsOK=False;
   // Adjust pending Long order
   while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
   RefreshRates();
   LongEntryLevel =NormalizeDouble(Ask+(Distance.From.Price*Point),Digits);
   SL             =NormalizeDouble(LongEntryLevel-(StopLoss.Pips*Point),Digits);
   TP             =NormalizeDouble(LongEntryLevel+(TakeProfit.Pips*Point),Digits);
   OrderModify(b.ticketP,LongEntryLevel,SL,TP,OrderExpiration(),MediumSpringGreen);
   MyErr=GetLastError();
   if (MyErr>0) Print("Error Adjusting Long Pending Order ticket=",b.ticketP,"  ",ErrorDescription(GetLastError())); 
   else
   {  Sleep(3000);
      // Adjust pending Short order
      while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
      RefreshRates();   
      ShortEntryLevel=NormalizeDouble(Bid-(Distance.From.Price*Point),Digits);
      SL             =NormalizeDouble(ShortEntryLevel+(StopLoss.Pips*Point),Digits);
      TP             =NormalizeDouble(ShortEntryLevel-(TakeProfit.Pips*Point),Digits);
      OrderModify(s.ticketP,ShortEntryLevel,SL,TP,OrderExpiration(),MediumVioletRed);
      MyErr=GetLastError();
      if (MyErr>0) Print("Error Adjusting Short Pending Order ticket=",s.ticketP,"  ",ErrorDescription(GetLastError())); 
      else
      {  LastMin=MinutesNow; // Resetting the "counter" to current minute so the ea adjusts only every 1 minute
         Sleep(3000);
      }   
   }
}

void PosCounter()
{  b.ticket=0;s.ticket=0;b.ticketP=0;s.ticketP=0;OpenTrades=0;
   for (int cnt=OrdersTotal()-1;cnt>=0;cnt--)
   {  OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      // Trades entered by the EA
      if (OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
      {  if (OrderType()==OP_SELL)     {s.ticket =OrderTicket();} 
         if (OrderType()==OP_SELLSTOP) {s.ticketP=OrderTicket();}
         if (OrderType()==OP_BUY)      {b.ticket =OrderTicket();}
         if (OrderType()==OP_BUYSTOP)  {b.ticketP=OrderTicket();}
         OpenTrades++;
         if ((OpenTrades>0) && (Enable.News.Trading) && (!Place.Straddle.Immediately)) {TradeInitiated=True;}
      }
      // Manually Entered Trades (No Magic Number)
      else 
      if (OrderSymbol()==Symbol() && OrderMagicNumber()==0)
      {  if (OrderType()==OP_SELL)     {s.ticketM=OrderTicket();}
         if (OrderType()==OP_BUY)      {b.ticketM=OrderTicket();}
         OpenTrades++;
      }
   }
}

void ScaleOut()
{  double dLots, PrevClose;
   for (int cnt=OrdersTotal()-1;cnt>=0;cnt--)
   {  OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);

      /////////////// Straddle positions ///////////////
      if ((OrderType()==OP_BUY) && (OrderSymbol()==Symbol()) && (OrderMagicNumber()==Magic))
      {  if (NextTarget == 0.0000) {NextTarget = NormalizeDouble(OrderOpenPrice()+(Trail.Pips*Point),Digits);}
         RefreshRates();
         ActualPipsProfit = (NormalizeDouble(Bid - OrderOpenPrice(),Digits)/Point);
         if (Bid>=NextTarget)
         {  PrevClose=NextTarget;
           // Close 1 lot
            if (OrderLots()>Take.Out.Lots)   {dLots=Take.Out.Lots;}
            else                             {dLots=0.00;}
            if (dLots>0.00)
            {  tr=0; while (tr<5 && !IsTradeAllowed()) { tr++; Sleep(2000); }
               if (OrderClose(OrderTicket(), dLots, Bid, Slippage, YellowGreen))
               {  RefreshRates();
                  NextTarget=PrevClose+(Trail.Pips*Point) ;
                  Sleep(2000);
               }
               else Print("Error Closing Long Entry Target @ ",NormalizeDouble(NextTarget,Digits));
            }
         }
      }
      else
      if ( (OrderType()==OP_SELL) && (OrderSymbol()==Symbol()) && (OrderMagicNumber()==Magic) )
      {  if (NextTarget == 0.0000) {NextTarget = NormalizeDouble(OrderOpenPrice()-(Trail.Pips*Point),Digits);}
         RefreshRates();
         ActualPipsProfit = NormalizeDouble(OrderOpenPrice()-Ask,Digits)/Point;
         if (Ask<=NextTarget)
         {  PrevClose=NextTarget;
            // Close 1 lot
            if (OrderLots()>Take.Out.Lots)   {dLots=Take.Out.Lots;}
            else                             {dLots=0.00;}
            if (dLots>0.00)
            {  tr=0; while (tr<5 && !IsTradeAllowed()) { tr++; Sleep(2000); }
               if (OrderClose(OrderTicket(), dLots, Ask, Slippage, YellowGreen))
               {  RefreshRates();
                  NextTarget=PrevClose-(Trail.Pips*Point) ;
                  Sleep(2000);
               }
               else Print("Error Closing Short Entry Target @ ",NormalizeDouble(NextTarget,Digits));
            }
         }
      }
      /////////////// Manual positions ///////////////
      if ((OrderType()==OP_BUY) && (OrderSymbol()==Symbol()) && (OrderMagicNumber()==0))
      {  if (NextTargetM == 0.0000) {NextTargetM = NormalizeDouble(OrderOpenPrice()+(Trail.Pips*Point),Digits);}
         RefreshRates();
         ActualPipsProfitM = (NormalizeDouble(Bid - OrderOpenPrice(),Digits)/Point);
         if (Bid>=NextTargetM)
         {  PrevClose=NextTargetM;
           // Close 1 lot
            if (OrderLots()>Take.Out.Lots)   {dLots=Take.Out.Lots;}
            else                             {dLots=0.00;}
            if (dLots>0.00)
            {  tr=0; while (tr<5 && !IsTradeAllowed()) { tr++; Sleep(2000); }
               if (OrderClose(OrderTicket(), dLots, Bid, Slippage, YellowGreen))
               {  RefreshRates();
                  NextTargetM=PrevClose+(Trail.Pips*Point) ;
                  Sleep(2000);
               }
               else Print("Error Closing Long Entry Target @ ",NormalizeDouble(NextTargetM,Digits));
            }
         }
      }
      else
      if ( (OrderType()==OP_SELL) && (OrderSymbol()==Symbol()) && (OrderMagicNumber()==0) )
      {  if (NextTargetM == 0.0000) {NextTargetM = NormalizeDouble(OrderOpenPrice()-(Trail.Pips*Point),Digits);}
         RefreshRates();
         ActualPipsProfitM = NormalizeDouble(OrderOpenPrice()-Ask,Digits)/Point;
         if (Ask<=NextTargetM)
         {  PrevClose=NextTargetM;
            // Close 1 lot
            if (OrderLots()>Take.Out.Lots)   {dLots=Take.Out.Lots;}
            else                             {dLots=0.00;}
            if (dLots>0.00)
            {  tr=0; while (tr<5 && !IsTradeAllowed()) { tr++; Sleep(2000); }
               if (OrderClose(OrderTicket(), dLots, Ask, Slippage, YellowGreen))
               {  RefreshRates();
                  NextTargetM=PrevClose-(Trail.Pips*Point) ;
                  Sleep(2000);
               }
               else Print("Error Closing Short Entry Target @ ",NormalizeDouble(NextTargetM,Digits));
            }
         }
      }

   }
}

void Trail.With.Standard.Trailing(int AfterBE)
{  double bsl, b.tsl, ssl, s.tsl;
   PosCounter();
   RefreshRates();
   if (AfterBE==0)
   {  if (b.ticket>0)
      {  bsl=Trail.Pips*Point;
         OrderSelect(b.ticket,SELECT_BY_TICKET);
         //determine if stoploss should be modified
         if(Bid>(OrderOpenPrice()+bsl) && OrderStopLoss()<(OrderOpenPrice()+(Bid-(OrderOpenPrice()+bsl))))
         {  b.tsl=NormalizeDouble(OrderOpenPrice()+(Bid-(OrderOpenPrice()+bsl)),Digits);
            Print("b.tsl ",b.tsl);
            if (OrderStopLoss()0)
      {  ssl=Trail.Pips*Point;
         //determine if stoploss should be modified
         OrderSelect(s.ticket,SELECT_BY_TICKET);
         if (Ask<(OrderOpenPrice()-ssl) && OrderStopLoss()>(OrderOpenPrice()-(OrderOpenPrice()-ssl)-Ask))
         {  s.tsl=NormalizeDouble(OrderOpenPrice()-((OrderOpenPrice()-ssl)-Ask),Digits);
            Print("s.tsl ",s.tsl);
            if (OrderStopLoss()>s.tsl)
            {  while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
               OrderModify(s.ticket,OrderOpenPrice(),s.tsl,OrderTakeProfit(),OrderExpiration(),MediumVioletRed);
               Sleep (2000);
            }
         }
      }
      if (b.ticketM>0)
      {  bsl=Trail.Pips*Point;
         OrderSelect(b.ticketM,SELECT_BY_TICKET);
         //determine if stoploss should be modified
         if(Bid>(OrderOpenPrice()+bsl) && OrderStopLoss()<(OrderOpenPrice()+(Bid-(OrderOpenPrice()+bsl))))
         {  b.tsl=NormalizeDouble(OrderOpenPrice()+(Bid-(OrderOpenPrice()+bsl)),Digits);
            Print("b.tsl ",b.tsl);
            if (OrderStopLoss()0)
      {  ssl=Trail.Pips*Point;
         //determine if stoploss should be modified
         OrderSelect(s.ticketM,SELECT_BY_TICKET);
         if (Ask<(OrderOpenPrice()-ssl) && OrderStopLoss()>(OrderOpenPrice()-(OrderOpenPrice()-ssl)-Ask))
         {  s.tsl=NormalizeDouble(OrderOpenPrice()-((OrderOpenPrice()-ssl)-Ask),Digits);
            Print("s.tsl ",s.tsl);
            if (OrderStopLoss()>s.tsl)
            {  while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
               OrderModify(s.ticketM,OrderOpenPrice(),s.tsl,OrderTakeProfit(),OrderExpiration(),MediumVioletRed);
               Sleep (2000);
            }
         }
      }

   }
   else // If Trail.Starts.After.BreakEven
   {  if (b.ticket>0)
      {  OrderSelect(b.ticket,SELECT_BY_TICKET);
         if (Bid>=(OrderOpenPrice()+(Move.To.BreakEven.at.pips*Point)))
         {  bsl=Trail.Pips*Point;
            if (Bid>(OrderOpenPrice()+bsl) && OrderStopLoss()<(OrderOpenPrice()+(Bid-(OrderOpenPrice()+bsl))))
            {  b.tsl=NormalizeDouble(OrderOpenPrice()+(Bid-(OrderOpenPrice()+bsl)),Digits);
               Print("b.tsl ",b.tsl);
               if (OrderStopLoss()0)
      {  OrderSelect(s.ticket,SELECT_BY_TICKET);
         if (Ask<=(OrderOpenPrice()-(Move.To.BreakEven.at.pips*Point)))
         {  ssl=Trail.Pips*Point;
            //determine if stoploss should be modified
            if(Ask<(OrderOpenPrice()-ssl) && OrderStopLoss()>(OrderOpenPrice()-(OrderOpenPrice()-ssl)-Ask))
            {  s.tsl=NormalizeDouble(OrderOpenPrice()-((OrderOpenPrice()-ssl)-Ask),Digits);
               Print("s.tsl ",s.tsl);
               if(OrderStopLoss()>s.tsl)
               {  while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
                  OrderModify(s.ticket,OrderOpenPrice(),s.tsl,OrderTakeProfit(),OrderExpiration(),MediumVioletRed);
                  Sleep (2000);
               }
            }
         }
      }
      if (b.ticketM>0)
      {  OrderSelect(b.ticketM,SELECT_BY_TICKET);
         if (Bid>=(OrderOpenPrice()+(Move.To.BreakEven.at.pips*Point)))
         {  bsl=Trail.Pips*Point;
            if (Bid>(OrderOpenPrice()+bsl) && OrderStopLoss()<(OrderOpenPrice()+(Bid-(OrderOpenPrice()+bsl))))
            {  b.tsl=NormalizeDouble(OrderOpenPrice()+(Bid-(OrderOpenPrice()+bsl)),Digits);
               Print("b.tsl ",b.tsl);
               if (OrderStopLoss()0)
      {  OrderSelect(s.ticketM,SELECT_BY_TICKET);
         if (Ask<=(OrderOpenPrice()-(Move.To.BreakEven.at.pips*Point)))
         {  ssl=Trail.Pips*Point;
            //determine if stoploss should be modified
            if(Ask<(OrderOpenPrice()-ssl) && OrderStopLoss()>(OrderOpenPrice()-(OrderOpenPrice()-ssl)-Ask))
            {  s.tsl=NormalizeDouble(OrderOpenPrice()-((OrderOpenPrice()-ssl)-Ask),Digits);
               Print("s.tsl ",s.tsl);
               if(OrderStopLoss()>s.tsl)
               {  while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
                  OrderModify(s.ticketM,OrderOpenPrice(),s.tsl,OrderTakeProfit(),OrderExpiration(),MediumVioletRed);
                  Sleep (2000);
               }
            }
         }
      }

   }
}


void Trail.Stop()
{  if (Trail.Starts.After.BreakEven)   Trail.With.Standard.Trailing(1);
   else                                Trail.With.Standard.Trailing(0);
}

void MoveToBreakEven()
{  PosCounter();
   RefreshRates();
   if (b.ticket > 0)
   {  OrderSelect(b.ticket,SELECT_BY_TICKET);
      if (OrderStopLoss()((Move.To.BreakEven.at.pips*Point) +OrderOpenPrice()))
         {  while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
            OrderModify(b.ticket, OrderOpenPrice(), (OrderOpenPrice()+(Move.To.BreakEven.Lock.pips*Point)),OrderTakeProfit(),OrderExpiration(),MediumSpringGreen);
            if (OrderSelect(b.ticket,SELECT_BY_TICKET,MODE_TRADES)) 
            {  Print("Long StopLoss Moved to BE at : ",OrderStopLoss());
               Sleep(2000);
            }
            else Print("Error moving Long StopLoss to BE: ",GetLastError());
         }
      }
   }
   if (s.ticket > 0)
   {  OrderSelect(s.ticket,SELECT_BY_TICKET);
      if (OrderStopLoss()>OrderOpenPrice())
      {  if ( Ask < (OrderOpenPrice()-(Move.To.BreakEven.at.pips*Point)))
         {  while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
            OrderModify(OrderTicket(), OrderOpenPrice(), (OrderOpenPrice()-(Move.To.BreakEven.Lock.pips*Point)),OrderTakeProfit(),OrderExpiration(),MediumVioletRed);
            if(OrderSelect(s.ticket,SELECT_BY_TICKET,MODE_TRADES)) 
            {  Print("Short StopLoss Moved to BE at : ",OrderStopLoss());
               Sleep(2000);
            }
            else Print("Error moving Short StopLoss to BE: ",GetLastError());
         }
      }
   }
   if (b.ticketM > 0)
   {  OrderSelect(b.ticketM,SELECT_BY_TICKET);
      if (OrderStopLoss()((Move.To.BreakEven.at.pips*Point) +OrderOpenPrice()))
         {  while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
            OrderModify(b.ticketM, OrderOpenPrice(), (OrderOpenPrice()+(Move.To.BreakEven.Lock.pips*Point)),OrderTakeProfit(),OrderExpiration(),MediumSpringGreen);
            if (OrderSelect(b.ticketM,SELECT_BY_TICKET,MODE_TRADES)) 
            {  Print("Long StopLoss Moved to BE at : ",OrderStopLoss());
               Sleep(2000);
            }
            else Print("Error moving Long StopLoss to BE: ",GetLastError());
         }
      }
   }
   if (s.ticketM > 0)
   {  OrderSelect(s.ticketM,SELECT_BY_TICKET);
      if (OrderStopLoss()>OrderOpenPrice())
      {  if ( Ask < (OrderOpenPrice()-(Move.To.BreakEven.at.pips*Point)))
         {  while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
            OrderModify(OrderTicket(), OrderOpenPrice(), (OrderOpenPrice()-(Move.To.BreakEven.Lock.pips*Point)),OrderTakeProfit(),OrderExpiration(),MediumVioletRed);
            if(OrderSelect(s.ticketM,SELECT_BY_TICKET,MODE_TRADES)) 
            {  Print("Short StopLoss Moved to BE at : ",OrderStopLoss());
               Sleep(2000);
            }
            else Print("Error moving Short StopLoss to BE: ",GetLastError());
         }
      }
   }
}


void CheckInitialSLTP()
{  int sl,tp;
   RefreshRates();
   if (b.ticket>0)
   {  OrderSelect(b.ticket,SELECT_BY_TICKET);
      if (OrderStopLoss()==0 || OrderTakeProfit()==0)
      {  if (OrderStopLoss  ()==0)  {sl=StopLoss.Pips;}
         if (OrderTakeProfit()==0)  {tp=TakeProfit.Pips;}
         if ((sl>0 && OrderStopLoss()==0) || (tp>0 && OrderTakeProfit()==0))
         {  Retry=0; while (Retry<5 && !IsTradeAllowed()) { Retry++; Sleep(2000); }
            OrderModify(b.ticket, OrderOpenPrice(), OrderOpenPrice()-sl*Point,OrderOpenPrice()+tp*Point,OrderExpiration(),MediumSpringGreen);
            if (OrderSelect(b.ticket,SELECT_BY_TICKET,MODE_TRADES)) 
            {  Print("Initial SL or TP is Set for Long Entry");
               Sleep(2000);
            }
            else Print("Error setting initial SL or TP for Long Entry");
         }
      }
   }
   if (s.ticket > 0)
   {  OrderSelect(s.ticket,SELECT_BY_TICKET);
      if (OrderStopLoss()==0 || OrderTakeProfit()==0)
      {  if (OrderStopLoss  ()==0)  {sl=StopLoss.Pips;}
         if (OrderTakeProfit()==0)  {tp=TakeProfit.Pips;}
         if ((sl>0 && OrderStopLoss()==0) || (tp>0 && OrderTakeProfit()==0))
         {  Retry=0; while (Retry<5 && !IsTradeAllowed()) { Retry++; Sleep(2000); }
            OrderModify(s.ticket, OrderOpenPrice(), OrderOpenPrice()+sl*Point,OrderOpenPrice()-tp*Point,OrderExpiration(),MediumVioletRed);
            if (OrderSelect(s.ticket,SELECT_BY_TICKET,MODE_TRADES)) 
            {  Print("Initial SL or TP is Set for Short Entry");
               Sleep(2000);
            }
            else Print("Error setting initial SL or TP for Short Entry");
         }
      }
   }
   if (b.ticketM>0)
   {  OrderSelect(b.ticketM,SELECT_BY_TICKET);
      if (OrderStopLoss()==0 || OrderTakeProfit()==0)
      {  if (OrderStopLoss  ()==0)  {sl=StopLoss.Pips;}
         if (OrderTakeProfit()==0)  {tp=TakeProfit.Pips;}
         if ((sl>0 && OrderStopLoss()==0) || (tp>0 && OrderTakeProfit()==0))
         {  Retry=0; while (Retry<5 && !IsTradeAllowed()) { Retry++; Sleep(2000); }
            OrderModify(b.ticketM, OrderOpenPrice(), OrderOpenPrice()-sl*Point,OrderOpenPrice()+tp*Point,OrderExpiration(),MediumSpringGreen);
            if (OrderSelect(b.ticketM,SELECT_BY_TICKET,MODE_TRADES)) 
            {  Print("Initial SL or TP is Set for Long Entry");
               Sleep(2000);
            }
            else Print("Error setting initial SL or TP for Long Entry");
         }
      }
   }
   if (s.ticketM > 0)
   {  OrderSelect(s.ticketM,SELECT_BY_TICKET);
      if (OrderStopLoss()==0 || OrderTakeProfit()==0)
      {  if (OrderStopLoss  ()==0)  {sl=StopLoss.Pips;}
         if (OrderTakeProfit()==0)  {tp=TakeProfit.Pips;}
         if ((sl>0 && OrderStopLoss()==0) || (tp>0 && OrderTakeProfit()==0))
         {  Retry=0; while (Retry<5 && !IsTradeAllowed()) { Retry++; Sleep(2000); }
            OrderModify(s.ticketM, OrderOpenPrice(), OrderOpenPrice()+sl*Point,OrderOpenPrice()-tp*Point,OrderExpiration(),MediumVioletRed);
            if (OrderSelect(s.ticketM,SELECT_BY_TICKET,MODE_TRADES)) 
            {  Print("Initial SL or TP is Set for Short Entry");
               Sleep(2000);
            }
            else Print("Error setting initial SL or TP for Short Entry");
         }
      }
   }
}


void ShutDownAllTrades(int aiWhat)
{  int Retry;
   for (int cnt=OrdersTotal()-1;cnt>=0;cnt--)
   {  OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES); 
      if ( ((ShutDown.Current.Pair.Only) && (OrderSymbol()==Symbol())) || (!ShutDown.Current.Pair.Only))
      {  if ((OrderType()==OP_BUY) && ((aiWhat==0) || (aiWhat==1) || (aiWhat==2)))
         {  Retry=0; while (Retry<5 && !IsTradeAllowed()) { Retry++; Sleep(1000); }
            OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,Yellow);
            Sleep(1000);
         }
         if ((OrderType()==OP_SELL) && ((aiWhat==0) || (aiWhat==1) || (aiWhat==3)))
         {  Retry=0; while (Retry<5 && !IsTradeAllowed()) { Retry++; Sleep(1000); }
            OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,Yellow);
            Sleep(1000);
         }
         if ((OrderType()==OP_BUYSTOP) && ((aiWhat==0) || (aiWhat==4) || (aiWhat==5)))
         {  Retry=0; while (Retry<5 && !IsTradeAllowed()) { Retry++; Sleep(1000); }
            OrderDelete(OrderTicket());
            Sleep(1000);
         }
         if ((OrderType()==OP_SELLSTOP) && ((aiWhat==0) || (aiWhat==4) || (aiWhat==6)))
         {  Retry=0; while (Retry<5 && !IsTradeAllowed()) { Retry++; Sleep(1000); }
            OrderDelete(OrderTicket());
            Sleep(1000);
         }
      }
   }
} 

void comments()
{  string s0="", s1="", s2="", s3="", swap="", sCombo="", sStr ;
   int PipsProfit;
   double AmountProfit;
   PipsProfit=0; AmountProfit=0;
   ObjectSetText( "Yannis", "[email protected]"  , 10, "Times New Roman", Yellow );
   ObjectSetText( "Yannis2", NewsLabel , 10, "Tahoma", Yellow );
   PosCounter();
   RefreshRates();
   if (b.ticket>0)
   {  OrderSelect(b.ticket,SELECT_BY_TICKET);
      PipsProfit=NormalizeDouble(((Bid - OrderOpenPrice())/Point),Digits);
      AmountProfit=OrderProfit();
   }
   else if (s.ticket>0)
   {  OrderSelect(s.ticket,SELECT_BY_TICKET);
      PipsProfit=NormalizeDouble(((OrderOpenPrice()-Ask)/Point),Digits);
      AmountProfit=OrderProfit();
   }
   else if (b.ticketM>0)
   {  OrderSelect(b.ticketM,SELECT_BY_TICKET);
      PipsProfit=NormalizeDouble(((Bid - OrderOpenPrice())/Point),Digits);
      AmountProfit=OrderProfit();
   }
   else if (s.ticketM>0)
   {  OrderSelect(s.ticketM,SELECT_BY_TICKET);
      PipsProfit=NormalizeDouble(((OrderOpenPrice()-Ask)/Point),Digits);
      AmountProfit=OrderProfit();
   }
   if (Move.To.BreakEven.at.pips>0) s1="S/L will move to B/E after: "+Move.To.BreakEven.at.pips+" pips   and lock: "+Move.To.BreakEven.Lock.pips+" pips"+"\n\n";
   else                             s1="";

   
   if ((!Place.Straddle.Immediately) && (Enable.News.Trading))
   {  if (Adjust.Pending.Orders) s2=StringConcatenate("A straddle will be placed ",DoubleToStr(Pre.Event.Entry.Minutes,0),
                                                      " Minutes before news \nat ",DoubleToStr(Distance.From.Price,0),
                                                      " pips above and below price \nAdjusting every minute until ",
                                                      DoubleToStr(Stop.Adjusting.Min.Before.Event,0),
                                                      " minutes before event time");
   }
   else s2="";
   
   Comment( "\n",ScreenComment,"\n\n",
            "SL: ",StopLoss.Pips,"  TP:",TakeProfit.Pips,"  Trail:",Trail.Pips,"\n",
            s1,"\n",
            "Minimum allowed for SL & TP is ",iMinimum," pips\n\n",
            s2
          );
}

string ServerTime()
{  string strHourPad,strMinutePad;
   if (TimeHour(iTime(NULL,PERIOD_M1,0))>=0 && TimeHour(iTime(NULL,PERIOD_M1,0))<=9) strHourPad = "0";
   else strHourPad = "";
   if (TimeMinute(iTime(NULL,PERIOD_M1,0))>=0 && TimeMinute(iTime(NULL,PERIOD_M1,0))<=9) strMinutePad = "0";
   else strMinutePad = "";
   return(StringConcatenate("Broker\'s Current Time is (",strHourPad,TimeHour(iTime(NULL,PERIOD_M1,0)),":",strMinutePad,TimeMinute(iTime(NULL,PERIOD_M1,0)),")"));
}


int CalcMagic(string CurrPair, int CurrPeriod)
{       if (CurrPair=="EURUSD" || CurrPair=="EURUSDm") {return(1000+CurrPeriod);}
   else if (CurrPair=="GBPUSD" || CurrPair=="GBPUSDm") {return(2000+CurrPeriod);}
   else if (CurrPair=="USDCHF" || CurrPair=="USDCHFm") {return(3000+CurrPeriod);}
   else if (CurrPair=="USDJPY" || CurrPair=="USDJPYm") {return(4000+CurrPeriod);}
   else if (CurrPair=="EURJPY" || CurrPair=="EURJPYm") {return(5000+CurrPeriod);}
   else if (CurrPair=="EURCHF" || CurrPair=="EURCHFm") {return(6000+CurrPeriod);}
   else if (CurrPair=="EURGBP" || CurrPair=="EURGBPm") {return(7000+CurrPeriod);}
   else if (CurrPair=="USDCAD" || CurrPair=="USDCADm") {return(8000+CurrPeriod);}
   else if (CurrPair=="AUDUSD" || CurrPair=="AUDUSDm") {return(9000+CurrPeriod);}
   else if (CurrPair=="GBPCHF" || CurrPair=="GBPCHFm") {return(10000+CurrPeriod);}
   else if (CurrPair=="GBPJPY" || CurrPair=="GBPJPYm") {return(11000+CurrPeriod);}
   else if (CurrPair=="CHFJPY" || CurrPair=="CHFJPYm") {return(12000+CurrPeriod);}
   else if (CurrPair=="NZDUSD" || CurrPair=="NZDUSDm") {return(13000+CurrPeriod);}
   else if (CurrPair=="EURCAD" || CurrPair=="EURCADm") {return(14000+CurrPeriod);}
   else if (CurrPair=="AUDJPY" || CurrPair=="AUDJPYm") {return(15000+CurrPeriod);}
   else if (CurrPair=="EURAUD" || CurrPair=="EURAUDm") {return(16000+CurrPeriod);}
   else if (CurrPair=="AUDCAD" || CurrPair=="AUDCADm") {return(17000+CurrPeriod);}
   else if (CurrPair=="AUDNZD" || CurrPair=="AUDNZDm") {return(18000+CurrPeriod);}
   else if (CurrPair=="NZDJPY" || CurrPair=="NZDJPYm") {return(19000+CurrPeriod);}
   else if (CurrPair=="CADJPY" || CurrPair=="CADJPYm") {return(20000+CurrPeriod);}
   else if (CurrPair=="XAUUSD" || CurrPair=="XAUUSDm") {return(21000+CurrPeriod);}
   else if (CurrPair=="XAGUSD" || CurrPair=="XAGUSDm") {return(22000+CurrPeriod);}
   else if (CurrPair=="GBPAUD" || CurrPair=="GBPAUDm") {return(23000+CurrPeriod);}
   else if (CurrPair=="GBPCAD" || CurrPair=="GBPCADm") {return(24000+CurrPeriod);}
   else if (CurrPair=="AUFCHF" || CurrPair=="AUFCHFm") {return(25000+CurrPeriod);}
   else if (CurrPair=="CADCHF" || CurrPair=="CADCHFm") {return(26000+CurrPeriod);}
   else if (CurrPair=="NZDCHF" || CurrPair=="NZDCHFm") {return(27000+CurrPeriod);}
}

int YannisCustomText( string Text, int xOffset, int yOffset,int iCorner) 
{  ObjectCreate(Text,OBJ_LABEL         , 0, 0, 0 );
   ObjectSet   (Text,OBJPROP_CORNER    , iCorner);
   ObjectSet   (Text,OBJPROP_XDISTANCE , xOffset );
   ObjectSet   (Text,OBJPROP_YDISTANCE , yOffset );
   ObjectSet   (Text,OBJPROP_BACK      , True );
}

//----------- Close All Orders, by Azmel
int CloseAllOrders()
{

int i;
int slippage=5;

   for (i=0;i        

Recommend