/*-----------------------------+
| |
| Shared by www.Aptrafx.com |
| |
+------------------------------*/
//+-----------------------------------------------------------------------------+
//| Straddle&Trail.mq4 |
//| Copyright © 2006, Yannis |
//| jsfero@otenet.gr |
//+-----------------------------------------------------------------------------+
//+ v2.00 +
//+-----------------------------------------------------------------------------+
/////////////////////////////////////////////////////////////////////////////////
// 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 this ea.
//
// 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 and Trail are concerned,
// and are totally unaffected by the straddle.
// 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.
/////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////// 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
/////////////////////////////////////////////////////////////////////////////////////
#include <stdlib.mqh>
extern string sStr1="POSITION DETAILS";
extern double Lots = 1;
extern int Slippage=10;
extern int Distance.From.Price=30; // Initial distance from price for the 2 pending orders.
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=1; // 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=10; // 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 int Event.Start.Hour=12; // Event start time = Hour. Broker's time.
extern int Event.Start.Minutes=30; // 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=15; // 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=True; // 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=True; // 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.
int iMinimum,Last.Ticket,b.ticket,s.ticket,b.ticketP,s.ticketP,b.ticketM,s.ticketM,Magic;
int Retry,HourNow,MinutesNow,LastMin,MyErr ;
string comment=" Straddle&Trail",ScreenComment="Straddle&Trail v2.00",NewsLabel="";
bool SupplyMagicNumber=True,IsOK=False;
double LongEntryLevel,ShortEntryLevel,SL,TP;
int init()
{ comments();
if ((Event.Start.Hour==0) && (Event.Start.Minutes==0)) NewsLabel=ServerTime()+" NO NEWS EVENT SCHEDULED";
else NewsLabel=(ServerTime()+" NEWS SCHEDULED FOR :"+Event.Start.Hour+":"+Event.Start.Minutes);
ObjectDelete("Yannis");
YannisCustomText( "Yannis", 15, 15,1);
ObjectSetText( "Yannis", "jsfero@otenet.gr" , 10, "Times New Roman", Yellow );
ObjectDelete("Yannis2");
YannisCustomText( "Yannis2", 15, 15,3);
ObjectSetText( "Yannis2", NewsLabel , 11, "Tahoma", HotPink );
return(0);
}
int deinit()
{ ObjectDelete("Yannis");
ObjectDelete("Yannis2");
return(0);
}
int start()
{ 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.Minutes==0)) NewsLabel=ServerTime()+" NO NEWS EVENT SCHEDULED";
else NewsLabel=(ServerTime()+" NEWS SCHEDULED FOR :"+Event.Start.Hour+":"+Event.Start.Minutes);
Magic=CalcMagic (Symbol(),Period());
if (StopLoss.Pips <iMinimum) StopLoss.Pips =iMinimum;
if (TakeProfit.Pips<iMinimum) TakeProfit.Pips=iMinimum;
if (Trail.Pips <iMinimum) Trail.Pips =iMinimum;
PosCounter(); // check for open positions. Sets b.ticket, s.ticket, b.ticketP, s.ticketP, b.ticketM, s.ticketM
// b.ticketM / s.ticketM = Ticket Number for Manual Trades
// (b.ticketM=Long position s.ticketM=Short position, if any, otherwise = 0)
// b.ticketP / s.ticketP = Ticket Number for Pending Trades (Straddle) from EA
// b.ticket / s.ticket = Ticket Number for Triggered Trades (Straddle) from EA
// 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())
{ 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)) 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
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 ((HourNow<Event.Start.Hour) || (HourNow>Event.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.30, 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;
double ShortEntryLevel, LongEntryLevel, TP, SL;
if (StopLoss.Pips ==0) StopLoss.Pips =999;
if (TakeProfit.Pips==0) TakeProfit.Pips=999;
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);
}
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);
}
}
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;
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();
}
}
// 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();
}
}
}
}
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()<b.tsl)
{ while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
OrderModify(b.ticket,OrderOpenPrice(),b.tsl,OrderTakeProfit(),OrderExpiration(),MediumSpringGreen);
Sleep (2000);
}
}
}
if(s.ticket>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()<b.tsl)
{ while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
OrderModify(b.ticketM,OrderOpenPrice(),b.tsl,OrderTakeProfit(),OrderExpiration(),MediumSpringGreen);
Sleep (2000);
}
}
}
if(s.ticketM>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()<b.tsl)
{ while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
OrderModify(b.ticket,OrderOpenPrice(),b.tsl,OrderTakeProfit(),OrderExpiration(),MediumSpringGreen);
Sleep (2000);
}
}
}
}
if(s.ticket>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()<b.tsl)
{ while (Retry<5 && !IsTradeAllowed()) {Retry++; Sleep(2000); }
OrderModify(b.ticketM,OrderOpenPrice(),b.tsl,OrderTakeProfit(),OrderExpiration(),MediumSpringGreen);
Sleep (2000);
}
}
}
}
if(s.ticketM>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()<OrderOpenPrice())
{ if (Bid >((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()<OrderOpenPrice())
{ if (Bid >((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 comments()
{ string s0="", s1="", s2="", s3="", swap="", sCombo="", sStr ;
int PipsProfit;
double AmountProfit;
PipsProfit=0; AmountProfit=0;
ObjectSetText( "Yannis", "jsfero@otenet.gr" , 10, "Times New Roman", Yellow );
ObjectSetText( "Yannis2", NewsLabel , 11, "Tahoma", HotPink );
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="";
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"
);
}
string ServerTime()
{ return ("BROKER CURRENT TIME = "+TimeHour(Time[0]) + ":" + TimeMinute(Time[0]) +"." + TimeSeconds(Time[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 );
}
Sample
Analysis
Market Information Used:
Series array that contains open time of each bar
Indicator Curves created:
Indicators Used:
Custom Indicators Used:
Order Management characteristics:
It can change open orders parameters, due to possible stepping strategy
Checks for the total of open orders
Other Features: