//+------------------------------------------------------------------+
//| RobinHood.mq4 |
//| Copyright © 2009, Robert Hill |
//| |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, Robert Hill"
#property link ""
#include <stdlib.mqh>
#include <stderror.mqh>
// Define signal types
#define NONE 0
#define LONG 1
#define SHORT 2
#define CLOSEBUY 3
#define CLOSESELL 4
//---- input parameters
extern int MagicBase=10000;
extern string myComment = "Robin Hood";
extern int Slippage = 3;
extern int ShowText = 0;
extern int StochK1=120;
extern int ovrbotlevel1=85;
extern int ovrsoldlevel1=10;
extern int StochK2 = 15;
extern int ovrbotlevel2=40;
extern int TargetBotLevel2 = 95;
extern int ovrsoldlevel2=70;
extern int TargetSoldLevel2 = 5;
extern int StopLoss = 35;
extern int TakeProfit = 50;
extern string tsp = "--Trailing Stop Types--";
extern string tsp0 = " 0 = Do not trail";
extern string tsp1 = " 1 = Trail immediately";
extern string tsp2 = " 2 = Wait to trail";
extern string tsp3 = " 3 = Uses 3 levels before trail";
extern string tsp4 = " 4 = Breakeven + Lockin";
extern int TrailingStopType = 2;
extern string ts2 = "Settings for Type 2";
extern double TrailingStop = 15; // Change to whatever number of pips you wish to trail your position with.
extern string ts3 = "Settings for Type 3";
extern double FirstMove = 10; // Type 3 first level pip gain
extern double FirstStopLoss = 30; // Move Stop to Breakeven
extern double SecondMove = 25; // Type 3 second level pip gain
extern double SecondStopLoss = 20; // Move stop to lock is profit
extern double ThirdMove = 35; // type 3 third level pip gain
extern double TrailingStop3 = 15; // Move stop and trail from there
extern string ts4 = "Settings for Type 4";
extern double BreakEven = 25;
extern int LockInPips = 10; // Profit Lock in pips
//+---------------------------------------------------+
//|Money Management |
//+---------------------------------------------------+
extern string mm = "---Money Management---";
extern double Lots=0.01;
extern bool UseMoneyManagement = false; // Change to false to shutdown money management controls.
extern bool BrokerIsIBFX = false;
extern bool BrokerIsCrownForex = false;
extern string m1="Set mini and micro to false for standard account";
extern bool AccountIsMini = false;
extern bool AccountIsMicro = true;
extern double TradeSizePercent = 1; // Change to whatever percent of equity you wish to risk.
extern bool BrokerPermitsFractionalLots = true;
extern string ef3="Friday No Trade - Enter 0 for false, 1 for true";
extern int UseFridayNoTradeTime = 0;
extern int FridayFinalHour = 20; // No trades to start after time
int FridayFinalTime; // No trades to start after time
extern string sm0="--Trading Hours Filter--";
extern string sm2="UseTradingHours - Enter 0 for false, 1 for true";
extern int UseTradingHours = 0;
extern string sm4="TradeAsian - Enter 0 for false, 1 for true";
extern int TradeAsianMarket = 1;
extern int AsianStart = 100; // Start trades after time
extern int AsianStop = 400; // Stop trading after time
extern string sm5="Trade Europe - Enter 0 for false, 1 for true";
extern int TradeEuropeanMarket = 1;
extern int EurStart = 1000; // Start trades after time
extern int EurStop = 1200; // Stop trading after time
extern string sm6="Trade NY - Enter 0 for false, 1 for true";
extern int TradeNewYorkMarket = 1;
extern int NYStart = 1600; // Start trades after time
extern int NYStop = 1800; // Stop trading after time
extern string to="---Text Object Settings---";
extern int StatusTxtSize = 10;
extern color StatusColor = White;
extern int CommentTxtSize = 10;
extern color CommentColor = White;
extern int TrendTxtSize = 10;
extern color TrendColor = White;
extern int LookingTxtSize = 10;
extern color LookingColor = White;
extern int FoundTxtSize = 10;
extern color FoundColor = White;
extern int WaitingTxtSize = 10;
extern color WaitingColor = White;
extern int ConditionTxtSize = 10;
extern color ConditionColor = White;
extern int TradeTxtSize = 10;
extern color TradeColor = White;
extern int DrawDownTxtSize = 10;
extern color DrawDownColor = White;
extern color MarkColor = Red;
int StatusY, Comment1Y, TrendY;
int LookingY, FoundY, ConditionY;
int Trade1Y, Trade2Y, Trade3Y, Trade4Y;
string StatusLabel, Comment1Label, TrendLabel;
string LookingLabel, FoundLabel, ConditionLabel;
string Trade1Label, Trade2Label, Trade3Label, Trade4Label, MarkLabel;
// Indicator values
double StochMain11, StochMain12;
double StochSignal11, StochSignal12;
double StochMain21, StochMain22;
double StochSignal21, StochSignal22;
string StatusStr = "Robin Hood";
double myPoint;
int MagicNumber;
bool rule1;
double mLots;
int LastTrade = NONE;
//+------------------------------------------------------------------+
//| expert initialization function |
//+------------------------------------------------------------------+
int init()
{
MagicNumber = MagicBase + func_Symbol2Val(Symbol())*100 + Period();
if (ShowText == 1)
{
DeleteExistingLabels();
SetupLabels();
ClearLabels();
OutputStatusToChart(StatusStr + " INITIALIZED SUCCESSFULLY");
}
myPoint = SetPoint();
rule1 = NONE;
return(0);
}
//+------------------------------------------------------------------+
//| expert start function |
//+------------------------------------------------------------------+
int start()
{
bool YesStop;
int NumOrders = 0, signal = 0;
if (ShowText == 1)
{
if (Comment1Y < 10)
{
SetupLabels();
ClearLabels();
DeleteExistingLabels();
SetupLabels();// Make sure label settings are OK
}
}
if (IsTesting() == false)
{
if (IsExpertEnabled() == false)
{
if (ShowText == 1)
{
OutputComment1ToChart("Expert is not enabled");
}
return(0);
}
}
if (IsTradeAllowed()==false ) return(0);
NumOrders = CalculateCurrentOrders();
if (NumOrders == 0)
{
if (ShowText == 1)
{
ClearWorkingLabels();
}
YesStop = CheckTradeFilters();
if (YesStop == false)
{
if (!NewBar()) return(0); // wait until first tick after bar close to take any action;
signal = GetEntrySignal();
if (signal != NONE)
{
mLots = GetLots();
if (LastTrade == NONE) OpenNewTrades(signal, mLots);
if (LastTrade == LONG && signal == SHORT) OpenNewTrades(signal, mLots);
if (LastTrade == SHORT && signal == LONG) OpenNewTrades(signal, mLots);
}
}
else
rule1 = NONE;
}
else
{
RefreshRates();
CheckForClose();
}
return(0);
}
int CheckStochRule1()
{
StochMain11 = iStochastic(NULL, 0, StochK1, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
StochSignal11 = iStochastic(NULL, 0, StochK1, 3, 3, MODE_SMA, 0, MODE_SIGNAL, 1);
StochMain21 = iStochastic(NULL, 0, StochK2, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
StochSignal21 = iStochastic(NULL, 0, StochK2, 3, 3, MODE_SMA, 0, MODE_SIGNAL, 1);
if (StochMain11 > ovrbotlevel1)
{
if (StochMain21 > ovrbotlevel2) return(LONG);
}
if (StochMain11 < ovrsoldlevel1)
{
if (StochMain21 < ovrsoldlevel2) return(SHORT);
}
return(NONE);
}
bool CheckStochRule2(int cmd)
{
StochMain21 = iStochastic(NULL, 0, StochK2, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
StochSignal21 = iStochastic(NULL, 0, StochK2, 3, 3, MODE_SMA, 0, MODE_SIGNAL, 1);
if (cmd == LONG)
{
if (StochMain21 > ovrbotlevel2)
{
if (ShowText == 1)
{
OutputFoundToChart("Stoch 2 Still above target");
}
return(false);
}
return(true);
}
if (cmd == SHORT)
{
if (StochMain21 < ovrsoldlevel2)
{
if (ShowText == 1)
{
OutputFoundToChart("Stoch 2 Still below target");
}
return(false);
}
return(true);
}
return(false);
}
int GetEntrySignal()
{
bool rule2 = false;
if (rule1 == NONE) rule1 = CheckStochRule1();
if (rule1 == NONE)
{
if (ShowText == 1)
{
ClearWorkingLabels();
OutputTrendToChart("Stoch 1 is neutral");
}
return(NONE);
}
if (rule1 == LONG)
{
if (ShowText == 1)
{
OutputTrendToChart("Stoch 1 overbought");
OutputLookingToChart( "Looking for Stoch 2 peak" );
}
rule2 = CheckStochRule2(LONG);
if (rule2 == false) return(NONE);
if (ShowText == 1)
{
OutputFoundToChart("Stoch 2 Peak found");
}
rule1 = NONE;
if (ShowText == 1)
{
OutputConditionToChart("All conditions met, entering " + isUpOrDown(LONG) + " trade");
}
return(LONG);
}
if (rule1 == SHORT)
{
if (ShowText == 1)
{
OutputTrendToChart("Stoch 1 oversold");
OutputLookingToChart( "Looking for Stoch 2 trough" );
}
rule2 = CheckStochRule2(SHORT);
if (rule2 == false) return(NONE);
if (ShowText == 1)
{
OutputFoundToChart("Stoch 2 Trough found");
}
rule1 = NONE;
if (ShowText == 1)
{
OutputConditionToChart("All conditions met, entering " + isUpOrDown(SHORT) + " trade");
}
return (SHORT);
}
return(NONE);
}
int GetExitSignal(int cmd)
{
StochMain21 = iStochastic(NULL, 0, StochK2, 3, 3, MODE_SMA, 0, MODE_MAIN, 1);
StochSignal21 = iStochastic(NULL, 0, StochK2, 3, 3, MODE_SMA, 0, MODE_SIGNAL, 1);
if (cmd == OP_BUY)
{
if (StochMain21 >= TargetBotLevel2) return(CLOSEBUY); //red HA candle
}
if (cmd == OP_SELL)
{
if (StochMain21 <= TargetSoldLevel2) return(CLOSESELL); //green HA candle
}
return(NONE);
}
void OpenNewTrades(int mSignal, double mLots)
{
int ticket, err;
double TPprice,STprice;
double OrderOP;
RefreshRates();
// Place new trades
if (mSignal == SHORT)
{
ticket=OrderSend(Symbol(),OP_SELL,mLots,Bid,Slippage * myPoint,0,0,
myComment,MagicNumber,0,Red); //Sell at Market price
if (ticket > 0)
{
LastTrade = SHORT;
OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES);
OrderOP = OrderOpenPrice();
if (StopLoss != 0 || TakeProfit != 0)
{
TPprice = 0;
if (TakeProfit > 0)
{
TPprice=TakeShort(OrderOP, TakeProfit);
}
STprice = 0;
if (StopLoss > 0)
{
STprice=StopShort(OrderOP, StopLoss);
STprice = ValidStopLoss(OP_SELL,Ask, STprice);
}
// Normalize stoploss / takeprofit to the proper # of digits.
if (Digits > 0)
{
STprice = NormalizeDouble( STprice, Digits);
TPprice = NormalizeDouble( TPprice, Digits);
}
ModifyOrder(ticket, OrderOP, STprice, TPprice, LightGreen);
}
if (ShowText == 1)
{
OutputTrade1ToChart("Ticket : " + ticket);
OutputTrade2ToChart(" SELL : " + DoubleToStr(mLots, 2) + " Lots at " + DoubleToStr(OrderOpenPrice(), Digits));
}
}
}
if (mSignal == LONG)
{
ticket=OrderSend(Symbol(),OP_BUY,mLots,Ask,Slippage * myPoint,0,0,
myComment,MagicNumber,0,Lime); //Buy at Market price
if (ticket > 0)
{
LastTrade = LONG;
OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES);
OrderOP = OrderOpenPrice();
if (StopLoss != 0 || TakeProfit != 0)
{
TPprice = 0;
if (TakeProfit > 0)
{
TPprice=TakeLong(OrderOP,TakeProfit);
}
STprice = 0;
if (StopLoss > 0)
{
STprice=StopLong(OrderOP ,StopLoss);
STprice = ValidStopLoss(OP_BUY,Bid, STprice);
}
// Normalize stoploss / takeprofit to the proper # of digits.
if (Digits > 0)
{
STprice = NormalizeDouble( STprice, Digits);
TPprice = NormalizeDouble( TPprice, Digits);
}
ModifyOrder(ticket, OrderOP, STprice, TPprice, Red);
}
if (ShowText == 1)
{
OutputTrade1ToChart("Ticket : " + ticket);
OutputTrade2ToChart(" BUY : " + DoubleToStr(mLots, 2) + " Lots at " + DoubleToStr(OrderOpenPrice(), Digits));
}
}
}
if(ticket<0)
{
err = GetLastError();
if (ShowText == 1)
{
OutputTrade1ToChart("OrderSend failed : (" + err + ")");
OutputTrade2ToChart(ErrorDescription(err));
}
}
}
void CheckForClose()
{
int Signal, result, err;
// Check for open trades to close or modify
for(int cnt=OrdersTotal()-1;cnt>=0;cnt--)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
{
Signal = GetExitSignal(OrderType());
result = true;
if(OrderType() == OP_BUY)
{
if (Signal == CLOSEBUY)
{
result = OrderClose(OrderTicket(), OrderLots(), Bid, 3, Red);
}
else
if (TrailingStopType > 0) HandleTrailingStop(OP_BUY,OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
}
if(OrderType() == OP_SELL)
{
if (Signal == CLOSESELL)
{
result = OrderClose(OrderTicket(), OrderLots(), Ask, 3, Lime);
}
else
if (TrailingStopType > 0) HandleTrailingStop(OP_SELL,OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
}
if (result == false)
{
err = GetLastError();
if (ShowText == 1)
{
OutputTrade3ToChart(" Error closing order : (" + err + ")");
OutputTrade4ToChart(ErrorDescription(err));
}
}
}
}
}
//----
//+------------------------------------------------------------------+
//| HandleTrailingStop |
//| Type 1 moves the stoploss without delay. |
//| Type 2 waits for price to move the amount of the trailStop |
//| before moving stop loss then moves like type 1 |
//| Type 3 uses up to 3 levels for trailing stop |
//| Level 1 Move stop to 1st level |
//| Level 2 Move stop to 2nd level |
//| Level 3 Trail like type 1 by fixed amount other than 1 |
//| Type 4 Move stop to breakeven + Lockin, no trail |
//| Type 5 uses steps for 1, every step pip move moves stop 1 pip |
//| Type 6 Uses EMA to set trailing stop |
//+------------------------------------------------------------------+
int HandleTrailingStop(int type, int ticket, double op, double os, double tp)
{
switch (TrailingStopType)
{
case 1 : Immediate_TrailingStop (type, ticket, op, os, tp);
break;
case 2 : Delayed_TrailingStop (type, ticket, op, os, tp);
break;
case 3 : ThreeLevel_TrailingStop (type, ticket, op, os, tp);
break;
case 4 : BreakEven_TrailingStop (type, ticket, op, os, tp);
break;
}
return(0);
}
int ModifyOrder(int ord_ticket,double op, double oSL, double oTP, color mColor)
{
int CloseCnt, err;
double myStop, myTake;
/*
if (Digits > 0)
{
myStop = NormalizeDouble( oSL, Digits);
myTake = NormalizeDouble( oTP, Digits);
}
*/
CloseCnt=0;
while (CloseCnt < 3)
{
if (OrderModify(ord_ticket,op,oSL,oTP,0,mColor))
{
CloseCnt = 3;
}
else
{
err=GetLastError();
Print(CloseCnt," Error modifying order : (", err , ") " + ErrorDescription(err));
if (err>0) CloseCnt++;
}
}
}
double ValidStopLoss(int type, double price, double SL)
{
double mySL;
double minstop;
if (SL < 0.1) return(SL);
mySL = SL;
minstop = MarketInfo(Symbol(),MODE_STOPLEVEL);
if (Digits == 3 || Digits == 5) minstop = minstop / 10;
if (type == OP_BUY)
{
if((price - SL) < minstop*myPoint) mySL = price - minstop*myPoint;
}
if (type == OP_SELL)
{
if((SL-price) < minstop*myPoint) mySL = price + minstop*myPoint;
}
return(NormalizeDouble(mySL,MarketInfo(Symbol(), MODE_DIGITS)));
}
//+------------------------------------------------------------------+
//| Immediate_TrailingStop.mq4 |
//| Copyright © 2006, Forex-TSD.com |
//| Written by MrPip,robydoby314@yahoo.com |
//| |
//| Moves the stoploss without delay. |
//+------------------------------------------------------------------+
void Immediate_TrailingStop(int type, int ticket, double op, double os, double tp)
{
int digits;
double pt, pBid, pAsk, BuyStop, SellStop;
digits = MarketInfo(Symbol( ), MODE_DIGITS);
if (type==OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
pt = StopLoss * myPoint;
if(pBid-os > pt)
{
BuyStop = pBid - pt;
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);
if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
return;
}
}
if (type==OP_SELL)
{
pAsk = MarketInfo(Symbol(), MODE_ASK);
pt = StopLoss * myPoint;
if(os - pAsk > pt)
{
SellStop = pAsk + pt;
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
return;
}
}
}
//+------------------------------------------------------------------+
//| Delayed_TrailingStop.mq4 |
//| Copyright © 2006, Forex-TSD.com |
//| Written by MrPip,robydoby314@yahoo.com |
//| |
//| Waits for price to move the amount of the TrailingStop |
//| Moves the stoploss pip for pip after delay. |
//+------------------------------------------------------------------+
void Delayed_TrailingStop(int type, int ticket, double op, double os, double tp)
{
int digits;
double pt, pBid, pAsk, BuyStop, SellStop;
pt = TrailingStop * myPoint;
digits = MarketInfo(Symbol(), MODE_DIGITS);
if (type==OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
BuyStop = pBid - pt;
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);
if (pBid-op > pt && os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
return;
}
if (type==OP_SELL)
{
pAsk = MarketInfo(Symbol(), MODE_ASK);
pt = TrailingStop * myPoint;
SellStop = pAsk + pt;
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (op - pAsk > pt && os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
return;
}
}
//+------------------------------------------------------------------+
//| BreakEvenExpert_v1.mq4 |
//| Copyright © 2006, Forex-TSD.com |
//| Written by IgorAD,igorad2003@yahoo.co.uk |
//| http://finance.groups.yahoo.com/group/TrendLaboratory |
//+------------------------------------------------------------------+
void BreakEven_TrailingStop(int type, int ticket, double op, double os, double tp)
{
int digits;
double pBid, pAsk, BuyStop, SellStop;
digits = MarketInfo(Symbol(), MODE_DIGITS);
if (type==OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
if ( pBid-op > myPoint*BreakEven )
{
BuyStop = op + LockInPips * myPoint;
if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);
if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
return;
}
}
if (type==OP_SELL)
{
pAsk = MarketInfo(Symbol(), MODE_ASK);
if ( op - pAsk > myPoint*BreakEven )
{
SellStop = op - LockInPips * myPoint;
if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
return;
}
}
}
//+------------------------------------------------------------------+
//| ThreeLevel_TrailingStop.mq4 |
//| Copyright © 2006, Forex-TSD.com |
//| Written by MrPip,robydoby314@yahoo.com |
//| |
//| Uses up to 3 levels for trailing stop |
//| Level 1 Move stop to 1st level |
//| Level 2 Move stop to 2nd level |
//| Level 3 Trail like type 1 by fixed amount other than 1 |
//+------------------------------------------------------------------+
void ThreeLevel_TrailingStop(int type, int ticket, double op, double os, double tp)
{
int digits;
double pBid, pAsk, BuyStop, SellStop;
digits = MarketInfo(Symbol(), MODE_DIGITS) ;
if (type == OP_BUY)
{
pBid = MarketInfo(Symbol(), MODE_BID);
if (pBid - op > FirstMove * myPoint)
{
BuyStop = op + FirstMove*myPoint - FirstStopLoss * myPoint;
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);
if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
}
if (pBid - op > SecondMove * myPoint)
{
BuyStop = op + SecondMove*myPoint - SecondStopLoss * myPoint;
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);
if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
}
if (pBid - op > ThirdMove * myPoint)
{
BuyStop = pBid - ThirdMove*myPoint;
if (digits > 0) BuyStop = NormalizeDouble(BuyStop, digits);
BuyStop = ValidStopLoss(OP_BUY, pBid, BuyStop);
if (os < BuyStop) ModifyOrder(ticket,op,BuyStop,tp,LightGreen);
}
}
if (type == OP_SELL)
{
pAsk = MarketInfo(Symbol(), MODE_ASK);
if (op - pAsk > FirstMove * myPoint)
{
SellStop = op - FirstMove * myPoint + FirstStopLoss * myPoint;
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
}
if (op - pAsk > SecondMove * myPoint)
{
SellStop = op - SecondMove * myPoint + SecondStopLoss * myPoint;
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
}
if (op - pAsk > ThirdMove * myPoint)
{
SellStop = pAsk + ThirdMove * myPoint;
if (digits > 0) SellStop = NormalizeDouble(SellStop, digits);
SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);
if (os > SellStop) ModifyOrder(ticket,op,SellStop,tp,DarkOrange);
}
}
}
//-- Check for Start of a new Bar
bool NewBar()
{
static datetime dt = 0;
if (Time[0] != dt)
{
dt = Time[0];
return(true);
}
return(false);
}
double StopLong(double price,int stop)
{
if(stop==0)
return(0);
else
return(price-(stop*myPoint));
}
double StopShort(double price,int stop)
{
if(stop==0)
return(0);
else
return(price+(stop*myPoint));
}
double TakeLong(double price,int take)
{
if(take==0)
return(0);
else
return(price+(take*myPoint));
}
double TakeShort(double price,int take)
{
if(take==0)
return(0);
else
return(price-(take*myPoint));
}
int CalculateCurrentOrders()
{
int buys = 0, sells = 0, num = 0;
for(int i=OrdersTotal()-1;i>=0;i--)
{
OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
if(OrderSymbol()== Symbol() && OrderMagicNumber()== MagicNumber)
{
if(OrderType() == OP_BUY) buys++;
if(OrderType() == OP_SELL) sells++;
}
}
num = buys + sells;
return(num);
}
//+------------------------------------------------------------------+
//| expert deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
if (ShowText == 1)
{
ClearLabels();
DeleteExistingLabels();
}
return(0);
}
//+------------------------------------------------------------------+
//| Get number of lots for this trade |
//+------------------------------------------------------------------+
double GetLots()
{
double lot;
double myMaxLot = MarketInfo(Symbol(), MODE_MAXLOT);
if(UseMoneyManagement == false) return(Lots);
if (BrokerIsIBFX == true)
{
lot = Calc_IBFX_Money_Management();
return(lot);
}
if (BrokerIsCrownForex == true)
{
lot = Calc_CrownMoney_Management();
return(lot);
}
// lot = LotsOptimized();
lot=NormalizeDouble((AccountEquity()*TradeSizePercent/10000)/10,2);
// lot = MathRound( lot/myStep ) * myStep;
// Use at least 1 micro lot
if (AccountIsMicro == true)
{
lot = MathFloor(lot*100)/100;
if (lot < 0.01) lot = 0.01;
if (lot > myMaxLot) lot = myMaxLot;
return(lot);
}
// Use at least 1 mini lot
if(AccountIsMini == true)
{
lot = MathFloor(lot*10)/10;
if (lot < 0.1) lot = 0.1;
if (lot > myMaxLot) lot = myMaxLot;
return(lot);
}
// Standard account
if( BrokerPermitsFractionalLots == false)
{
if (lot >= 1.0) lot = MathFloor(lot); else lot = 1.0;
}
if (lot < 1.0) lot = 1.0;
if (lot > myMaxLot) lot = myMaxLot;
return(lot);
}
double Calc_CrownMoney_Management()
{
double lot;
lot=NormalizeDouble((AccountEquity()*TradeSizePercent/10000)/10,1);
// lot = MathRound( lot/myStep ) * myStep;
// Use at least 1 mini lot
if(AccountIsMini == true)
{
lot = MathFloor(lot*10)/10 * 10000;
if (lot < 10000) lot = 10000;
// if (lot > myMaxLot) lot = myMaxLot;
return(lot);
}
// Standard account
lot = lot * 100000;
if (lot < 100000) lot = 100000;
// if (lot > myMaxLot) lot = myMaxLot;
return(lot);
}
double Calc_IBFX_Money_Management()
{
// variables used for money management
double lot;
double myMaxLot = MarketInfo(Symbol(), MODE_MAXLOT);
lot=NormalizeDouble((AccountEquity()*TradeSizePercent/10000)/10,2);
// Use at least 1 micro lot
if (AccountIsMicro == true)
{
lot = lot * 10;
lot = MathFloor(lot*100)/100;
if (lot < 0.1) lot = 0.1;
if (lot > myMaxLot) lot = myMaxLot;
return(lot);
}
// Use at least 1 mini lot
if(AccountIsMini == true)
{
lot = lot * 10;
lot = MathFloor(lot*10)/10;
if (lot < 1) lot = 1;
if (lot > myMaxLot) lot = myMaxLot;
return(lot);
}
// Standard Account
if(BrokerPermitsFractionalLots == true)
lot = StrToDouble(DoubleToStr(lot, 2));
else
lot = MathFloor(lot);
if (lot > myMaxLot) lot = myMaxLot;
return(lot);
}
double SetPoint()
{
double mPoint;
if (Digits < 4)
mPoint = 0.01;
else
mPoint = 0.0001;
return(mPoint);
}
string isUpOrDown(int i)
{
if(i==LONG) return ("LONG"); else if (i==SHORT) return("SHORT");
}
int func_Symbol2Val(string symbol)
{
string mySymbol = StringSubstr(symbol,0,6);
if(mySymbol=="AUDCAD") return(1);
if(mySymbol=="AUDJPY") return(2);
if(mySymbol=="AUDNZD") return(3);
if(mySymbol=="AUDUSD") return(4);
if(mySymbol=="CHFJPY") return(5);
if(mySymbol=="EURAUD") return(6);
if(mySymbol=="EURCAD") return(7);
if(mySymbol=="EURCHF") return(8);
if(mySymbol=="EURGBP") return(9);
if(mySymbol=="EURJPY") return(10);
if(mySymbol=="EURUSD") return(11);
if(mySymbol=="GBPCHF") return(12);
if(mySymbol=="GBPJPY") return(13);
if(mySymbol=="GBPUSD") return(14);
if(mySymbol=="NZDJPY") return(15);
if(mySymbol=="NZDUSD") return(16);
if(mySymbol=="USDCAD") return(17);
if(mySymbol=="USDCHF") return(18);
if(mySymbol=="USDJPY") return(19);
Comment("unexpected Symbol");
return(999);
}
string tf2txt(int tf)
{
switch(tf)
{
case PERIOD_M1: return("M1");
case PERIOD_M5: return("M5");
case PERIOD_M15: return("M15");
case PERIOD_M30: return("M30");
case PERIOD_H1: return("H1");
case PERIOD_H4: return("H4");
case PERIOD_D1: return("D1");
case PERIOD_W1: return("W1");
case PERIOD_MN1: return("MN");
}
return("??");
}
//+------------------------------------------------------------------+
//| Labels_inc.mqh |
//| Copyright © 2007 |
//| |
//+------------------------------------------------------------------+
void OutputMarkToChart(int yPos, int TxtSize, string myMark)
{
if(ObjectFind(MarkLabel) != 0)
{
ObjectCreate(MarkLabel, OBJ_LABEL, 0, 0, 0);
}
ObjectSet(MarkLabel, OBJPROP_CORNER, 0);
ObjectSet(MarkLabel, OBJPROP_XDISTANCE, 10);
ObjectSet(MarkLabel, OBJPROP_YDISTANCE, yPos);
ObjectSetText(MarkLabel,myMark, TxtSize*2, "Arial Bold", MarkColor);
}
void ClearLabels()
{
string mComment = " ";
OutputStatusToChart( mComment);
OutputComment1ToChart( mComment);
OutputTrendToChart( mComment);
OutputLookingToChart( mComment);
OutputFoundToChart( mComment);
OutputConditionToChart( mComment);
OutputTrade1ToChart( mComment);
OutputTrade2ToChart( mComment);
OutputTrade3ToChart( mComment);
OutputTrade4ToChart( mComment);
}
void ClearWorkingLabels()
{
string mComment = " ";
// OutputTrendToChart( mComment);
// OutputLookingToChart( mComment);
// OutputFoundToChart( mComment);
OutputConditionToChart( mComment);
OutputTrade1ToChart( mComment);
OutputTrade2ToChart( mComment);
OutputTrade3ToChart( mComment);
OutputTrade4ToChart( mComment);
}
void DeleteExistingLabels()
{
int objLabels = ObjectsTotal(OBJ_LABEL);
string objName;
string prefix;
prefix = "RH_" + Symbol() + tf2txt(Period());
if (objLabels > 0)
{
for (int i = objLabels; i >= 0;i--)
{
objName = ObjectName(i);
if (StringFind(objName,prefix + "Status", 0) >= 0) { ObjectDelete(objName); continue; }
if (StringFind(objName,prefix + "Comment1", 0) >= 0) { ObjectDelete(objName); continue; }
if (StringFind(objName,prefix + "Trend", 0) >= 0) { ObjectDelete(objName); continue; }
if (StringFind(objName,prefix + "Looking", 0) >= 0) { ObjectDelete(objName); continue; }
if (StringFind(objName,prefix + "Found", 0) >= 0) { ObjectDelete(objName); continue; }
if (StringFind(objName,prefix + "Condition", 0) >= 0) { ObjectDelete(objName); continue; }
if (StringFind(objName,prefix + "Trade", 0) >= 0) { ObjectDelete(objName); continue; }
if (StringFind(objName,prefix + "Mark", 0) >= 0) ObjectDelete(objName);
}
}
}
void SetupLabels()
{
string prefix;
prefix = "HH_" + Symbol() + tf2txt(Period());
StatusY = 12;
Comment1Y = StatusY + StatusTxtSize + 4;
TrendY = Comment1Y + CommentTxtSize + 4;
LookingY = TrendY + TrendTxtSize + 4;
FoundY = LookingY + LookingTxtSize + 4;
ConditionY = FoundY + FoundTxtSize + 4;
Trade1Y = ConditionY + ConditionTxtSize + 4;
Trade2Y = Trade1Y + TradeTxtSize + 4;
Trade3Y = Trade2Y + TradeTxtSize + 4;
Trade4Y = Trade3Y + TradeTxtSize + 4;
StatusLabel = prefix + "Status";
Comment1Label = prefix + "Comment1";
TrendLabel = prefix + "Trend";
LookingLabel = prefix + "Looking";
FoundLabel = prefix + "Found";
ConditionLabel = prefix + "Condition";
Trade1Label = prefix + "Trade1";
Trade2Label = prefix + "Trade2";
Trade3Label = prefix + "Trade3";
Trade4Label = prefix + "Trade4";
MarkLabel = prefix + "Mark";
}
void OutputLabelToChart(string LabelName, int LabelY, int LabelTxtSize, color LabelColor, string LabelStr, string MarkString)
{
// string mtime=Month()+"/"+Day()+" "+Hour()+":"+Minute()+":"+Seconds()+" ";
if(ObjectFind(LabelName) != 0)
{
ObjectCreate(LabelName, OBJ_LABEL, 0, 0, 0);
ObjectSet(LabelName, OBJPROP_CORNER, 0);
ObjectSet(LabelName, OBJPROP_XDISTANCE, 20);
ObjectSet(LabelName, OBJPROP_YDISTANCE, LabelY);
}
ObjectSetText(LabelName, LabelStr, LabelTxtSize, "Arial Bold", LabelColor);
OutputMarkToChart(LabelY, LabelTxtSize, MarkString);
}
void OutputStatusToChart(string mComment)
{
OutputLabelToChart(StatusLabel, StatusY, StatusTxtSize, StatusColor, mComment, "*");
}
void OutputComment1ToChart(string mComment)
{
OutputLabelToChart(Comment1Label, Comment1Y, CommentTxtSize, CommentColor, mComment, "*");
}
void OutputTrendToChart(string mComment)
{
OutputLabelToChart(TrendLabel, TrendY, TrendTxtSize, TrendColor, mComment, "*");
}
void OutputLookingToChart(string mComment)
{
OutputLabelToChart(LookingLabel, LookingY, LookingTxtSize, LookingColor, mComment, "*");
}
void OutputFoundToChart(string mComment)
{
OutputLabelToChart(FoundLabel, FoundY, FoundTxtSize, FoundColor, mComment, "*");
}
void OutputConditionToChart(string mComment)
{
OutputLabelToChart(ConditionLabel, ConditionY, ConditionTxtSize, ConditionColor, mComment, "*");
}
void OutputTrade1ToChart(string mComment)
{
OutputLabelToChart(Trade1Label, Trade1Y, TradeTxtSize, TradeColor, mComment, "*");
}
void OutputTrade2ToChart(string mComment)
{
OutputLabelToChart(Trade2Label, Trade2Y, TradeTxtSize, TradeColor, mComment, "*");
}
void OutputTrade3ToChart(string mComment)
{
OutputLabelToChart(Trade3Label, Trade3Y, TradeTxtSize, TradeColor, mComment, "*");
}
void OutputTrade4ToChart(string mComment)
{
OutputLabelToChart(Trade4Label, Trade4Y, TradeTxtSize, TradeColor, mComment, "*");
}
bool CheckTradeFilters()
{
bool myStop, Expired;
myStop = false;
if (UseTradingHours == 1)
{
myStop = CheckTradingTimes();
if (ShowText == 1)
{
if (myStop == true)
{
OutputComment1ToChart ("Trading has been stopped - wrong time of day");
}
else
{
OutputComment1ToChart ("Trading has resumed - time is OK");
}
}
}
else
if (ShowText == 1)
{
OutputComment1ToChart("Trading Time filter not in use");
}
//+------------------------------------------------------------------+
//| Friday No trade zone |
//+------------------------------------------------------------------+
if (myStop == false)
{
if (UseFridayNoTradeTime == 1)
{
if(DayOfWeek()==5 && Hour() >= FridayFinalHour)
{
myStop = true;
if (ShowText == 1)
{
OutputComment1ToChart ("Trading has been stopped - Friday");
}
}
}
}
return(myStop);
}
bool IsNotValidTradingTime( int StartHour, int EndHour)
{
int lHour=Hour() *100+Minute( );
if(StartHour<=EndHour)
{
if(lHour<StartHour || lHour>EndHour) return(true) ;
}
else if(lHour>EndHour && lHour<StartHour) return(true) ;
return(false) ;
}
bool CheckTradingTimes()
{
bool StopTrading;
int ct;
ct = Hour() * 100 + Minute();
StopTrading = true;
// Check trading Asian Market
if (TradeAsianMarket == 1)
{
StopTrading = IsNotValidTradingTime(AsianStart, AsianStop);
}
if (StopTrading == true)
{
// Check trading European Market
if (TradeEuropeanMarket == 1)
{
StopTrading = IsNotValidTradingTime(EurStart, EurStop);
}
}
if (StopTrading == true)
{
// Check trading New York Market
if (TradeNewYorkMarket == 1)
{
StopTrading = IsNotValidTradingTime(NYStart, NYStop);
}
}
return(StopTrading);
}
//----
Sample
Analysis
Market Information Used:
Series array that contains open time of each bar
Indicator Curves created:
Indicators Used:
Stochastic oscillator
Custom Indicators Used:
Order Management characteristics:
Checks for the total of open orders
It Closes Orders by itself
It can change open orders parameters, due to possible stepping strategy
Other Features: