//+-------------------------------------------------------------------+ //| Unimak.mq4 | //| Based on Generic auto trading robot by Steve Hopwood.mq4 | //| Copyright © 2012, Unimak, magft & Steve Hopwood | //| http://www.forexfactory.com/magft | //+-------------------------------------------------------------------+ #property copyright "Copyright © 2012, Unimak, magft & Steve Hopwood" #property link "http://www.forexfactory.com/magft" #include #include #define NL "\n" #define up "Up" #define down "Down" #define ranging "Ranging" #define none "None" #define both "Both" #define buy "Buy" #define sell "Sell" #define Buy 1 #define Sell 2 //Pending trade price line #define pendingpriceline "Pending price line" //Hidden sl and tp lines. If UseStealth enabled, the bot will close trades on a touch/break of these lines. //Each line is named with its appropriate prefix and the ticket number of the relevant trade #define TpPrefix "Tp" #define SlPrefix "Sl" #define VERSION "1.00" #define DATE "25th April 2012" extern string gen="----General inputs----"; extern double Lot=0.01; extern int RiskPercent = 0;//Set to zero to disable and use Lot extern bool StopTrading=false; extern bool TradeLong=true; extern bool TradeShort=true; extern int TakeProfit=0; extern int StopLoss=0; extern int MagicNumber=0; extern string TradeComment=""; extern bool CriminalIsECN=false; extern double MaxSpread=120; extern string l2="----EA inputs----"; extern double BuySellOffSet = 0.5; extern int TargetPips = 30; //Hidden tp/sl inputs. extern string hts="----Stealth stop loss and take profit inputs----"; extern int HiddenPips=0;//Added to the 'hard' sl and tp and used for closure calculations ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// double HiddenStopLoss, HiddenTakeProfit; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// extern string tt="----Trading hours----"; extern string Trade_Hours= "Set Morning & Evening Hours"; extern string Trade_Hoursi= "Use 24 hour, local time clock"; extern string Trade_Hours_M= "Morning Hours 0-12"; extern int start_hourm = 0; extern int end_hourm = 12; extern string Trade_Hours_E= "Evening Hours 12-24"; extern int start_houre = 12; extern int end_houre = 24; extern string tmm="----Trade management module----"; //Breakeven has to be enabled for JS and TS to work. extern string BE="Break even settings"; extern bool BreakEven=true; extern int BreakEvenPips=10; extern int BreakEvenProfit=9; extern string cts="----Candlestick trailing stop----"; extern bool UseCandlestickTrailingStop=false; extern int CstTimeFrame=0;//Defaults to current chart extern int CstTrailCandles=1;//Defaults to previous candle ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// int OldCstBars;//For candlestick ts ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// extern string JSL="Jumping stop loss settings"; extern bool JumpingStop=true; extern int JumpingStopPips=10; extern bool AddBEP=true; extern string TSL="Trailing stop loss settings"; extern bool TrailingStop=false; extern int TrailingStopPips=20; extern string mis="----Odds and ends----"; extern int DisplayGapSize=30; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// string Gap, ScreenMessage; ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Matt's O-R stuff int O_R_Setting_max_retries = 10; double O_R_Setting_sleep_time = 4.0; /* seconds */ double O_R_Setting_sleep_max = 15.0; /* seconds */ int RetryCount = 10;//Will make this number of attempts to get around the trade context busy error. //Trading variables int TicketNo = -1, OpenTrades; bool CanTradeThisPair;//Will be false when this pair fails the currency can only trade twice filter, or the balanced trade filter bool BuyOpen, SellOpen, PendingBuyOpen, PendingSellOpen;//Might need further refinement to reflect the pending type double upl;//For keeping track of the upl of hedged positions //Running total of trades int LossTrades, WinTrades; double OverallProfit; //Misc int OldBars; string PipDescription=" pips"; bool ForceTradeClosure; double YesterdayHigh, YesterdayLow , YesterdayClose; double OpenD, PivotD, R1D, S1D; int Signal; int BuyFlagR[3];//flags for display int SellFlagS[3];//flags for display void DisplayUserFeedback() { if (IsTesting() && !IsVisualMode()) return; ScreenMessage = ""; ScreenMessage = StringConcatenate(ScreenMessage,Gap, NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, WindowExpertName()+" v"+VERSION+", "+DATE,NL); ScreenMessage = StringConcatenate(ScreenMessage, Gap, TimeToStr(TimeLocal(), TIME_DATE|TIME_MINUTES|TIME_SECONDS), NL ); /* //Code for time to bar-end display from Candle Time by Nick Bilak int m,s,k; m=Time[0]+Period()*60-CurTime(); s=m%60; m=(m-m%60)/60; ScreenMessage = StringConcatenate(ScreenMessage,Gap, m + " minutes " + s + " seconds left to bar end", NL); */ ScreenMessage = StringConcatenate(ScreenMessage,Gap, NL); if (TradeLong) ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Taking long trades", NL); if (TradeShort) ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Taking short trades", NL); if (!TradeLong && !TradeShort) ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Both TradeLong and TradeShort are set to false", NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Lot size: ", Lot, " (Criminal's minimum lot size: ", MarketInfo(Symbol(), MODE_MINLOT), ")", NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Take profit: ", TakeProfit, PipDescription, NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Stop loss: ", StopLoss, PipDescription, NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Magic number: ", MagicNumber, NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Trade comment: ", TradeComment, NL); if (CriminalIsECN) ScreenMessage = StringConcatenate(ScreenMessage,Gap, "CriminalIsECN = true", NL); else ScreenMessage = StringConcatenate(ScreenMessage,Gap, "CriminalIsECN = false", NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, "MaxSpread = ", MaxSpread, ": Spread = ", MarketInfo(Symbol(), MODE_SPREAD), NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, NL); //ScreenMessage = StringConcatenate(ScreenMessage,Gap,"YesterdayHigh: ",DoubleToStr(YesterdayHigh,Digits), ", YesterdayLow: ",DoubleToStr(YesterdayLow,Digits),NL); //ScreenMessage = StringConcatenate(ScreenMessage,Gap,"YesterdayClose: ",DoubleToStr(YesterdayClose,Digits),", Daily Open: ",DoubleToStr(OpenD,Digits), NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap,"Daily Open: ",DoubleToStr(OpenD,Digits),", Daily Pivot: ",DoubleToStr(PivotD,Digits), NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap,"Daily R1: ", DoubleToStr(R1D,Digits),", Daily S1: ", DoubleToStr(S1D,Digits),NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap,"Buy Signal R1: "); for(int i=0;i<3;i++) { ScreenMessage = StringConcatenate(ScreenMessage,BuyFlagR[i]); } ScreenMessage = StringConcatenate(ScreenMessage, NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap,"Sell Signal S1: "); for(i=0;i<3;i++) { ScreenMessage = StringConcatenate(ScreenMessage,SellFlagS[i]); } ScreenMessage = StringConcatenate(ScreenMessage, NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Trading hours", NL); if (start_hourm == 0 && end_hourm == 12 && start_houre && end_houre == 24) ScreenMessage = StringConcatenate(ScreenMessage,Gap, " 24H trading", NL); else { ScreenMessage = StringConcatenate(ScreenMessage,Gap, " start_hourm: ", DoubleToStr(start_hourm, 2), ": end_hourm: ", DoubleToStr(end_hourm, 2), NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, " start_houre: ", DoubleToStr(start_houre, 2), ": end_houre: ", DoubleToStr(end_houre, 2), NL); }//else //Running total of trades ScreenMessage = StringConcatenate(ScreenMessage,Gap, NL); ScreenMessage = StringConcatenate(ScreenMessage, Gap, "Results today. Wins: ", WinTrades, ": Losses ", LossTrades, ": P/L ", DoubleToStr(OverallProfit, 2), NL); ScreenMessage = StringConcatenate(ScreenMessage,Gap, NL); if (BreakEven) { ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Breakeven is set to ", BreakEvenPips, PipDescription); ScreenMessage = StringConcatenate(ScreenMessage,": BreakEvenProfit = ", BreakEvenProfit, PipDescription); ScreenMessage = StringConcatenate(ScreenMessage,Gap, NL); }//if (BreakEven) if (UseCandlestickTrailingStop) { ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Using candlestick trailing stop", NL); }//if (UseCandlestickTrailingStop) if (JumpingStop) { ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Jumping stop is set to ", JumpingStopPips, PipDescription); ScreenMessage = StringConcatenate(ScreenMessage,Gap, NL); }//if (JumpingStop) if (TrailingStop) { ScreenMessage = StringConcatenate(ScreenMessage,Gap, "Trailing stop is set to ", TrailingStopPips, PipDescription); ScreenMessage = StringConcatenate(ScreenMessage,Gap, NL); }//if (TrailingStop) Comment(ScreenMessage); }//void DisplayUserFeedback() //+------------------------------------------------------------------+ //| expert initialization function | //+------------------------------------------------------------------+ int init() { //---- //Adapt to x digit criminals int multiplier = 1; if(Digits == 2 || Digits == 4) multiplier = 1; if(Digits == 3 || Digits == 5) multiplier = 10; if(Digits == 6) multiplier = 100; if(Digits == 7) multiplier = 1000; if (multiplier > 1) PipDescription = " points"; //scale pips to mt4 digits TakeProfit*= multiplier; StopLoss*= multiplier; HiddenPips*= multiplier; BreakEvenPips*= multiplier; BreakEvenProfit*= multiplier; JumpingStopPips*= multiplier; TrailingStopPips*= multiplier; BuySellOffSet *= multiplier; TargetPips *= multiplier; //Jumping/trailing stops need breakeven set before they work properly if ((JumpingStop || TrailingStop) && !BreakEven) { BreakEven = true; if (JumpingStop) BreakEvenPips = JumpingStopPips; if (TrailingStop) BreakEvenPips = TrailingStopPips; }//if (JumpingStop || TrailingStop) Gap=""; if (DisplayGapSize >0) { for (int cc=0; cc< DisplayGapSize; cc++) { Gap = StringConcatenate(Gap, " "); } }//if (DisplayGapSize >0) if (TradeComment == "") TradeComment = " "; OldBars = Bars; TicketNo = -1; ReadIndicatorValues();//For initial display in case user has turned of constant re-display DisplayUserFeedback(); //This forces the platform to 2048 bars of data - necessary if this is a new CrapT4 installation iBars(NULL, Period() ); //Call sq's show trades indi //iCustom(NULL, 0, "SQ_showTrades",Magic, 0,0); //---- return(0); } //+------------------------------------------------------------------+ //| expert deinitialization function | //+------------------------------------------------------------------+ int deinit() { //---- Comment(""); ObjectDelete("R1"); ObjectDelete("S1"); ObjectDelete("Pivot"); ObjectDelete("DailyOpen"); //---- return(0); } bool SendSingleTrade(int type, string comment, double lotsize, double price, double stop, double take) { //pah (Paul) contributed the code to get around the trade context busy error. Many thanks, Paul. int slippage = 10; if (Digits == 3 || Digits == 5) slippage = 100; color col = Red; if (type == OP_BUY || type == OP_BUYSTOP) col = Green; int expiry = 0; //if (SendPendingTrades) expiry = TimeCurrent() + (PendingExpiryMinutes * 60); //RetryCount is declared as 10 in the Trading variables section at the top of this file for (int cc = 0; cc < RetryCount; cc++) { for (int d = 0; (d < RetryCount) && IsTradeContextBusy(); d++) Sleep(100); RefreshRates(); if (type == OP_BUY) price = NormalizeDouble(Ask, Digits); if (type == OP_SELL) price = NormalizeDouble(Bid, Digits); if (!CriminalIsECN) int ticket = OrderSend(Symbol(),type, lotsize, price, slippage, stop, take, comment, MagicNumber, expiry, col); //Is a 2 stage criminal if (CriminalIsECN) { ticket = OrderSend(Symbol(),type, lotsize, price, slippage, 0, 0, comment, MagicNumber, expiry, col); if (ticket > -1) { ModifyOrder(ticket, stop, take); }//if (ticket > 0)} }//if (CriminalIsECN) if (ticket > -1) break;//Exit the trade send loop if (cc == RetryCount - 1) return(false); //Error trapping for both if (ticket < 0) { string stype; if (type == OP_BUY) stype = "OP_BUY"; if (type == OP_SELL) stype = "OP_SELL"; if (type == OP_BUYLIMIT) stype = "OP_BUYLIMIT"; if (type == OP_SELLLIMIT) stype = "OP_SELLLIMIT"; if (type == OP_BUYSTOP) stype = "OP_BUYSTOP"; if (type == OP_SELLSTOP) stype = "OP_SELLSTOP"; int err=GetLastError(); Alert(Symbol(), " ", WindowExpertName(), " ", stype," order send failed with error(",err,"): ",ErrorDescription(err)); Print(Symbol(), " ", WindowExpertName(), " ", stype," order send failed with error(",err,"): ",ErrorDescription(err)); return(false); }//if (ticket < 0) }//for (int cc = 0; cc < RetryCount; cc++); TicketNo = ticket; //Make sure the trade has appeared in the platform's history to avoid duplicate trades. //My mod of Matt's code attempts to overcome the bastard crim's attempts to overcome Matt's code. bool TradeReturnedFromCriminal = false; while (!TradeReturnedFromCriminal) { TradeReturnedFromCriminal = O_R_CheckForHistory(ticket); if (!TradeReturnedFromCriminal) { Alert(Symbol(), " sent trade not in your trade history yet. Turn of this ea NOW."); }//if (!TradeReturnedFromCriminal) }//while (!TradeReturnedFromCriminal) //Got this far, so trade send succeeded return(true); }//End bool SendSingleTrade(int type, string comment, double lotsize, double price, double stop, double take) void ModifyOrder(int ticket, double stop, double take) { //Modifies an order already sent if the crim is ECN. if (stop == 0 && take == 0) return; //nothing to do if (!OrderSelect(ticket, SELECT_BY_TICKET) ) return;//Trade does not exist, so no mod needed //RetryCount is declared as 10 in the Trading variables section at the top of this file for (int cc = 0; cc < RetryCount; cc++) { for (int d = 0; (d < RetryCount) && IsTradeContextBusy(); d++) Sleep(100); if (take > 0 && stop > 0) { while(IsTradeContextBusy()) Sleep(100); if (OrderModify(ticket, OrderOpenPrice(), stop, take, OrderExpiration(), CLR_NONE)) return; }//if (take > 0 && stop > 0) if (take != 0 && stop == 0) { while(IsTradeContextBusy()) Sleep(100); if (OrderModify(ticket, OrderOpenPrice(), OrderStopLoss(), take, OrderExpiration(), CLR_NONE)) return; }//if (take == 0 && stop != 0) if (take == 0 && stop != 0) { while(IsTradeContextBusy()) Sleep(100); if (OrderModify(ticket, OrderOpenPrice(), stop, OrderTakeProfit(), OrderExpiration(), CLR_NONE)) return; }//if (take == 0 && stop != 0) }//for (int cc = 0; cc < RetryCount; cc++) //Got this far, so the order modify failed int err=GetLastError(); Print(Symbol(), " SL/TP order modify failed with error(",err,"): ",ErrorDescription(err)); Alert(Symbol(), " SL/TP order modify failed with error(",err,"): ",ErrorDescription(err)); }//void ModifyOrder(int ticket, double tp, double sl) //============================================================================= // O_R_CheckForHistory() // // This function is to work around a very annoying and dangerous bug in MT4: // immediately after you send a trade, the trade may NOT show up in the // order history, even though it exists according to ticket number. // As a result, EA's which count history to check for trade entries // may give many multiple entries, possibly blowing your account! // // This function will take a ticket number and loop until // it is seen in the history. // // RETURN VALUE: // TRUE if successful, FALSE otherwise // // // FEATURES: // * Re-trying under some error conditions, sleeping a random // time defined by an exponential probability distribution. // // * Displays various error messages on the log for debugging. // // ORIGINAL AUTHOR AND DATE: // Matt Kennel, 2010 // //============================================================================= bool O_R_CheckForHistory(int ticket) { //My thanks to Matt for this code. He also has the undying gratitude of all users of my trading robots int lastTicket = OrderTicket(); int cnt = 0; int err = GetLastError(); // so we clear the global variable. err = 0; bool exit_loop = false; bool success=false; while (!exit_loop) { /* loop through open trades */ int total=OrdersTotal(); for(int c = 0; c < total; c++) { if(OrderSelect(c,SELECT_BY_POS,MODE_TRADES) == true) { if (OrderTicket() == ticket) { success = true; exit_loop = true; } } } if (cnt > 3) { /* look through history too, as order may have opened and closed immediately */ total=OrdersHistoryTotal(); for(c = 0; c < total; c++) { if(OrderSelect(c,SELECT_BY_POS,MODE_HISTORY) == true) { if (OrderTicket() == ticket) { success = true; exit_loop = true; } } } } cnt = cnt+1; if (cnt > O_R_Setting_max_retries) { exit_loop = true; } if (!(success || exit_loop)) { Print("Did not find #"+ticket+" in history, sleeping, then doing retry #"+cnt); O_R_Sleep(O_R_Setting_sleep_time, O_R_Setting_sleep_max); } } // Select back the prior ticket num in case caller was using it. if (lastTicket >= 0) { OrderSelect(lastTicket, SELECT_BY_TICKET, MODE_TRADES); } if (!success) { Print("Never found #"+ticket+" in history! crap!"); } return(success); }//End bool O_R_CheckForHistory(int ticket) //============================================================================= // O_R_Sleep() // // This sleeps a random amount of time defined by an exponential // probability distribution. The mean time, in Seconds is given // in 'mean_time'. // This returns immediately if we are backtesting // and does not sleep. // //============================================================================= void O_R_Sleep(double mean_time, double max_time) { if (IsTesting()) { return; // return immediately if backtesting. } double p = (MathRand()+1) / 32768.0; double t = -MathLog(p)*mean_time; t = MathMin(t,max_time); int ms = t*1000; if (ms < 10) { ms=10; } Sleep(ms); }//End void O_R_Sleep(double mean_time, double max_time) /////////////////////////////////////////////////////////////////////////////////////////////////////// bool IsTradingAllowed() { //Returns false if any of the filters should cancel trading, else returns true to allow trading //Maximum spread if (MarketInfo(Symbol(), MODE_SPREAD) > MaxSpread) return(false); return(true); }//End bool IsTradingAllowed() double CalculateLotSize(double price1, double price2) { //Calculate the lot size by risk. Code kindly supplied by jmw1970. Nice one jmw. if (price1 == 0 || price2 == 0) return(Lot);//Just in case double FreeMargin = AccountFreeMargin(); double TickValue = MarketInfo(Symbol(),MODE_TICKVALUE) ; double LotStep = MarketInfo(Symbol(),MODE_LOTSTEP); double SLPts = MathAbs(price1 - price2); SLPts/= Point; double Exposure = SLPts * TickValue; // Exposure based on 1 full lot double AllowedExposure = (FreeMargin * RiskPercent) / 100; int TotalSteps = ((AllowedExposure / Exposure) / LotStep); double LotSize = TotalSteps * LotStep; double MinLots = MarketInfo(Symbol(), MODE_MINLOT); double MaxLots = MarketInfo(Symbol(), MODE_MAXLOT); if (LotSize < MinLots) LotSize = MinLots; if (LotSize > MaxLots) LotSize = MaxLots; return(LotSize); }//double CalculateLotSize(double price1, double price1) double CalculateStopLoss(int type) { //Returns the stop loss for use in LookForTradingOpps and InsertMissingStopLoss double stop, price; RefreshRates(); if (type == OP_BUY) { price = Ask; if (StopLoss > 0) { stop = NormalizeDouble(price - (StopLoss * Point), Digits); HiddenStopLoss = stop; }//if (StopLoss > 0) if (HiddenPips > 0 && stop > 0) stop = NormalizeDouble(stop - (HiddenPips * Point), Digits); }//if (type == OP_BUY) if (type == OP_SELL) { price = Bid; if (StopLoss > 0) { stop = NormalizeDouble(price + (StopLoss * Point), Digits); HiddenStopLoss = stop; }//if (StopLoss > 0) if (HiddenPips > 0 && stop > 0) stop = NormalizeDouble(stop + (HiddenPips * Point), Digits); }//if (type == OP_SELL) return(stop); }//End double CalculateStopLoss(int type) double CalculateTakeProfit(int type) { //Returns the stop loss for use in LookForTradingOpps and InsertMissingStopLoss double take, price; RefreshRates(); if (type == OP_BUY) { price = Ask; if (TakeProfit > 0) { take = NormalizeDouble(price + (TakeProfit * Point), Digits); HiddenTakeProfit = take; }//if (TakeProfit > 0) if (HiddenPips > 0 && take > 0) take = NormalizeDouble(take + (HiddenPips * Point), Digits); }//if (type == OP_BUY) if (type == OP_SELL) { price = Bid; if (TakeProfit > 0) { take = NormalizeDouble(price - (TakeProfit * Point), Digits); HiddenTakeProfit = take; }//if (TakeProfit > 0) if (HiddenPips > 0 && take > 0) take = NormalizeDouble(take - (HiddenPips * Point), Digits); }//if (type == OP_SELL) return(take); }//End double CalculateTakeProfit(int type) void LookForTradingOpportunities() { RefreshRates(); double take, stop, price; int type; string stype;//For the alert bool SendTrade; double SendLots = Lot; //Check filters if (!IsTradingAllowed() ) return; if (!CheckForSignal()) return; //////////////////////////////////////////////////////////////////////////////////////////////////////// //Trading decision. //Examine the filters one by one. //Work on the basis that a failed filter turns off SendLong/Short bool SendLong = true, SendShort = true; //Long trade //User choice of trade direction if (!TradeLong) SendLong = false; //Other filters if(Signal!=Buy) SendLong = false; //////////////////////////////////////////////////////////////////////////////////////////// //Short trade //Usual filters //User choice of trade direction if (!TradeShort) SendShort = false; //Other filters if(Signal!=Sell) SendShort = false; //////////////////////////////////////////////////////////////////////////////////////////////////////// //Long if (SendLong) { //Got this far, so there is going to be a trade send of some sort. Setting up price here makes //this code most easily adaptable to easy alteration price = Ask;//Change this to whatever the price needs to be take = CalculateTakeProfit(OP_BUY); stop = CalculateStopLoss(OP_BUY); //Lot size calculated by risk if (RiskPercent > 0) SendLots = CalculateLotSize(price, NormalizeDouble(stop, Digits) ); type = OP_BUY; stype = " Buy "; SendTrade = true; }//if (SendLong) //Short if (SendShort) { //Got this far, so there is going to be a trade send of some sort. Setting up price here makes //this code most easily adaptable to easy alteration price = Bid;//Change this to whatever the price needs to be take = CalculateTakeProfit(OP_SELL); stop = CalculateStopLoss(OP_SELL); //Lot size calculated by risk if (RiskPercent > 0) SendLots = CalculateLotSize(NormalizeDouble(stop, Digits), price); type = OP_SELL; stype = " Buy "; SendTrade = true; }//if (SendShort) if (SendTrade) { bool result = SendSingleTrade(type, TradeComment, SendLots, price, stop, take); }//if (SendTrade) //Actions when trade send succeeds if (SendTrade && result) { if (HiddenPips > 0) ReplaceMissingSlTpLines(); }//if (result) //Actions when trade send fails if (SendTrade && !result) { }//if (!result) }//void LookForTradingOpportunities() bool CloseTrade(int ticket) { while(IsTradeContextBusy()) Sleep(100); bool result = OrderClose(ticket, OrderLots(), OrderClosePrice(), 1000, CLR_NONE); //Actions when trade send succeeds if (result) { return(true); }//if (result) //Actions when trade send fails if (!result) { return(false); }//if (!result) }//End bool CloseTrade(ticket) //////////////////////////////////////////////////////////////////////////////////////////////// //Indicator module void CalculateDailyResult() { //Calculate the no of winners and losers from today's trading. These are held in the history tab. LossTrades = 0; WinTrades = 0; OverallProfit = 0; for (int cc = 0; cc <= OrdersHistoryTotal(); cc++) { if (!OrderSelect(cc, SELECT_BY_POS, MODE_HISTORY) ) continue; if (OrderSymbol() != Symbol() ) continue; if (OrderMagicNumber() != MagicNumber) continue; OverallProfit+= (OrderProfit() + OrderSwap() + OrderCommission() ); if (OrderProfit() > 0) WinTrades++; if (OrderProfit() < 0) LossTrades++; }//for (int cc = 0; cc <= tot -1; cc++) }//End void CalculateDailyResult() void ReadIndicatorValues() { int i=1;//yesterday if (TimeDayOfWeek(Time[i])==0) i=3;//moves back to friday YesterdayHigh = iHigh(NULL, PERIOD_D1, i); YesterdayLow = iLow(NULL, PERIOD_D1, i); YesterdayClose = iClose(NULL, PERIOD_D1, i); OpenD = iOpen(NULL, PERIOD_D1, 0); PivotD = (YesterdayHigh + YesterdayLow + YesterdayClose) / 3.0; R1D = (2.0*PivotD) - YesterdayLow; S1D = (2.0*PivotD) - YesterdayHigh; //Draw line drawTrendLine("R1", Time[0], R1D, Time[10], R1D, Red); drawTrendLine("S1", Time[0], S1D, Time[10], S1D, Blue); drawTrendLine("Pivot", Time[0], PivotD, Time[10], PivotD, Gray); drawTrendLine("DailyOpen", Time[0], OpenD, Time[10], OpenD, White); }//void ReadIndicatorValues() //End Indicator module //////////////////////////////////////////////////////////////////////////////////////////////// bool LookForTradeClosure(int ticket) { //Close the trade if the close conditions are met. //Called from within CountOpenTrades(). Returns true if a close is needed and succeeds, so that COT can increment cc, //else returns false if (!OrderSelect(ticket, SELECT_BY_TICKET) ) return(true); if (OrderSelect(ticket, SELECT_BY_TICKET) && OrderCloseTime() > 0) return(true); bool CloseThisTrade; string LineName = TpPrefix + DoubleToStr(ticket, 0); //Work with the lines on the chart that represent the hidden tp/sl double take = ObjectGet(LineName, OBJPROP_PRICE1); LineName = SlPrefix + DoubleToStr(ticket, 0); double stop = ObjectGet(LineName, OBJPROP_PRICE1); if (OrderType() == OP_BUY) { //TP if (Bid >= take && take > 0) CloseThisTrade = true; //SL if (Bid <= stop && stop > 0) CloseThisTrade = true; }//if (OrderType() == OP_BUY) if (OrderType() == OP_SELL) { //TP if (Bid <= take && take > 0) CloseThisTrade = true; //SL if (Bid >= stop && stop > 0) CloseThisTrade = true; }//if (OrderType() == OP_SELL) if (CloseThisTrade) { bool result = CloseTrade(TicketNo); //Actions when trade close succeeds if (result) { DeletePendingPriceLines(); TicketNo = -1;//TicketNo is the most recently trade opened, so this might need editing in a multi-trade EA OpenTrades--;//Rather than OpenTrades = 0 to cater for multi-trade EA's return(true);//Makes CountOpenTrades increment cc to avoid missing out ccounting a trade }//if (result) //Actions when trade close fails if (!result) { return(false);//Do not increment cc }//if (!result) }//if (CloseThisTrade) //Got this far, so no trade closure return(false);//Do not increment cc }//End bool LookForTradeClosure() void CloseAllTrades() { ForceTradeClosure= false; if (OrdersTotal() == 0) return; for (int cc = OrdersTotal() - 1; cc >= 0; cc--) { if (!OrderSelect(cc, SELECT_BY_POS) ) continue; if (OrderMagicNumber() != MagicNumber) continue; if (OrderSymbol() != Symbol() ) continue; while(IsTradeContextBusy()) Sleep(100); if (OrderType() == OP_BUY || OrderType() == OP_SELL) bool result = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 1000, CLR_NONE); if (result) cc++; if (!result) ForceTradeClosure= true; }//for (int cc = OrdersTotal() - 1; cc >= 0; cc--) //If full closure succeeded, then allow new trading if (!ForceTradeClosure) { OpenTrades = 0; BuyOpen = false; SellOpen = false; }//if (!ForceTradeClosure) }//End void CloseAllTrades() bool CheckTradingTimes() { //This code contributed by squalou. Many thanks, sq. int hour = TimeHour(TimeLocal() ); if (end_hourm < start_hourm) { end_hourm += 24; } if (end_houre < start_houre) { end_houre += 24; } bool ok2Trade = true; ok2Trade = (hour >= start_hourm && hour <= end_hourm) || (hour >= start_houre && hour <= end_houre); // adjust for past-end-of-day cases // eg in AUS, USDJPY trades 09-17 and 22-06 // so, the above check failed, check if it is because of this condition if (!ok2Trade && hour < 12) { hour += 24; ok2Trade = (hour >= start_hourm && hour <= end_hourm) || (hour >= start_houre && hour <= end_houre); // so, if the trading hours are 11pm - 6am and the time is between midnight to 11am, (say, 5am) // the above code will result in comparing 5+24 to see if it is between 23 (11pm) and 30(6+24), which it is... } // check for end of day by looking at *both* end-hours if (hour >= MathMax(end_hourm, end_houre)) { ok2Trade = false; }//if (hour >= MathMax(end_hourm, end_houre)) return(ok2Trade); }//bool CheckTradingTimes() void CountOpenTrades() { //Not all these will be needed. Which ones are depends on the individual EA. OpenTrades = 0; TicketNo = -1; BuyOpen = false; SellOpen = false; PendingBuyOpen = false; PendingSellOpen = false; int type;//Saves the OrderType() for consulatation later in the function upl = 0;//Unrealised profit and loss for hedging/recovery basket closure decisions if (OrdersTotal() == 0) return; //Iterating backwards through the orders list caters more easily for closed trades than iterating forwards for (int cc = OrdersTotal() - 1; cc >= 0; cc--) { bool TradeWasClosed = false;//See 'check for possible trade closure' //Ensure the trade is still open if (!OrderSelect(cc, SELECT_BY_POS) ) continue; //Ensure the EA 'owns' this trade if (OrderSymbol() != Symbol() ) continue; if (OrderMagicNumber() != MagicNumber) continue; //All conditions passed, so carry on type = OrderType();//Store the order type OpenTrades++; //Store the latest trade sent. Most of my EA's only need this final ticket number as either they are single trade //bots or the last trade in the sequence is the important one. Adapt this code for your own use. if (TicketNo == -1) TicketNo = OrderTicket(); //upl might not be needed. Depends on the individual EA upl+= (OrderProfit() + OrderSwap() + OrderCommission()); //Trade types if (OrderType() == OP_BUY) BuyOpen = true; if (OrderType() == OP_SELL) SellOpen = true; //These might need extra coding if both stop and limit orders are used if (OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT) PendingBuyOpen = true; if (OrderType() == OP_SELLSTOP || OrderType() == OP_SELLLIMIT) PendingSellOpen = true; //Add missing tp/sl in case rapidly moving markets prevent their addition - ECN if (OrderStopLoss() == 0 && StopLoss > 0) InsertStopLoss(TicketNo); if (OrderTakeProfit() == 0 && TakeProfit > 0) InsertTakeProfit(TicketNo); //Replace missing tp and sl lines if (HiddenPips > 0) ReplaceMissingSlTpLines(); TradeWasClosed = LookForTradeClosure(OrderTicket() ); if (TradeWasClosed) { if (type == OP_BUY) BuyOpen = false;//Will be reset if subsequent trades are buys that are not closed if (type == OP_SELL) SellOpen = false;//Will be reset if subsequent trades are sells that are not closed cc++; }//if (TradeWasClosed) //Profitable trade management if (OrderProfit() > 0 && !TradeWasClosed) TradeManagementModule(); }//for (int cc = OrdersTotal() - 1; cc <= 0; c`c--) }//End void CountOpenTrades(); void InsertStopLoss(int ticket) { //Inserts a stop loss if the ECN crim managed to swindle the original trade out of the modification at trade send time //Called from CountOpenTrades() if StopLoss > 0 && OrderStopLoss() == 0. while(IsTradeContextBusy()) Sleep(100); if (!OrderSelect(ticket, SELECT_BY_TICKET) || OrderCloseTime() > 0) return; double stop; if (OrderType() == OP_BUY) { stop = CalculateStopLoss(OP_SELL); }//if (OrderType() == OP_BUY) if (OrderType() == OP_SELL) { stop = CalculateStopLoss(OP_SELL); }//if (OrderType() == OP_SELL) OrderModify(ticket, OrderOpenPrice(), stop, OrderTakeProfit(), OrderExpiration(), CLR_NONE); }//End void InsertStopLoss(int ticket) void InsertTakeProfit(int ticket) { //Inserts a TP if the ECN crim managed to swindle the original trade out of the modification at trade send time //Called from CountOpenTrades() if TakeProfit > 0 && OrderTakeProfit() == 0. while(IsTradeContextBusy()) Sleep(100); if (!OrderSelect(ticket, SELECT_BY_TICKET) || OrderCloseTime() > 0) return; double take; if (OrderType() == OP_BUY) { take = CalculateTakeProfit(OP_BUY); }//if (OrderType() == OP_BUY) if (OrderType() == OP_SELL) { take = CalculateTakeProfit(OP_SELL); }//if (OrderType() == OP_SELL) OrderModify(ticket, OrderOpenPrice(), OrderStopLoss(), take, OrderExpiration(), CLR_NONE); }//End void InsertStopLoss(int ticket) /////////////////////////////////////////////////////////////////////////////////////////////////////// //Pending trade price lines module. //Doubles up by providing missing lines for the stealth stuff void DrawPendingPriceLines() { //This function will work for a full pending-trade EA. //The pending tp/sl can be used for hiding the stops in a market-trading ea /* ObjectDelete(pendingpriceline); ObjectCreate(pendingpriceline, OBJ_HLINE, 0, TimeCurrent(), PendingPrice); if (PendingBuy) ObjectSet(pendingpriceline, OBJPROP_COLOR, Green); if (PendingSell) ObjectSet(pendingpriceline, OBJPROP_COLOR, Red); ObjectSet(pendingpriceline, OBJPROP_WIDTH, 1); ObjectSet(pendingpriceline, OBJPROP_STYLE, STYLE_DASH); */ string LineName = TpPrefix + DoubleToStr(TicketNo, 0);//TicketNo is set by the calling function - either CountOpenTrades or DoesTradeExist HiddenTakeProfit = 0; if (TicketNo > -1 && OrderTakeProfit() > 0) { if (OrderType() == OP_BUY || OrderType() == OP_BUYSTOP || OrderType() == OP_BUYLIMIT) { HiddenTakeProfit = NormalizeDouble(OrderTakeProfit() - (HiddenPips * Point), Digits); }//if (OrderType() == OP_BUY) if (OrderType() == OP_SELL) { HiddenTakeProfit = NormalizeDouble(OrderTakeProfit() + (HiddenPips * Point), Digits); }//if (OrderType() == OP_BUY) }//if (TicketNo > -1 && OrderTakeProfit() > 0) if (HiddenTakeProfit > 0 && ObjectFind(LineName) == -1) { ObjectDelete(LineName); ObjectCreate(LineName, OBJ_HLINE, 0, TimeCurrent(), HiddenTakeProfit); ObjectSet(LineName, OBJPROP_COLOR, Green); ObjectSet(LineName, OBJPROP_WIDTH, 1); ObjectSet(LineName, OBJPROP_STYLE, STYLE_DOT); }//if (HiddenTakeProfit > 0) LineName = SlPrefix + DoubleToStr(TicketNo, 0);//TicketNo is set by the calling function - either CountOpenTrades or DoesTradeExist HiddenStopLoss = 0; if (TicketNo > -1 && OrderStopLoss() > 0) { if (OrderType() == OP_BUY) { HiddenStopLoss = NormalizeDouble(OrderStopLoss() + (HiddenPips * Point), Digits); }//if (OrderType() == OP_BUY) if (OrderType() == OP_SELL || OrderType() == OP_SELLSTOP || OrderType() == OP_SELLLIMIT) { HiddenStopLoss = NormalizeDouble(OrderStopLoss() - (HiddenPips * Point), Digits); }//if (OrderType() == OP_BUY) }//if (TicketNo > -1 && OrderStopLoss() > 0) if (HiddenStopLoss > 0 && ObjectFind(LineName) == -1) { ObjectDelete(LineName); ObjectCreate(LineName, OBJ_HLINE, 0, TimeCurrent(), HiddenStopLoss); ObjectSet(LineName, OBJPROP_COLOR, Red); ObjectSet(LineName, OBJPROP_WIDTH, 1); ObjectSet(LineName, OBJPROP_STYLE, STYLE_DOT); }//if (HiddenStopLoss > 0) }//End void DrawPendingPriceLines() void DeletePendingPriceLines() { //ObjectDelete(pendingpriceline); string LineName = TpPrefix + DoubleToStr(TicketNo, 0); ObjectDelete(LineName); LineName = SlPrefix + DoubleToStr(TicketNo, 0); ObjectDelete(LineName); }//End void DeletePendingPriceLines() void ReplaceMissingSlTpLines() { if (OrderTakeProfit() > 0 || OrderStopLoss() > 0) DrawPendingPriceLines(); }//End void ReplaceMissingSlTpLines() void DeleteOrphanTpSlLines() { if (ObjectsTotal() == 0) return; for (int cc = ObjectsTotal() - 1; cc >= 0; cc--) { string name = ObjectName(cc); if ((StringSubstr(name, 0, 2) == TpPrefix || StringSubstr(name, 0, 2) == SlPrefix) && ObjectType(name) == OBJ_HLINE) { int tn = StrToDouble(StringSubstr(name, 2)); if (tn > 0) { if (!OrderSelect(tn, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() > 0) { ObjectDelete(name); }//if (!OrderSelect(tn, SELECT_BY_TICKET, MODE_TRADES) || OrderCloseTime() > 0) }//if (tn > 0) }//if (StringSubstr(name, 0, 1) == TpPrefix) }//for (int cc = ObjectsTotal() - 1; cc >= 0; cc--) }//End void DeleteOrphanTpSlLines() //END Pending trade price lines module /////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////// //TRADE MANAGEMENT MODULE void ReportError() { //All purpose sl mod error reporter. Called when a sl mod fails int err=GetLastError(); Alert(OrderTicket()," stop loss modification failed with error(",err,"): ",ErrorDescription(err)); Print(OrderTicket()," stop loss modification failed with error(",err,"): ",ErrorDescription(err)); }//void ReportError() void BreakEvenStopLoss() // Move stop loss to breakeven { double NewStop; bool result; bool modify=false; string LineName = SlPrefix + DoubleToStr(OrderTicket(), 0); double sl = ObjectGet(LineName, OBJPROP_PRICE1); if (OrderType()==OP_BUY) { if (OrderStopLoss() >= OrderOpenPrice() - (HiddenPips * Point) ) return; if (Bid >= OrderOpenPrice () + (Point*BreakEvenPips)) { //Calculate the new stop NewStop = NormalizeDouble(OrderOpenPrice()+(BreakEvenProfit*Point), Digits); if (HiddenPips > 0) { if (ObjectFind(LineName) == -1) { ObjectCreate(LineName, OBJ_HLINE, 0, TimeCurrent(), 0); ObjectSet(LineName, OBJPROP_COLOR, Red); ObjectSet(LineName, OBJPROP_WIDTH, 1); ObjectSet(LineName, OBJPROP_STYLE, STYLE_DOT); }//if (ObjectFind(LineName == -1) ) ObjectMove(LineName, 0, TimeCurrent(), NewStop); }//if (HiddenPips > 0) modify = true; }//if (Bid >= OrderOpenPrice () + (Point*BreakEvenPips) && }//if (OrderType()==OP_BUY) if (OrderType()==OP_SELL) { if ((OrderStopLoss() <= OrderOpenPrice() + (HiddenPips * Point) ) && OrderStopLoss() > 0) return; if (Ask <= OrderOpenPrice() - (Point*BreakEvenPips)) { //Calculate the new stop NewStop = NormalizeDouble(OrderOpenPrice()-(BreakEvenProfit*Point), Digits); if (HiddenPips > 0) { if (ObjectFind(LineName) == -1) { ObjectCreate(LineName, OBJ_HLINE, 0, TimeCurrent(), 0); ObjectSet(LineName, OBJPROP_COLOR, Red); ObjectSet(LineName, OBJPROP_WIDTH, 1); ObjectSet(LineName, OBJPROP_STYLE, STYLE_DOT); }//if (ObjectFind(LineName == -1) ) ObjectMove(LineName, 0, Time[0], NewStop); }//if (HiddenPips > 0) modify = true; }//if (Ask <= OrderOpenPrice() - (Point*BreakEvenPips) && (OrderStopLoss()>OrderOpenPrice()|| OrderStopLoss()==0)) }//if (OrderType()==OP_SELL) //Move 'hard' stop loss whether hidden or not. Don't want to risk losing a breakeven through disconnect. if (modify) { if (NewStop == OrderStopLoss() ) return; while (IsTradeContextBusy() ) Sleep(100); result = OrderModify(OrderTicket(), OrderOpenPrice(), NewStop, OrderTakeProfit(), OrderExpiration(), CLR_NONE); if (!result) ReportError(); }//if (modify) } // End BreakevenStopLoss sub void JumpingStopLoss() { // Jump sl by pips and at intervals chosen by user . //if (OrderProfit() < 0) return;//Nothing to do string LineName = SlPrefix + DoubleToStr(OrderTicket(), 0); double sl = ObjectGet(LineName, OBJPROP_PRICE1); //if (sl == 0) return;//No line, so nothing to do double NewStop; bool modify=false; bool result; if (OrderType()==OP_BUY) { //if (sl < OrderOpenPrice() ) return;//Not at breakeven yet // Increment sl by sl + JumpingStopPips. // This will happen when market price >= (sl + JumpingStopPips) //if (Bid>= sl + ((JumpingStopPips*2)*Point) ) sl = MathMax(sl, OrderOpenPrice()); if (Bid >= sl + ((JumpingStopPips * 2) * Point) )//George{ { NewStop = NormalizeDouble(sl + (JumpingStopPips * Point), Digits); if (AddBEP) NewStop = NormalizeDouble(NewStop + (BreakEvenProfit*Point), Digits); if (HiddenPips > 0) ObjectMove(LineName, 0, Time[0], NewStop); if (NewStop - OrderStopLoss() >= Point) modify = true;//George again. What a guy }// if (Bid>= sl + (JumpingStopPips*Point) && sl>= OrderOpenPrice()) }//if (OrderType()==OP_BUY) if (OrderType()==OP_SELL) { //if (sl > OrderOpenPrice() ) return;//Not at breakeven yet // Decrement sl by sl - JumpingStopPips. // This will happen when market price <= (sl - JumpingStopPips) //if (Bid<= sl - ((JumpingStopPips*2)*Point)) Original code sl = MathMin(sl, OrderOpenPrice()); if (sl == 0) sl = OrderOpenPrice(); if (Bid <= sl - ((JumpingStopPips * 2) * Point) )//George { NewStop = NormalizeDouble(sl - (JumpingStopPips * Point), Digits); if (AddBEP) NewStop = NormalizeDouble(NewStop - (BreakEvenProfit*Point), Digits); if (HiddenPips > 0) ObjectMove(LineName, 0, Time[0], NewStop); if (OrderStopLoss() - NewStop >= Point || OrderStopLoss() == 0) modify = true;//George again. What a guy }// close if (Bid>= sl + (JumpingStopPips*Point) && sl>= OrderOpenPrice()) }//if (OrderType()==OP_SELL) //Move 'hard' stop loss whether hidden or not. Don't want to risk losing a breakeven through disconnect. if (modify) { while (IsTradeContextBusy() ) Sleep(100); result = OrderModify(OrderTicket(), OrderOpenPrice(), NewStop, OrderTakeProfit(), OrderExpiration(), CLR_NONE); if (!result) ReportError(); }//if (modify) } //End of JumpingStopLoss sub void TrailingStopLoss() { if (OrderProfit() < 0) return;//Nothing to do string LineName = SlPrefix + DoubleToStr(OrderTicket(), 0); double sl = ObjectGet(LineName, OBJPROP_PRICE1); //if (sl == 0) return;//No line, so nothing to do double NewStop; bool modify=false; bool result; if (OrderType()==OP_BUY) { //if (sl < OrderOpenPrice() ) return;//Not at breakeven yet // Increment sl by sl + TrailingStopPips. // This will happen when market price >= (sl + JumpingStopPips) //if (Bid>= sl + (TrailingStopPips * Point) ) Original code sl = MathMax(sl, OrderOpenPrice()); if (Bid >= sl + (TrailingStopPips * Point) )//George { NewStop = NormalizeDouble(sl + (TrailingStopPips * Point), Digits); if (HiddenPips > 0) ObjectMove(LineName, 0, Time[0], NewStop); if (NewStop - OrderStopLoss() >= Point) modify = true;//George again. What a guy }//if (Bid >= MathMax(sl,OrderOpenPrice()) + (TrailingStopPips * Point) )//George }//if (OrderType()==OP_BUY) if (OrderType()==OP_SELL) { //if (sl > OrderOpenPrice() ) return;//Not at breakeven yet // Decrement sl by sl - TrailingStopPips. // This will happen when market price <= (sl - JumpingStopPips) //if (Bid<= sl - (TrailingStopPips * Point) ) Original code sl = MathMin(sl, OrderOpenPrice()); if (sl == 0) sl = OrderOpenPrice(); if (Bid <= sl - (TrailingStopPips * Point))//George { NewStop = NormalizeDouble(sl - (TrailingStopPips * Point), Digits); if (HiddenPips > 0) ObjectMove(LineName, 0, Time[0], NewStop); if (OrderStopLoss() - NewStop >= Point || OrderStopLoss() == 0) modify = true;//George again. What a guy }//if (Bid <= MathMin(sl, OrderOpenPrice() ) - (TrailingStopPips * Point) )//George }//if (OrderType()==OP_SELL) //Move 'hard' stop loss whether hidden or not. Don't want to risk losing a breakeven through disconnect. if (modify) { while (IsTradeContextBusy() ) Sleep(100); result = OrderModify(OrderTicket(), OrderOpenPrice(), NewStop, OrderTakeProfit(), OrderExpiration(), CLR_NONE); if (!result) ReportError(); }//if (modify) } // End of TrailingStopLoss sub void CandlestickTrailingStop() { //Trails the stop at the hi/lo of the previous candle shifted by the user choice. //Only tries to do this once per bar, so an invalid stop error will only be generated once. I could code for //a too-close sl, but cannot be arsed. Coders, sort this out for yourselves. if (OldCstBars == iBars(NULL, CstTimeFrame)) return; OldCstBars = iBars(NULL, CstTimeFrame); if (OrderProfit() < 0) return;//Nothing to do string LineName = SlPrefix + DoubleToStr(OrderTicket(), 0); double sl = ObjectGet(LineName, OBJPROP_PRICE1); if (sl == 0) return;//No line, so nothing to do double NewStop; bool modify=false; bool result; if (OrderType() == OP_BUY) { if (iLow(NULL, CstTimeFrame, CstTrailCandles) > sl) { NewStop = NormalizeDouble(iLow(NULL, CstTimeFrame, CstTrailCandles), Digits); if (HiddenPips > 0) { ObjectMove(LineName, 0, Time[0], NewStop); NewStop = NormalizeDouble(NewStop - (HiddenPips * Point), Digits); }//if (HiddenPips > 0) modify = true; }//if (iLow(NULL, CstTimeFrame, CstTrailCandles) > sl) }//if (OrderType == OP_BUY) if (OrderType() == OP_SELL) { if (iHigh(NULL, CstTimeFrame, CstTrailCandles) < sl) { NewStop = NormalizeDouble(iHigh(NULL, CstTimeFrame, CstTrailCandles), Digits); if (HiddenPips > 0) { ObjectMove(LineName, 0, Time[0], NewStop); NewStop = NormalizeDouble(NewStop + (HiddenPips * Point), Digits); }//if (HiddenPips > 0) modify = true; }//if (iHigh(NULL, CstTimeFrame, CstTrailCandles) < sl) }//if (OrderType() == OP_SELL) //Move 'hard' stop loss whether hidden or not. Don't want to risk losing a breakeven through disconnect. if (modify) { while (IsTradeContextBusy() ) Sleep(100); result = OrderModify(OrderTicket(), OrderOpenPrice(), NewStop, OrderTakeProfit(), OrderExpiration(), CLR_NONE); if (!result) ReportError(); }//if (modify) }//End void CandlestickTrailingStop() void TradeManagementModule() { // Call the working subroutines one by one. //Candlestick trailing stop if (UseCandlestickTrailingStop) CandlestickTrailingStop(); // Breakeven if(BreakEven) BreakEvenStopLoss(); // JumpingStop if(JumpingStop) JumpingStopLoss(); //TrailingStop if(TrailingStop) TrailingStopLoss(); }//void TradeManagementModule() //END TRADE MANAGEMENT MODULE //////////////////////////////////////////////////////////////////////////////////////////////// //+------------------------------------------------------------------+ //| expert start function | //+------------------------------------------------------------------+ int start() { //---- if (!IsDemo() ) { Alert("Cretin alert"); MessageBox("Listen, turnip-brain, which bit of" + NL + "DO NOT USE THIS ON A LIVE ACCOUNT YET. IT IS EXPERIMENTAL." + NL + "from post 1 do you not get? This EA is disabled."); return; }//if (!IsDemo() ) if (OrdersTotal() == 0) { TicketNo = -1; ForceTradeClosure = false; }//if (OrdersTotal() == 0) if (ForceTradeClosure) { CloseAllTrades(); return; }//if (ForceTradeClosure) //Daily results so far - they work on what in in the history tab, so users need warning that //what they see displayed on screen depends on that. //Code courtesy of TIG yet again. Thanks, George. static int OldHistoryTotal; if (OrdersHistoryTotal() != OldHistoryTotal) { CalculateDailyResult();//Does no harm to have a recalc from time to time OldHistoryTotal = OrdersHistoryTotal(); }//if (OrdersHistoryTotal() != OldHistoryTotal) ReadIndicatorValues(); //Delete orphaned tp/sl lines static int M15Bars; if (M15Bars != iBars(NULL, PERIOD_M15) ) { M15Bars = iBars(NULL, PERIOD_M15); DeleteOrphanTpSlLines(); }//if (M15Bars != iBars(NULL, PERIOD_M15) /////////////////////////////////////////////////////////////////////////////////////////////// //Find open trades. CountOpenTrades(); //Reset various bools if (OpenTrades == 0) { }//if (OpenTrades > 0) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Trading times bool TradeTimeOk = CheckTradingTimes(); if (!TradeTimeOk) { Comment("Outside trading hours\nstart_hourm-end_hourm: ", start_hourm, "-",end_hourm, "\nstart_houre-end_houre: ", start_houre, "-",end_houre); return; }//if (!TradeTimeOk) ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////// //Trading if (TicketNo == -1 && !StopTrading) { LookForTradingOpportunities(); }//if (TicketNo == -1) /////////////////////////////////////////////////////////////////////////////////////////////// DisplayUserFeedback(); //---- return(0); } //+------------------------------------------------------------------+ void drawTrendLine(string objname, int t1, double p1, int t2, double p2, color c, int style=STYLE_SOLID, int width=0) { if (ObjectFind(objname) == -1) { ObjectCreate(objname, OBJ_TREND, 0, t1,p1, t2,p2); } else { ObjectSet(objname, OBJPROP_TIME1, t1); ObjectSet(objname, OBJPROP_TIME2, t2); ObjectSet(objname, OBJPROP_PRICE1, p1); ObjectSet(objname, OBJPROP_PRICE2, p2); } ObjectSet(objname, OBJPROP_RAY, false); ObjectSet(objname, OBJPROP_COLOR, c); ObjectSet(objname, OBJPROP_STYLE, style); ObjectSet(objname, OBJPROP_WIDTH, width); } //+------------------------------------------------------------------+ bool CheckForSignal() { //reset flags ArrayInitialize(BuyFlagR,0); ArrayInitialize(SellFlagS,0); Signal=-1; //Check R1 for buy trade if(YesterdayClose>PivotD && OpenD>PivotD && BidPivotD) BuyFlagR[1] = Buy; if((R1D-Bid)<(TargetPips*Point)) BuyFlagR[2] = Buy; if(BuyFlagR[0]==Buy && BuyFlagR[1]==Buy && BuyFlagR[2]==Buy) Signal = Buy; //Check S1 for sell trade if(YesterdayCloseS1D && Bid>(PivotD + (Point*BuySellOffSet))) SellFlagS[0] = Sell; if(Bid-1) return(true); else return(false); } //+------------------------------------------------------------------+