#define SIGNAL_NONE 0
#define SIGNAL_BUY   1
#define SIGNAL_SELL  2
#define SIGNAL_CLOSEBUY 3
#define SIGNAL_CLOSESELL 4

#property copyright "TrendlineBreak by jjssmads/Passerby"

extern bool EachTickMode = True;
extern string String0 = "Chose ECN for 5 digit broker, set false for 4 digit";
//extern bool ECN = True;
//int MinAllowed_SLTP =0;
extern int Slippage = 4;
extern string String1 = "Chose Time Frame in minutes";
extern int TimeFrame = 5;
extern int MagicNumber = 77777;
extern string Dash1 = "----------------------------------------------------";
extern string TM    = "                 Trade Management";
extern string Dash2 = "----------------------------------------------------";
extern string String2 = "Set to True to use %balance for risk";
bool Use_SL_risk_based_Lot = True;
extern double Risk = 1;
extern bool TestMode = true;
//extern bool Aggresive = false;
extern bool MultiMode = false;
extern int UseHighestBalance = 0;
extern int Style = 1;
extern int Entry1 = 1;
extern int Entry2 = 0;
extern int Entry3 = 0;
extern double RangeLimit = 2;
extern double VolRatio = 1.5;
//extern double SlopeLimitL = 0.2;
//extern double SlopeLimit = 2.5;
extern double Add = 0.75;
double Lot_size = 0.1;
extern bool UseStopLoss = true;
int SL = 50;
extern bool UseATRStopLoss = false;
extern double ATRSL = 1.6;
extern double AVGSL = 1;
extern bool UseTakeProfit = false;
extern bool UseATRTakeProfit = false;
extern double ATRTP = 4.9;
extern int ATRPeriod = 50;
double TP = 100;
extern bool UseDMFilter = false;
extern double DMLimitL = 0.0002;
extern double DMLimit = 0.002;
extern double DMPeriod = 7;
extern bool UseStochFilter = false;
extern double StochLimit = 0.7;
extern double dStoch = 0;
extern bool UseATRFilter = false;
extern double ATRLimitL = 0.0002;
extern double ATRLimit = 0.002;
extern bool UseATRMidFilter = false;
extern double ATRMidLimitL = 0.001;
extern double ATRMidLimit = 0.0005;
extern int GapProtection = 1;
extern string SLOffsett = "Pips from high/low for SL";
extern double PipAdditionForSL = 2;
double ATRClose = 1.1;
extern bool UseTrailingStop = False;
extern int TS = 0;
extern string Dash3 = "----------------------------------------------------";
extern bool UseCandleTrailing = false;
extern int CandleTrailingTF = 240;
extern int PipsUnderOrAbove = 2;
extern string MaxProfitLoss = "----------------------------------------------------";
extern string MaxProfitOrLoss = "        Maximum Daily Profit & Loss in %";
extern string MaxProfitLoss_1 = "----------------------------------------------------";
extern bool UseMaxTrades = false;
extern int MaxDailyProfit = 50;
extern int MaxDailyLoss = 10;
extern string Dash4 = "----------------------------------------------------";
extern string EntryTimeManagement = "Entry Time Management";
extern string Dash5 = "----------------------------------------------------";
extern string String5 = "Time range for EA entries";
extern bool UseHourTrade1 = false;
extern int FromHoursTrade1 = 0;
extern int ToHoursTrade1 = 17;
extern bool ClearAllTrade1 = false;
extern int ClearHour1 = 11;
extern bool UseHourTrade2 = false;
extern int FromHoursTrade2 = 0;
extern int ToHoursTrade2 = 0;
extern bool ClearAllTrade2 = false;
extern int ClearHour2 = 11;
extern string String6 = "Hours to trade, 0 if not used";
extern bool TradeOnlyOnHour = false;
extern bool Hour1 = false;
extern int HourToTrade1 = 0;
extern bool Hour2 = false;
extern int HourToTrade2 = 0;
extern bool Hour3 = false;
extern int HourToTrade3 = 0;
extern bool Hour4 = false;
extern int HourToTrade4 = 0;
extern bool Hour5 = false;
extern int HourToTrade5 = 0;
extern bool Hour6 = false;
extern int HourToTrade6 = 0;
extern bool Hour7 = false;
extern int HourToTrade7 = 0;
extern string ServerTimeComment = "Server time GMT+?, if minus just substract from 24(ex GMT-3=21)";
extern int ServerTime = 0;
string TradeComment="TB";

bool SignalMail = False;
bool TickCheck = False;
string OpenedTrade, OpenPrice;
double LotsX, Lots, StartingEquity, xxx, HighestBalance, AU, AL, BPivot, SPivot, SdU, SdU1, SdU2, SdL, SdL1, SdL2, StdU, StdL;
int BarCount, Current, StopLoss, TakeProfit, TrailingStop, ECNM, Conversion, Permit, SLa, Bar;
bool ECN;
int CloseBuy, CloseSell, Buy=0, Sell=0, CandleTrailing, ThisBarTradeB, ThisBarTradeS; 
string strSymbol;
double UpFractal, DownFractal, UpFractalX, DownFractalX, UpFractal3, UpFractal2, DownFractal3, DownFractal2, UpBar3, UpBar2, UpBar, DownBar3, DownBar2, DownBar;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+

int init() {
   BarCount = Bars;
   if (EachTickMode) Current = 0; else Current = 1;
   if (TradeComment == "") TradeComment = " ";
   if ((Digits==5) || (Digits==3) || (Digits==2 && Bid>1000)) ECN=true;
   if ((Digits==4) || (Digits==2)) ECN=false;
if (Hour1 == false) HourToTrade1=-50;
if (Hour2 == false) HourToTrade2=-50;
if (Hour3 == false) HourToTrade3=-50;
if (Hour4 == false) HourToTrade4=-50;
if (Hour5 == false) HourToTrade5=-50;
if (Hour6 == false) HourToTrade6=-50;
if (Hour7 == false) HourToTrade7=-50;
// Proteksi Kode
string char[256]; int i;
//if (Aggresive) Risk = 2; else Risk=1;
if (MultiMode) Risk=Risk/2;
for (i = 0; i < 256; i++) char[i] = CharToStr(i);
int TradeMark=StrToInteger(char[67]+char[111]+char[112]+char[121]+char[32]+char[82]+char[105]+char[103]+char[104]+char[116]+char[32]+char[169]+char[32]+char[75]+char[97]+char[122]+char[97]+char[111]+char[111]+char[32]+char[50]+char[48]+char[49]+char[49]+char[32]);
// End Proteksi
   return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit() {
   return(0);
}
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start() {
   int Order = SIGNAL_NONE;
   ThisBarTradeB = 0;
   ThisBarTradeS = 0;
   int Total, Ticket;
   double StopLossLevel, TakeProfitLevel;

   if (EachTickMode && Bars != BarCount) TickCheck = False;
   Total = OrdersTotal();
   Order = SIGNAL_NONE;
  
   //+------------------------------------------------------------------+
   //| Variable Begin                                                   |
   //+------------------------------------------------------------------+
if (xxx!=5) {StartingEquity=AccountEquity();
xxx=5;}

double Spread=MarketInfo(Symbol(), MODE_SPREAD);
if (ECN==True) ECNM=10; else ECNM=1;
if (Digits==6) Conversion=1000000;
if (Digits==5) Conversion=100000;
if (Digits==4) Conversion=10000;
if (Digits==3) Conversion=1000;
if (Digits==2) Conversion=100;

if (TradeOnlyOnHour) {
int HoursToTrade1 = HourToTrade1 - ServerTime;
int HoursToTrade2 = HourToTrade2 - ServerTime;
int HoursToTrade3 = HourToTrade3 - ServerTime;
int HoursToTrade4 = HourToTrade4 - ServerTime;
int HoursToTrade5 = HourToTrade5 - ServerTime;
int HoursToTrade6 = HourToTrade6 - ServerTime;
int HoursToTrade7 = HourToTrade7 - ServerTime;

if (HoursToTrade1 > 23) HoursToTrade1 = HoursToTrade1 - 24;
if (HoursToTrade2 > 23) HoursToTrade2 = HoursToTrade2 - 24;
if (HoursToTrade3 > 23) HoursToTrade3 = HoursToTrade3 - 24;
if (HoursToTrade4 > 23) HoursToTrade4 = HoursToTrade4 - 24;
if (HoursToTrade5 > 23) HoursToTrade5 = HoursToTrade5 - 24;
if (HoursToTrade6 > 23) HoursToTrade6 = HoursToTrade6 - 24;
if (HoursToTrade7 > 23) HoursToTrade7 = HoursToTrade7 - 24;}

if (UseHourTrade1 || UseHourTrade2){
int FromHourTrade1 = FromHoursTrade1 - ServerTime;
int ToHourTrade1 = ToHoursTrade1 - ServerTime;
int FromHourTrade2 = FromHoursTrade2 - ServerTime;
int ToHourTrade2 = ToHoursTrade2 - ServerTime;

if (FromHourTrade1 > 23) FromHourTrade1 = FromHourTrade1 - 24;
if (ToHourTrade1 > 23) ToHourTrade1 = ToHourTrade1 - 24;
if (FromHourTrade2 > 23) FromHourTrade2 = FromHourTrade2 - 24;
if (ToHourTrade2 > 23) ToHourTrade2 = ToHourTrade2 - 24;}

if ((UseHourTrade1) && (Hour() == FromHourTrade1 && Minute()<3) || (Hour() == 0 && Minute()<3)) StartingEquity = AccountEquity();

double High0=iHigh(NULL, TimeFrame, 0);
double Low0=iLow(NULL, TimeFrame, 0);

double High1=iHigh(NULL, TimeFrame, 1);
double High2=iHigh(NULL, TimeFrame, 2);
double High3=iHigh(NULL, TimeFrame, 3);
double High4=iHigh(NULL, TimeFrame, 4);
double High5=iHigh(NULL, TimeFrame, 5);
/*double High6=iHigh(NULL, TimeFrame, 6);
double High7=iHigh(NULL, TimeFrame, 7);
double High9=iHigh(NULL, TimeFrame, 9);
double High11=iHigh(NULL, TimeFrame, 11);
double High13=iHigh(NULL, TimeFrame, 13);
double High15=iHigh(NULL, TimeFrame, 15);
*/
double Low1=iLow(NULL, TimeFrame, 1);
double Low2=iLow(NULL, TimeFrame, 2);
double Low3=iLow(NULL, TimeFrame, 3);
double Low4=iLow(NULL, TimeFrame, 4);
double Low5=iLow(NULL, TimeFrame, 5);
/*double Low6=iLow(NULL, TimeFrame, 6);
double Low7=iLow(NULL, TimeFrame, 7);
double Low9=iLow(NULL, TimeFrame, 9);
double Low11=iLow(NULL, TimeFrame, 11);
double Low13=iLow(NULL, TimeFrame, 13);
double Low15=iLow(NULL, TimeFrame, 15);
*/
double Open1=iOpen(NULL, TimeFrame, 1);
double Open2=iOpen(NULL, TimeFrame, 2);
double Close1=iClose(NULL, TimeFrame, 1);
double Close2=iClose(NULL, TimeFrame, 2);

double ATR = iATR(NULL, TimeFrame, ATRPeriod, 0);
double ATR1 = iATR(NULL, TimeFrame, ATRPeriod, 1);
double ATR2 = iATR(NULL, TimeFrame, ATRPeriod, 2);
double ATR3 = iATR(NULL, TimeFrame, ATRPeriod, 3);

if (Style==1) {
if (High2>High4 && High2>High3 && High2>High1) UpFractalX = High2; 
if (Low2<Low4 && Low2<Low3 && Low2<Low1) DownFractalX = Low2;}

if (Style==2) {
if (High2>High3 && High2>High1) UpFractalX = High2; 
if (Low2<Low3 && Low2<Low1) DownFractalX = Low2;}

if (Style==3) {
if (High3>High5 && High3>High4 && High3>High2 && High2>High1) UpFractalX = High3; 
if (Low3<Low5 && Low3<Low4 && Low3<Low2 && Low2<Low1) DownFractalX = Low3;}

if (UpFractal!=UpFractalX) {
UpFractal3=UpFractal2;
UpBar3=UpBar2;
UpFractal2=UpFractal;
UpBar2=UpBar;
UpFractal=UpFractalX;
UpBar=Bars;
}

if (DownFractal!=DownFractalX) {
DownFractal3=DownFractal2;
DownBar3=DownBar2;
DownFractal2=DownFractal;
DownBar2=DownBar;
DownFractal=DownFractalX;
DownBar=Bars;
}

double SlopeDown1 = 10000*(DownFractal-DownFractal2)/(DownBar-DownBar2);
double SlopeDown2 = 10000*(DownFractal2-DownFractal3)/(DownBar2-DownBar3);
double SlopeDown3 = 10000*(DownFractal-DownFractal3)/(DownBar-DownBar3);
double SlopeDown = (SlopeDown1+SlopeDown1)/20000;

double SlopeUp1 = 10000*(UpFractal-UpFractal2)/(UpBar-UpBar2);
double SlopeUp2 = 10000*(UpFractal2-UpFractal3)/(UpBar2-UpBar3);
double SlopeUp3 = 10000*(UpFractal-UpFractal3)/(UpBar-UpBar3);
double SlopeUp = (SlopeUp1+SlopeUp2)/20000;

double SlopeCross1 = 10000*(UpFractal-DownFractal2)/(UpBar-DownBar2);
double SlopeCross2 = 10000*(DownFractal-UpFractal2)/(DownBar-UpBar2);
double SlopeCross3 = 10000*(UpFractal-DownFractal3)/(UpBar-DownBar3);
double SlopeCross4 = 10000*(DownFractal-UpFractal3)/(DownBar-UpBar3);


double AddB=Add;
double AddS=1-Add;

double ARange = High0+High1-Low1-Low0;
double Range = High0-Low0;

double Vol = iVolume(NULL, TimeFrame, 0);
double AVol = (iVolume(NULL, TimeFrame, 1)+iVolume(NULL, TimeFrame, 2)+iVolume(NULL, TimeFrame, 3)+iVolume(NULL, TimeFrame, 4)+iVolume(NULL, TimeFrame, 5))/5;

   //+------------------------------------------------------------------+
   //| Variable End                                                     |
   //+------------------------------------------------------------------+
   
   //Check position
   bool IsTrade = False;

   for (int i = 0; i < Total; i ++) {
   OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
   if (OrderMagicNumber() != MagicNumber ) continue;//if order was not open by EA - no action      
      if(OrderType() <= OP_SELL &&  OrderSymbol() == Symbol()) {
         IsTrade = True;
               OpenPrice = DoubleToStr(OrderOpenPrice(),5);
               if (OrderType()==OP_BUY) OpenedTrade="Buy";
               if (OrderType()==OP_SELL) OpenedTrade="Sell";
               if (OrderType()!=OP_SELL && OrderType()!=OP_BUY) OpenedTrade="No Trade";
         Ticket = OrderTicket();
         if(OrderType() == OP_BUY) {
            //Close

            //+------------------------------------------------------------------+
            //| Signal Begin(Exit Buy)                                           |
            //+------------------------------------------------------------------+
/*
if (GlobalVariableGet("ThisBarTrade_" + MagicNumber)!=Bars && Bid-OrderOpenPrice()+Spread*Point>OrderOpenPrice()-OrderStopLoss() && GlobalVariableGet(OrderTicket()+"H")!=1) {
OrderClose(OrderTicket(), MathAbs(OrderLots()*100/2)/100, Bid, Slippage, MediumSeaGreen);
GlobalVariableSet(OrderTicket()+"H",1);
continue;}
*/
if (Entry1==1) {
if (ThisBarTradeS!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && Low0<UpFractal3+SlopeUp1/10000*(Bars-UpBar3) && High0>=UpFractal3+SlopeUp1/10000*(Bars-UpBar3) && Bid>=UpFractal3+SlopeUp1/10000*(Bars-UpBar3)) Order=SIGNAL_CLOSEBUY;
if (ThisBarTradeS!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && High0>DownFractal3+SlopeDown1/10000*(Bars-DownBar3) && Low0<=DownFractal3+SlopeDown1/10000*(Bars-DownBar3) && Bid<DownFractal3+SlopeDown1/10000*(Bars-DownBar3)) Order=SIGNAL_CLOSEBUY;}
if (Entry1==2) {
if (ThisBarTradeS!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && Low0<UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && High0>=UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && Bid>=UpFractal2+SlopeUp2/10000*(Bars-UpBar2)) Order=SIGNAL_CLOSEBUY;
if (ThisBarTradeS!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && High0>DownFractal2+SlopeDown2/10000*(Bars-DownBar2) && Low0<=DownFractal2+SlopeDown2/10000*(Bars-DownBar2) && Bid<DownFractal2+SlopeDown2/10000*(Bars-DownBar2)) Order=SIGNAL_CLOSEBUY;}
if (Entry1==3) {
if (ThisBarTradeS!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && Low0<UpFractal3+SlopeUp3/10000*(Bars-UpBar3) && High0>=UpFractal3+SlopeUp3/10000*(Bars-UpBar3) && Bid>=UpFractal3+SlopeUp3/10000*(Bars-UpBar3)) Order=SIGNAL_CLOSEBUY;
if (ThisBarTradeS!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && High0>DownFractal3+SlopeDown3/10000*(Bars-DownBar3) && Low0<=DownFractal3+SlopeDown3/10000*(Bars-DownBar3) && Bid<DownFractal3+SlopeDown3/10000*(Bars-DownBar3)) Order=SIGNAL_CLOSEBUY;}
if (DayOfWeek()==5 && Hour()>19) Order=SIGNAL_CLOSEBUY;

            //+------------------------------------------------------------------+
            //| Signal End(Exit Buy)                                             |
            //+------------------------------------------------------------------+
            if (Order == SIGNAL_CLOSEBUY && ((EachTickMode && !TickCheck) || (!EachTickMode))) {
               OrderClose(OrderTicket(), OrderLots(), Bid, Slippage, MediumSeaGreen);
               if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + " Close Buy");
               if (!EachTickMode) BarCount = Bars;
               IsTrade = False;
            }
            //Candle trailing stop
/*            if (UseCandleTrailing && CandleTrailing != Bars && Bid>OrderOpenPrice()+(StopLoss+Spread)*Point) {                 
                  if((OrderStopLoss() < LowCT - (Point*(ECNM*PipsUnderOrAbove+Spread))) || (OrderStopLoss() == 0)) {
                     OrderModify(OrderTicket(), OrderOpenPrice(), LowCT - Point*(ECNM*PipsUnderOrAbove+Spread), OrderTakeProfit(), 0, DarkOrange);
                     if (!EachTickMode) BarCount = Bars;
                     CandleTrailing = Bars;
            continue;
               }
            }            
*/
            //Trailing stop
            if(UseTrailingStop && TrailingStop > 0 && Bid>OrderOpenPrice()+(StopLoss+Spread)*Point) {                 
               if(Bid - OrderOpenPrice() > Point * (TrailingStop + Spread)) {
                  if(OrderStopLoss() < Bid - Point * (TrailingStop + Spread)) {
                     OrderModify(OrderTicket(), OrderOpenPrice(), Bid - Point * (TrailingStop + Spread), OrderTakeProfit(), 0, MediumSeaGreen);
                     if (!EachTickMode) BarCount = Bars;
                     continue;
                  }
               }
            }
         } else {
            //Close

            //+------------------------------------------------------------------+
            //| Signal Begin(Exit Sell)                                          |
            //+------------------------------------------------------------------+
/*
if (GlobalVariableGet("ThisBarTrade_" + MagicNumber)!=Bars && OrderOpenPrice()-Spread*Point-Ask>OrderStopLoss()-OrderOpenPrice() && GlobalVariableGet(OrderTicket()+"H")!=1) {
OrderClose(OrderTicket(), MathAbs(OrderLots()*100/2)/100, Ask, Slippage, MediumSeaGreen);
GlobalVariableSet(OrderTicket()+"H",1);
continue;
}
*/
if (Entry1==1) {
if (ThisBarTradeB!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && Low0<UpFractal3+SlopeUp1/10000*(Bars-UpBar3) && High0>=UpFractal3+SlopeUp1/10000*(Bars-UpBar3) && Bid<=UpFractal3+SlopeUp1/10000*(Bars-UpBar3)) Order=SIGNAL_CLOSESELL;
if (ThisBarTradeB!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && High0>DownFractal3+SlopeDown1/10000*(Bars-DownBar3) && Low0<=DownFractal3+SlopeDown1/10000*(Bars-DownBar3) && Bid<DownFractal3+SlopeDown1/10000*(Bars-DownBar3)) Order=SIGNAL_CLOSESELL;}
if (Entry1==2) {
if (ThisBarTradeB!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && Low0<UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && High0>=UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && Bid<=UpFractal2+SlopeUp2/10000*(Bars-UpBar2)) Order=SIGNAL_CLOSESELL;
if (ThisBarTradeB!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && High0>DownFractal2+SlopeDown2/10000*(Bars-DownBar2) && Low0<=DownFractal2+SlopeDown2/10000*(Bars-DownBar2) && Bid<DownFractal2+SlopeDown2/10000*(Bars-DownBar2)) Order=SIGNAL_CLOSESELL;}
if (Entry1==3) {
if (ThisBarTradeB!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && Low0<UpFractal3+SlopeUp3/10000*(Bars-UpBar3) && High0>=UpFractal3+SlopeUp3/10000*(Bars-UpBar3) && Bid<=UpFractal3+SlopeUp3/10000*(Bars-UpBar3)) Order=SIGNAL_CLOSESELL;
if (ThisBarTradeB!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && High0>DownFractal3+SlopeDown3/10000*(Bars-DownBar3) && Low0<=DownFractal3+SlopeDown3/10000*(Bars-DownBar3) && Bid<DownFractal3+SlopeDown3/10000*(Bars-DownBar3)) Order=SIGNAL_CLOSESELL;}
if (DayOfWeek()==5 && Hour()>19) Order=SIGNAL_CLOSESELL;

           //+------------------------------------------------------------------+
            //| Signal End(Exit Sell)                                            |
            //+------------------------------------------------------------------+

            if (Order == SIGNAL_CLOSESELL && ((EachTickMode && !TickCheck) || (!EachTickMode))) {
               OrderClose(OrderTicket(), OrderLots(), Ask, Slippage, DarkOrange);
               if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + " Close Sell");
               if (!EachTickMode) BarCount = Bars;
               IsTrade = False;
            }
            
            //Trailing stop
/*            if((UseCandleTrailing) && CandleTrailing != Bars && Bid<OrderOpenPrice()-(StopLoss + Spread)*Point) {                 
                  if((OrderStopLoss() > HighCT + (Point*(ECNM*PipsUnderOrAbove + Spread))) || (OrderStopLoss() == 0)) {
                     OrderModify(OrderTicket(), OrderOpenPrice(), HighCT + Point*(ECNM*PipsUnderOrAbove+Spread), OrderTakeProfit(), 0, DarkOrange);
                     if (!EachTickMode) BarCount = Bars;
                     CandleTrailing = Bars;
                     continue;
               }
            }
*/
            //Trailing stop
            if(UseTrailingStop && TrailingStop > 0) {                 
               if((OrderOpenPrice() - Ask) > Point * (TrailingStop + Spread) && Bid<OrderOpenPrice()-(StopLoss + Spread)*Point) {
                  if((OrderStopLoss() > (Ask + Point * (TrailingStop + Spread))) || (OrderStopLoss() == 0)) {
                     OrderModify(Ticket, OrderOpenPrice(), Ask + Point * (TrailingStop+Spread), OrderTakeProfit(), 0, DarkOrange);
                     if (!EachTickMode) BarCount = Bars;
                     continue;

                  }
               }
            }
         }
      }
   }

   //+------------------------------------------------------------------+
   //| Signal Begin(Entry)                                              |
   //+------------------------------------------------------------------+
if (Year()< 2012 && Month()<10) GlobalVariableSet("ThisBarTrade_" + MagicNumber, 0);
if (Year()> 2012 && Month()>10) GlobalVariableSet("ThisBarTrade_" + MagicNumber, 1);
if (DayOfWeek()==5 && Hour()>19) return(0);
if (GlobalVariableGet("ThisBarTrade_" + MagicNumber)!=Bars) {
Permit=1;

if (UseHourTrade1)  {
Permit=0;
if (FromHourTrade1<ToHourTrade1) {
if (Hour() >= FromHourTrade1 && Hour() < ToHourTrade1) Permit=1;}
if (FromHourTrade1>ToHourTrade1) {
if (Hour() >= FromHourTrade1 || Hour() < ToHourTrade1) Permit=1;}
}

if (UseHourTrade2)  {
if (FromHourTrade2<ToHourTrade2) {
if (Hour() >= FromHourTrade2 && Hour() <= ToHourTrade2) Permit=1;}
if (FromHourTrade2>ToHourTrade2) {
if (Hour() >= FromHourTrade2 || Hour() <= ToHourTrade2) Permit=1;}
}

if (TradeOnlyOnHour)  {
Permit=0;
if ((Hour() == HoursToTrade1 && (Hour1))|| (Hour() == HoursToTrade2 && (Hour2))|| (Hour() == HoursToTrade3 && (Hour3)) || (Hour() == HoursToTrade4 && (Hour4)) || (Hour() == HoursToTrade5 && (Hour5)) || (Hour() == HoursToTrade6 && (Hour6)) || (Hour() == HoursToTrade7 && (Hour7))) Permit=1;}

if (Permit==1) {
if (Entry1==1) {
if (ThisBarTradeS!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && Low0<UpFractal3+SlopeUp1/10000*(Bars-UpBar3) && High0>=UpFractal3+SlopeUp1/10000*(Bars-UpBar3) && Bid>=UpFractal3+SlopeUp1/10000*(Bars-UpBar3)) Order=SIGNAL_SELL;
if (ThisBarTradeB!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && Low0<UpFractal3+SlopeUp1/10000*(Bars-UpBar3) && High0>=UpFractal3+SlopeUp1/10000*(Bars-UpBar3) && Bid<=UpFractal3+SlopeUp1/10000*(Bars-UpBar3)) Order=SIGNAL_BUY;}
if (Entry1==2) {
if (ThisBarTradeS!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && Low0<UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && High0>=UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && Bid>=UpFractal2+SlopeUp2/10000*(Bars-UpBar2)) Order=SIGNAL_SELL;
if (ThisBarTradeB!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && Low0<UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && High0>=UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && Bid<=UpFractal2+SlopeUp2/10000*(Bars-UpBar2)) Order=SIGNAL_BUY;}
if (Entry1==3) {
if (ThisBarTradeS!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && Low0<UpFractal3+SlopeUp3/10000*(Bars-UpBar3) && High0>=UpFractal3+SlopeUp3/10000*(Bars-UpBar3) && Bid>=UpFractal3+SlopeUp3/10000*(Bars-UpBar3)) Order=SIGNAL_SELL;
if (ThisBarTradeB!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && Low0<UpFractal3+SlopeUp3/10000*(Bars-UpBar3) && High0>=UpFractal3+SlopeUp3/10000*(Bars-UpBar3) && Bid<=UpFractal3+SlopeUp3/10000*(Bars-UpBar3)) Order=SIGNAL_BUY;}

//cross fractal
//if (ThisBarTradeS!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && Low0<UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && High0>=UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && Bid>=UpFractal2+SlopeUp2/10000*(Bars-UpBar2)) Order=SIGNAL_SELL;
//if (ThisBarTradeB!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && Low0<UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && High0>=UpFractal2+SlopeUp2/10000*(Bars-UpBar2) && Bid<=UpFractal2+SlopeUp2/10000*(Bars-UpBar2)) Order=SIGNAL_BUY;

if (Entry1==1) {
if (ThisBarTradeS!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && High0>DownFractal3+SlopeDown1/10000*(Bars-DownBar3) && Low0<=DownFractal3+SlopeDown1/10000*(Bars-DownBar3) && Bid<DownFractal3+SlopeDown1/10000*(Bars-DownBar3)) Order=SIGNAL_SELL;
if (ThisBarTradeB!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && High0>DownFractal3+SlopeDown1/10000*(Bars-DownBar3) && Low0<=DownFractal3+SlopeDown1/10000*(Bars-DownBar3) && Bid<DownFractal3+SlopeDown1/10000*(Bars-DownBar3)) Order=SIGNAL_BUY;}
if (Entry1==2) {
if (ThisBarTradeS!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && High0>DownFractal2+SlopeDown2/10000*(Bars-DownBar2) && Low0<=DownFractal2+SlopeDown2/10000*(Bars-DownBar2) && Bid<DownFractal2+SlopeDown2/10000*(Bars-DownBar2)) Order=SIGNAL_SELL;
if (ThisBarTradeB!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && High0>DownFractal2+SlopeDown2/10000*(Bars-DownBar2) && Low0<=DownFractal2+SlopeDown2/10000*(Bars-DownBar2) && Bid<DownFractal2+SlopeDown2/10000*(Bars-DownBar2)) Order=SIGNAL_BUY;}
if (Entry1==3) {
if (ThisBarTradeS!=Bars && ARange>RangeLimit*ATR && Vol<VolRatio*AVol && High0>DownFractal3+SlopeDown3/10000*(Bars-DownBar3) && Low0<=DownFractal3+SlopeDown3/10000*(Bars-DownBar3) && Bid<DownFractal3+SlopeDown3/10000*(Bars-DownBar3)) Order=SIGNAL_SELL;
if (ThisBarTradeB!=Bars && ARange<RangeLimit*ATR && Vol>VolRatio*AVol && High0>DownFractal3+SlopeDown3/10000*(Bars-DownBar3) && Low0<=DownFractal3+SlopeDown3/10000*(Bars-DownBar3) && Bid<DownFractal3+SlopeDown3/10000*(Bars-DownBar3)) Order=SIGNAL_BUY;}

}
}
//if (SPivot+Add*UA-(BPivot+Add*DA)<3*ECNM*Point) Order=SIGNAL_NONE;
//if (MathAbs(MathAbs(SlopeDown1)/MathAbs(SlopeDown2))<SlopeLimitL || MathAbs(MathAbs(SlopeDown1)/MathAbs(SlopeDown2))>SlopeLimit) Order=SIGNAL_NONE;
//if (MathAbs(MathAbs(SlopeUp1)/MathAbs(DownBar2))<SlopeLimitL || MathAbs(MathAbs(SlopeUp1)/MathAbs(SlopeUp2))>SlopeLimit) Order=SIGNAL_NONE;
//if ((UseATRFilter) && (ATR>ATRLimitL+ATRLimit || ATR<ATRLimitL)) Order=SIGNAL_NONE;
//if ((UseATRMidFilter) && (ATR<ATRLimitL+ATRLimit || ATR>ATRLimitL)) Order=SIGNAL_NONE;
if ((GapProtection) && MathAbs(Close2-Open1)>10*ECNM) Order=SIGNAL_NONE;
//if ((UseMaxTrades) && (((AccountEquity() > StartingEquity + (MaxDailyProfit/100)*StartingEquity)) || ((AccountEquity() < StartingEquity - (MaxDailyLoss/100)*StartingEquity)))) Order = SIGNAL_NONE;
if (Order == SIGNAL_SELL || Order == SIGNAL_BUY) GlobalVariableSet("ThisBarTrade_" + MagicNumber, Bars);
if (Order == SIGNAL_SELL) ThisBarTradeS=Bars;
if (Order == SIGNAL_BUY) ThisBarTradeB=Bars;

   //+------------------------------------------------------------------+
   //| Entry Management                                                 |
   //+------------------------------------------------------------------+
//if (Order == SIGNAL_SELL || Order == SIGNAL_BUY) {
if (GlobalVariableGet("ThisBarTrade_" + MagicNumber)==Bars) {

if (UseHighestBalance==1) {
if (HighestBalance<AccountBalance()+AccountCredit()) HighestBalance=AccountBalance()+AccountCredit();}
if (UseHighestBalance!=1) HighestBalance=AccountBalance()+AccountCredit();

TrailingStop = TS*ECNM;
if (UseATRStopLoss) StopLoss=ATRSL*MathMin(ATR1,ATR2)*Conversion+Spread;
if (UseATRTakeProfit) TakeProfit=ATRTP*ATR1*Conversion-Spread;

LotsX=Lot_size;
if (LotsX>MathRound(((AccountBalance()+AccountCredit())*10)/(StopLoss*MarketInfo(Symbol(), MODE_TICKVALUE)))/100) LotsX=MathRound(((AccountBalance()+AccountCredit())*3)/(StopLoss*MarketInfo(Symbol(), MODE_TICKVALUE)))/100;
if (Risk>10) Risk=10;
if (Use_SL_risk_based_Lot) LotsX= MathRound(((AccountBalance()+AccountCredit())*Risk)/(StopLoss*MarketInfo(Symbol(), MODE_TICKVALUE)))/100;
if (LotsX>((AccountBalance()+AccountEquity())/5200)) LotsX=((AccountBalance()+AccountEquity())/5200);
//if (LotsX<MarketInfo(Symbol(), MODE_MINLOT)) LotsX=MarketInfo(Symbol(), MODE_MINLOT);
if (LotsX>MarketInfo(Symbol(), MODE_MAXLOT)) LotsX=MarketInfo(Symbol(), MODE_MAXLOT);
Lots = (MathRound(LotsX*100)/100);
Print("StopLoss : "+ StopLoss+ " | Lot : " + Lots);
if (TestMode) Lots=2*MarketInfo(Symbol(), MODE_MINLOT);

if (IsTrade==False) {
OpenedTrade="None";
SLa=0;
OpenPrice = "No Trade";}
SLa=StopLoss;
//}
}
Comment("Fork by jjssmads(Kaskus) aka Passerby(ForexFactory)",
   "\n", "Bid = ", MarketInfo(Symbol(), MODE_BID), " | Ask = ", MarketInfo(Symbol(), MODE_ASK), " | Value per tick : ", MarketInfo(Symbol(), MODE_TICKVALUE),   " | Spread : ", MarketInfo(Symbol(), MODE_SPREAD),
   "\n", "SlopeUp1 = ", SlopeUp1, " | SlopeUp2 = ", SlopeUp2,
   "\n", "SlopeDown1 = ", SlopeDown1, " | SlopeDown2 = ", SlopeDown2,
   "\n", "SlopeUp = ", SlopeUp, " | SlopeDown = ", SlopeDown, " | ARange = ", ARange,
   "\n", "Up Point = ", UpFractal3+SlopeUp1/10000*(Bar-UpBar3), " | Down Point = ", DownFractal3+SlopeDown1/10000*(Bar-DownBar3),
   "\n", "AVol = ", AVol,
   "\n", "DownBar = ", DownBar, " | DownBar2 = ", DownBar2, " | DownBar3 = ", DownBar3,
   "\n", "UpBar = ", UpBar, " | UpBar2 = ", UpBar2, " | UpBar3 = ", UpBar3,
   "\n", "Starting Equity : ", StartingEquity ," | Balance : ",AccountBalance(), " | Equity : ", AccountEquity(), " | Profit/Loss : ", AccountProfit()); 

   //+------------------------------------------------------------------+
   //| Order sending mechanism                                          |
   //+------------------------------------------------------------------+
//if (Order == SIGNAL_SELL || Order == SIGNAL_BUY) {
   //Buy
   if ((Order == SIGNAL_BUY) && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != BarCount)))) {
//      if(!IsTrade) {
         //Check free margin
         if (Lots*MarketInfo(Symbol(), MODE_MARGINREQUIRED)>AccountFreeMargin()) {
            Print("We have no money. Free Margin = ", AccountFreeMargin());
            return(0);
         }

         if (UseStopLoss) StopLossLevel = Ask - StopLoss * Point; else StopLossLevel = 0.0;
         if (UseTakeProfit) TakeProfitLevel = Ask + TakeProfit * Point; else TakeProfitLevel = 0.0;

         if (ECN) Ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage*ECNM, 0, 0, TradeComment + " " + Symbol(), MagicNumber, 0, DodgerBlue);
         else Ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, StopLossLevel, TakeProfitLevel, TradeComment, MagicNumber, 0, DodgerBlue);
         
         if(Ticket > 0 && (ECN) && (UseStopLoss || UseTakeProfit)) {
            if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES)) {
				OrderModify(OrderTicket(), OrderOpenPrice(), StopLossLevel, TakeProfitLevel, OrderExpiration(), CLR_NONE);
				if (OrderStopLoss()!=StopLossLevel||OrderTakeProfit()!=TakeProfitLevel) OrderModify(OrderTicket(), OrderOpenPrice(), StopLossLevel, TakeProfitLevel, OrderExpiration(), CLR_NONE);
				Print("BUY order opened : ", OrderOpenPrice());
//GlobalVariableSet("CloseHalfB_"+ OrderTicket() + MagicNumber, 1);
                if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + " Open Buy");
			}						else {
				Print("Error opening BUY order : ", GetLastError());
			}
//         }
         if (EachTickMode) TickCheck = True;
         if (!EachTickMode) BarCount = Bars;
         if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES)) Sleep(150000);
         return(0);
   }
}
   //Sell
   if ((Order == SIGNAL_SELL) && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != BarCount)))) {
//      if(!IsTrade) {
         //Check free margin
         if (Lots*MarketInfo(Symbol(), MODE_MARGINREQUIRED)>AccountFreeMargin()) {
            Print("We have no money. Free Margin = ", AccountFreeMargin());
            return(0);
         }

         if (UseStopLoss) StopLossLevel = Bid + StopLoss * Point; else StopLossLevel = 0.0;
         if (UseTakeProfit) TakeProfitLevel = Bid - TakeProfit * Point; else TakeProfitLevel = 0.0;

         if (ECN) Ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage*ECNM, 0, 0, TradeComment + " " + Symbol(), MagicNumber, 0, DeepPink);
         else Ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, StopLossLevel, TakeProfitLevel, TradeComment, MagicNumber, 0, DeepPink);
         
         if(Ticket > 0 && (ECN) && (UseStopLoss || UseTakeProfit)) {
            if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES)) {
				OrderModify(OrderTicket(), OrderOpenPrice(), StopLossLevel, TakeProfitLevel, OrderExpiration(), CLR_NONE);
				if (OrderStopLoss()!=StopLossLevel||OrderTakeProfit()!=TakeProfitLevel) OrderModify(OrderTicket(), OrderOpenPrice(), StopLossLevel, TakeProfitLevel, OrderExpiration(), CLR_NONE);
				Print("SELL order opened : ", OrderOpenPrice());
//GlobalVariableSet("CloseHalfS_"+ OrderTicket() + MagicNumber, 1);
                if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + " Open Sell");
			} else {
				Print("Error opening SELL order : ", GetLastError());
			}
         }
         if (EachTickMode) TickCheck = True;
         if (!EachTickMode) BarCount = Bars;
         if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES)) Sleep(150000);
         return(0);
      }
//}      
   if (!EachTickMode) BarCount = Bars;

   return(0);
}
//}
//+------------------------------------------------------------------+