//+------------------------------------------------------------------+
//|                                                PriceActionEA.mq4 |
//|                                    Copyright © 2011, Robert Hill |
//|                                       http://www.mrpipforex.com/ |
//|                                                                  |
//| Based on idea from Miguel at Yahoo MTE&I group                   | 
//| Enter long when price above EMA (x) and short below.             |
//| Enter after current candle passes H/L of previous candle.        |
//| Make close at end of candle T/F (on/off).                        |
//| Add trailing stop (adjustable).                                  |
//| V1.2                                                             |
//|  Added MA Angle filter                                           |
//| V1.3                                                             |
//|  Added SaveGlobals with check for IsTesting                      |
//+------------------------------------------------------------------+
#include <stdlib.mqh>
#include <stderror.mqh> 

// Add defines for signals
#define LONG 1
#define SHORT -1
#define FLAT 0

#define SMA 0
#define EMA 1
#define SMMA 2
#define LWMA 3
#define LSMA 4

// MoneyManagement Account Usage
#define EQUITY 2
#define MARGIN 3

extern bool    UseOptimizedSettings = False;
extern int     MagicNumber = 1234567;
extern int     SignalCandle = 1;
extern string  f = "Filters";
extern string  f0 = "Enter 1 to use";
extern int     UseEMA_Filter = 1;
extern int     EMA_Period = 50;
extern int     UseHighLowBreakFilter = 1;
extern int     UseMA_AngleFilter = 1;
extern int     mMA_Angle_Period = 34;
int MA_Angle_Period;

extern string  m = "--Moving Average Types--";
extern string  m0 = " 0 = SMA";
extern string  m1 = " 1 = EMA";
extern string  m2 = " 2 = SMMA";
extern string  m3 = " 3 = LWMA";
extern string  m4 = " 4 = LSMA";
extern int     mMA_Type = 1;
int MA_Type;
int MA_AppliedPrice = 0;
extern double  mAngle_Threshold=0.25;   // What size angle to trigger a trade
int Angle_Threshold;
extern int     mPrevMAShift=2;
int PrevMAShift;
extern int     CurMAShift=1;

extern int     ExitOnCandleClose = 1;

extern string  UserComment = "PriceAction_EA";

//+---------------------------------------------------+
//|Money Management                                   |
//+---------------------------------------------------+
extern string  mm = "--- Money Management ---";
extern double  Lots=0.1;
extern bool    UseMoneyManagement = false;
extern double  TradeRiskPercent = 1;  // Change to whatever percent of equity you wish to risk.
extern string  mm0 = "MM Method";
extern string  mm1 = " 1. AccountBalance";
extern string  mm2 = " 2. Free Margin";
extern int     mmMethod = 1;

extern int     TakeProfit = 0;
extern int     StopLoss=0;
extern int     Slippage = 3;
extern string  ts0 = "---TrailingStopLoss---";
extern string  ts1 = " 1. None";
extern string  ts2 = " 2. Standard at input";
extern string  ts3 = " 3. Trail immediately";
extern string  ts4 = " 4. Breakeven + Lockin";
extern int     TrailingStopMethod = 2;
extern string  ts12 = "Settings for Type 2";
extern double  TrailingStop = 20;
extern string  ts14 = "Settings for Type 4";
extern double  BreakEven = 15;
extern int     LockInPips = 1;        // Profit Lock in pips


extern string  sm0="--Trading Hours Filter--";
extern string  sm1=" Times are GMT when UseDST=false";
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 = 300;      // Stop trading after time
extern string  sm5="Trade Europe - Enter 0 for false, 1 for true";
extern int    TradeEuropeanMarket = 1;
extern int     EurStart = 900;       // Start trades after time
extern int     EurStop = 1100;      // Stop trading after time
extern string  sm6="Trade NY - Enter 0 for false, 1 for true";
extern int    TradeNewYorkMarket = 0;
extern int     NYStart = 1300;       // Start trades after time
extern int     NYStop = 1500;      // Stop trading after time


string EA_ID = "PAO_";
double myPoint;
double mLots;
bool YesStop;
double TPprice, STprice;
string      gTPpriceName;
string      gSTpriceName;
double mFactor;

bool SaveGlobals;

int init()
{
   int ShiftDif;
    myPoint = SetPoint();
    if (IsTesting())
       SaveGlobals = false;
    else
    {
        SaveGlobals = true;
        GetGlobalVars();
    }

    MA_Angle_Period = mMA_Angle_Period;
    MA_Type = mMA_Type;
    Angle_Threshold = mAngle_Threshold;  
    PrevMAShift = mPrevMAShift;
    if (UseOptimizedSettings) GetOptInputs();

   if(CurMAShift >= PrevMAShift)
   {
      Print("Error: CurMAShift >= PrevMAShift");
      PrevMAShift = 6;
      CurMAShift = 0;      
   }  

// Multiply by 10000 or 100 so that the fAngle is not too small
// for the indicator Window.
   mFactor = 10000.0;
   if (StringFind(Symbol(), "JPY", 0) >= 0) mFactor = 100.0;


   
   ShiftDif = PrevMAShift-CurMAShift;
   mFactor /= ShiftDif; 
     
   return(0);
}

int deinit()
{
 return(0);
}

void GetOptInputs()
{
    string sym = Symbol();
     
    MA_Angle_Period = mMA_Angle_Period;
    MA_Type = mMA_Type;
    Angle_Threshold = mAngle_Threshold;  
    PrevMAShift = mPrevMAShift;
 
   if (StringFind(sym, "EURJPY") >= 0)
   {
    MA_Angle_Period = 155;
    MA_Type = 1;
    Angle_Threshold = 1.25;  
    PrevMAShift = 2;
   }
   
   if (StringFind(sym, "GBPJPY") >= 0)
   {
    MA_Angle_Period = 30;
    MA_Type = 1;
    Angle_Threshold = 2.75;  
    PrevMAShift = 3;
   }

   if (StringFind(sym, "EURUSD") >= 0)
   {
    MA_Angle_Period = 95;
    MA_Type = 1;
    Angle_Threshold = 0.25;  
    PrevMAShift = 2;
   }
   
   if (StringFind(sym, "USDJPY") >= 0)
   {
    MA_Angle_Period = 65;
    MA_Type = 1;
    Angle_Threshold = 0.5;  
    PrevMAShift = 2;
   }
   

   if (StringFind(sym, "AUDUSD") >= 0)
   {
    MA_Angle_Period = 115;
    MA_Type = 1;
    Angle_Threshold = 0.75;  
    PrevMAShift = 2;
   }
   
   if (StringFind(sym, "GBPUSD") >= 0)
   {
    MA_Angle_Period = 150;
    MA_Type = 1;
    Angle_Threshold = 0.25;  
    PrevMAShift = 3;
   }

   if (StringFind(sym, "USDCAD") >= 0)
   {
    MA_Angle_Period = 40;
    MA_Type = 1;
    Angle_Threshold = 0.5;  
    PrevMAShift = 3;
   }

   if (StringFind(sym, "EURAUD") >= 0)
   {
    MA_Angle_Period = 140;
    MA_Type = 1;
    Angle_Threshold = 0.5;  
    PrevMAShift = 2;
   }
   
   if (StringFind(sym, "GBPCHF") >= 0)
   {
    MA_Angle_Period = 165;
    MA_Type = 1;
    Angle_Threshold = 1.25;  
    PrevMAShift = 3;
   }

   if (StringFind(sym, "USDCHF") >= 0)
   {
    MA_Angle_Period = 180;
    MA_Type = 1;
    Angle_Threshold = 0.25;  
    PrevMAShift = 3;
   }

   if (StringFind(sym, "EURCHF") >= 0)
   {
    MA_Angle_Period = 175;
    MA_Type = 1;
    Angle_Threshold = 0.5;  
    PrevMAShift = 2;
   }

   if (StringFind(sym, "EURGBP") >= 0)
   {
    MA_Angle_Period = 70;
    MA_Type = 1;
    Angle_Threshold = 0.25;  
    PrevMAShift = 2;
   }
}


//+------------------------------------------------------------------+
//| GetSignal                                                        |
//|                                                                  |
//| BUY Signal                                                       |
//| Rule 1 : Prior candle open is less than close (up candle)        |
//| Rule 2 : Bid > High of prior candle                              |
//| Rule 3 : Bid above EMA                                           |
//| Rule 4 : MA Angle above positive threshold                       |
//| SELL Signal                                                      |
//| Rule 1 : Prior candle open is greater than close (down candle)   |
//| Rule 2 : Bid < Low of prior candle                               |
//| Rule 3 : Bid below EMA                                           |
//| Rule 4 : MA Angle below negative threshold                       |
//+------------------------------------------------------------------+
int GetEntrySignal()
{
   double MA_Angle;
   
   
//---- Buy conditions
       if (Open[SignalCandle] < Close[SignalCandle])
       {
// Check HighLow Rule
         if (UseHighLowBreakFilter == 1)
         {
            if (Bid <= High[SignalCandle]) return(FLAT); // failure
         }
// Check EMA rule
         if (UseEMA_Filter == 1)
         {
           if (Bid <= iMA(NULL, 0, EMA_Period, 0, MODE_EMA, PRICE_CLOSE, SignalCandle)) return(FLAT); // failure
         }
// Check angle rule         
         if (UseMA_AngleFilter == 1)
         {
            MA_Angle = GetMA_Angle(SignalCandle);
            if (MA_Angle < Angle_Threshold) return(FLAT); // failure;
         }
         
         return(LONG);
       }
//---- Sell conditions
       if (Open[SignalCandle] > Close[SignalCandle])
       {
// Check HighLow Rule
         if (UseHighLowBreakFilter == 1)
         {
            if (Bid >= Low[SignalCandle]) return(FLAT); // failure
         }
// Check EMA rule
         if (UseEMA_Filter == 1)
         {
           if (Bid >= iMA(NULL, 0, EMA_Period, 0, MODE_EMA, PRICE_CLOSE, SignalCandle)) return(FLAT); // failure
         }
// Check angle rule         
         if (UseMA_AngleFilter == 1)
         {
            MA_Angle = GetMA_Angle(SignalCandle);
            if (MA_Angle > -Angle_Threshold) return(FLAT); // failure;
         }
         return(SHORT);
       }
  
   return (FLAT);
   
}

//+------------------------------------------------------------------+
//| LSMA with PriceMode                                              |
//| LSMA - Least Squares Moving Average function calculation               |
//| LSMA_In_Color Indicator plots the end of the linear regression line    |
//| PrMode  0=close, 1=open, 2=high, 3=low, 4=median(high+low)/2,    |
//| 5=typical(high+low+close)/3, 6=weighted(high+low+close+close)/4  |
//+------------------------------------------------------------------+

double fLSMA(int LSMAPeriod, int LSMAPrice,int shift)
{
   double wt;
   
   double ma1=iMA(NULL,0,LSMAPeriod,0,MODE_SMA ,LSMAPrice,shift);
   double ma2=iMA(NULL,0,LSMAPeriod,0,MODE_LWMA,LSMAPrice,shift);
   wt = MathFloor((3.0*ma2-2.0*ma1)/myPoint)*myPoint;
   return(wt);
}  


double GetMA_Angle(int shift)
{
   double fAngle;
   double MACurrent, MAPrevious;

   switch (MA_Type)
   {
     case LSMA : MACurrent=fLSMA(MA_Angle_Period,MA_AppliedPrice,CurMAShift + shift);
                 MAPrevious=fLSMA(MA_Angle_Period,MA_AppliedPrice,PrevMAShift + shift);
                 break;
       default : MACurrent=iMA(NULL,0,MA_Angle_Period,0,MA_Type,MA_AppliedPrice,CurMAShift + shift);
                 MAPrevious=iMA(NULL,0,MA_Angle_Period,0,MA_Type,MA_AppliedPrice,PrevMAShift + shift);
   }

    fAngle = mFactor * (MACurrent - MAPrevious)/2.0;

    return(fAngle);
}

//+------------------------------------------------------------------+
//| Close at close of candle                                         |
//+------------------------------------------------------------------+
bool CheckExitCondition(int cmd, int ticket, double ol)
{
   int Signal;
   
   if (!NewBar()) return(false);
   if (ExitOnCandleClose == 0) return(false);
   
//----
   if(cmd==OP_BUY)
   {
        CloseOrder(ticket,ol,OP_BUY);
        return(true);
   }
  if(cmd==OP_SELL)
   {
        CloseOrder(ticket,ol,OP_SELL);
        return(true);
   }
   return(false);
//----
}


//+------------------------------------------------------------------+
//| Start function                                                   |
//+------------------------------------------------------------------+
void start()
  {
    int NumOrders = 0, Position, signal; 
    
    RefreshRates();
    
   if (IsTradeAllowed()==false ) return(0);
   
   
//+------------------------------------------------------------------+
//| Check for Open Position                                          |
//+------------------------------------------------------------------+
// Only allow 1 trade per Symbol

// Handle bug where there are 2 orders on pair
   NumOrders = CalculateCurrentOrders();
   
   if (NumOrders > 0)
   {
      HandleOpenPositions();
      return(0);
   }
   
   YesStop = CheckTradeFilters();
   if (YesStop == false)
   {
     signal=GetEntrySignal();
     if (signal != FLAT)
     {
       mLots = GetLots(StopLoss);
       if(AccountFreeMargin()<(1000*mLots))
       {
         Comment("We have no money. Free Margin = " + AccountFreeMargin());
         return(0);  
       }

	    if(signal == LONG)
	    {
         OpenTrade(OP_BUY, mLots);
         return;
       }
	    if(signal == SHORT)
	    {
          OpenTrade(OP_SELL, mLots);
       }
	  
	  }
	}
   return(0);
//----
  }


int OpenTrade(int signal, double mLots)
{  
  int err, ticket;
  
   RefreshRates();
   
   if (signal==OP_BUY) 
   {
      ticket= OrderSend(Symbol(),OP_BUY,mLots,Ask,Slippage,0,0,UserComment,MagicNumber,0,Green);
      if (ticket > 0)
      {
         TPprice = 0;
         STprice = 0;
         if (StopLoss != 0 || TakeProfit != 0)
	      {
            OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES);
            if (TakeProfit > 0)
            {
              TPprice=TakeLong(OrderOpenPrice(), TakeProfit);
		        TPprice = ValidTakeProfit(OP_BUY,Ask, TPprice);
		      }
            if (StopLoss > 0)
            {
              STprice=StopLong(OrderOpenPrice(), 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); 
            }
            if (SaveGlobals)
            {
              SaveTPprice(TPprice);
              SaveSTprice(STprice);
            }
		      OrderModify(ticket, OrderOpenPrice(), STprice, TPprice, 0, LightGreen);
		   }
         
      }
   } 
   else if (signal==OP_SELL) 
   {
      ticket=OrderSend(Symbol(),OP_SELL,mLots,Bid,Slippage,0,0,UserComment,MagicNumber,0,Red);
      if (ticket > 0)
      {
         TPprice = 0;
         STprice = 0;
         if (StopLoss != 0 || TakeProfit != 0)
	      {
            OrderSelect(ticket, SELECT_BY_TICKET, MODE_TRADES);
            if (TakeProfit > 0)
            {
              TPprice=TakeShort(OrderOpenPrice(),TakeProfit);
		        TPprice = ValidTakeProfit(OP_SELL,Bid, TPprice);
		      }
            if (StopLoss > 0)
            {
              STprice=StopShort(OrderOpenPrice() ,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); 
            }
            if (SaveGlobals)
            {
              SaveTPprice(TPprice);
              SaveSTprice(STprice);
            }
		      OrderModify(ticket, OrderOpenPrice(), STprice, TPprice, 0, LightGreen);
		   }
       }
   }
      
   if(ticket<0)
   {
     err = GetLastError();
     Print("OrderSend failed with error(" + err + ") " + ErrorDescription(err) );
   }
   return(ticket);
}

//+------------------------------------------------------------------+
//| Handle Open Positions                                            |
//| Check if any open positions need to be closed or modified        |
//+------------------------------------------------------------------+
void HandleOpenPositions()
{
   bool Done;
   int ticket, OrderTy;
   double OrderLTS, OrderOP;
   double OrderTP, OrderSL; 

   int cnt;
   
   for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
   {
      OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
      if ( OrderSymbol() != Symbol()) continue;
      if ( OrderMagicNumber() != MagicNumber)  continue;
      
      ticket = OrderTicket();
      OrderTy = OrderType();
      OrderLTS = OrderLots();
      OrderOP = NormalizeDouble(OrderOpenPrice(), Digits);
      OrderTP = OrderTakeProfit();
      OrderSL = NormalizeDouble(OrderStopLoss(), Digits);
      

// Check for TakeProfit Exits

      Done = false;
      Done = CheckTPClose(OrderTy, ticket, OrderLTS, TPprice);
      if (Done == true) return;

       
// Check for internal StopLoss

      Done = false;
      Done = CheckSLClose(OrderTy, ticket, OrderLTS, STprice);
      if (Done == true) return;
      
// Check for exit on signal

      Done = false;
      Done = CheckExitCondition(OrderTy, ticket, OrderLTS);
      if (Done == true) return;
      
// If we get to here the trade is still Open
// check for trailing stop
      if (TrailingStopMethod > 0)
      {
         HandleTrailingStop(OrderTy,ticket,OrderOP,OrderSL,OrderTP);
      }
   }
}
       
bool CheckSLClose(int cmd, int ticket, double ol, double IntSTprice)
{
   if (cmd == OP_BUY)
   {
         
       if(Bid <= IntSTprice)
       {
          CloseOrder(ticket,ol,OP_BUY);
          return (true);
       }
     return(false);
   }
    
   if (cmd == OP_SELL)
   {
         
     if (IntSTprice > 0.1)
     {
       if(Ask >= IntSTprice)
       {
         CloseOrder(ticket,ol,OP_SELL);
         return(true);
       }
     }
   }
   return(false);
}


bool CheckTPClose(int cmd, int ticket, double ol, double IntTPprice )
{

   if (cmd == OP_BUY)
   {
        
      if(Bid >= IntTPprice && IntTPprice > 0.1)
      {
           CloseOrder(ticket,ol,OP_BUY);
           return(true);
      }
       return(false);
   }
   
   if (cmd == OP_SELL)
   {
      if(Ask <= IntTPprice)
      {
           CloseOrder(ticket,ol,OP_SELL);
           return(true);
      }
   }
    return(false);
}    

//+------------------------------------------------------------------+
//| HandleTrailingStop                                               |
//| Type 1 is do not trail                                           |
//| Type 2 waits for price to move the amount of the trailStop       |
//|        before moving stop loss then moves like type 4            |
//| Type 3 moves the stoploss without delay.                         |
//+------------------------------------------------------------------+
void HandleTrailingStop(int cmd, int ticket, double op, double os, double tp)
{
   switch (TrailingStopMethod)
   {
     case 2 : Delayed_TrailingStop (cmd, ticket, op, os, tp);
              break;
     case 3 : Immediate_TrailingStop (cmd, ticket, op, os, tp);
              break;
     case 4 : BreakEven_TrailingStop (cmd, ticket, op, os, tp);
              break;
	}
}

//+------------------------------------------------------------------+
//|                                       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;
   double myOrderStop;

   myOrderStop = NormalizeDouble(os, Digits);
   digits = MarketInfo(Symbol( ), MODE_DIGITS);
   
   if (type==OP_BUY)
   {
     pBid = MarketInfo(Symbol(), MODE_BID);
     pt = StopLoss * myPoint;
     if(pBid-myOrderStop > pt)
     {
       BuyStop = pBid - pt;
       if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
		 BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);   
        if (myOrderStop < BuyStop)
        {
           STprice = BuyStop;
            if (SaveGlobals) SaveSTprice(BuyStop);
		     OrderModify(ticket, op, BuyStop, tp, 0, LightGreen);
        }
		 return;
	  }
   }
   if (type==OP_SELL)
   {
     pAsk = MarketInfo(Symbol(), MODE_ASK);
     pt = StopLoss * myPoint;
     if(myOrderStop - pAsk > pt)
     {
       SellStop = pAsk + pt;
       if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
       SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);  
       if (myOrderStop > SellStop)
       {
          STprice = SellStop;
          if (SaveGlobals) SaveSTprice(SellStop);
		    OrderModify(ticket, op, SellStop, tp, 0, 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;
   double myOrderStop, myOpenPrice;

   myOrderStop = NormalizeDouble(os, Digits);
   myOpenPrice = NormalizeDouble(op, Digits);
   
   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-myOpenPrice > pt && myOrderStop < BuyStop)
     {
     	  STprice = BuyStop;  
        if (SaveGlobals) SaveSTprice(BuyStop);
		  OrderModify(ticket, op, BuyStop, tp, 0, 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 (myOpenPrice - pAsk > pt && myOrderStop > SellStop)
      {
     	   STprice = SellStop;  
         if (SaveGlobals) SaveSTprice (SellStop);
		   OrderModify(ticket, op, SellStop, tp, 0, 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, pt, BuyStop, SellStop;
   double myOrderStop, myOpenPrice;

   myOrderStop = NormalizeDouble(os, Digits);
   myOpenPrice = NormalizeDouble(op, Digits);

   digits = MarketInfo(Symbol(), MODE_DIGITS);
   pt = myPoint * BreakEven;
   
   if (type==OP_BUY)
   {
    pBid = MarketInfo(Symbol(), MODE_BID);
    if ( pBid-myOpenPrice > pt ) 
    {
       BuyStop = myOpenPrice + LockInPips * myPoint;
       if (digits > 0) BuyStop = NormalizeDouble( BuyStop, digits);
		 BuyStop = ValidStopLoss(OP_BUY,pBid, BuyStop);   
       if (myOrderStop < BuyStop)
       {
          STprice = BuyStop;
          if (SaveGlobals) SaveSTprice(BuyStop);
		    OrderModify(ticket, op, BuyStop, tp, 0, LightGreen);
       }
		 return;
	 }
  }
  if (type==OP_SELL)
  {
    pAsk = MarketInfo(Symbol(), MODE_ASK);
    if ( myOpenPrice - pAsk > pt ) 
    {
       SellStop = myOpenPrice - LockInPips * myPoint;
       if (digits > 0) SellStop = NormalizeDouble( SellStop, digits);
       SellStop = ValidStopLoss(OP_SELL, pAsk, SellStop);  
       if (myOrderStop > SellStop)
       {
          STprice = SellStop;
          if (SaveGlobals) SaveSTprice(SellStop);
		    OrderModify(ticket, op, SellStop, tp, 0, DarkOrange);
       }
		 return;
    }
  }   

}

int CloseOrder(int ticket,double numLots,int cmd)
{
	bool result;
   int err, digits;
   double myPrice;
   
   if (cmd == OP_BUY) myPrice = MarketInfo(Symbol( ), MODE_BID);
   if (cmd == OP_SELL) myPrice = MarketInfo(Symbol( ), MODE_ASK);
   digits = MarketInfo(Symbol( ), MODE_DIGITS) ;
   if (digits > 0)  myPrice = NormalizeDouble( myPrice, digits);
      
   result = OrderClose(ticket,numLots,myPrice,Slippage,Violet);
   if (result) return(true);
   err = GetLastError();
   Print(" Error closing order : (", err , ") " + ErrorDescription(err));
   return(false);

}


//+------------------------------------------------------------------+
//| Calculate open positions                                         |
//+------------------------------------------------------------------+
int CalculateCurrentOrders()
  {
   int buys=0,sells=0, num = 0;
//----
   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
      if(OrderSymbol()!=Symbol()) continue;
      if (OrderMagicNumber()!=MagicNumber) continue;
        {
         if(OrderType()==OP_BUY)  buys++;
         if(OrderType()==OP_SELL) sells++;
        }
     }
//---- return orders volume
   num = buys + sells;
   return(num);
  }


double SetPoint()
{
   double mPoint;
   
   if (Digits < 4)
      mPoint = 0.01;
   else
      mPoint = 0.0001;
   
   return(mPoint);
}


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));
}

double ValidStopLoss(int type, double price, double SL)
{

   double minstop;
   double newSL;
   
   if (SL < 0.1) return(SL);
   minstop = MarketInfo(Symbol(),MODE_STOPLEVEL);
   if (Digits == 3 || Digits == 5) minstop = minstop / 10;
   newSL = SL;
   if (type == OP_BUY)
   {
		 if((price - SL) < minstop*myPoint) newSL = price - minstop*myPoint;
   }
   if (type == OP_SELL)
   {
       if((SL-price) < minstop*myPoint)  newSL = price + minstop*myPoint;  
   }
   newSL = NormalizeDouble(newSL,Digits);   

   return(newSL);   
}

double ValidTakeProfit(int type, double price, double TP)
{

   double newTP, temp;
   
   temp = MarketInfo(Symbol(), MODE_STOPLEVEL) * myPoint;
   newTP = TP;
   if (type == OP_BUY)
   {
		 if((TP - price) < temp) newTP = price + temp;
   }
   if (type == OP_SELL)
   {
       if((price - TP) < temp)  newTP = price - temp;  
   }
   newTP = NormalizeDouble(newTP,Digits);   

   return(newTP);   
}

//+------------------------------------------------------------------+
//| Get number of lots for this trade                                |
//+------------------------------------------------------------------+
double GetLots(double StopInPips)
{
   int    Decimals = 0;
   double lot, AccountValue;
   double myMaxLot = MarketInfo(Symbol(), MODE_MAXLOT);
   double myMinLot = MarketInfo(Symbol(), MODE_MINLOT);
   
 
   double LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
   double LotSize = MarketInfo(Symbol(), MODE_LOTSIZE);
   double LotTickValue = MarketInfo(Symbol(), MODE_TICKVALUE);

   if(LotStep == 0.01)
      Decimals = 2;
   if(LotStep == 0.1)
      Decimals = 1;
   
  if (UseMoneyManagement == false) return(Lots);
   
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
   if (mmMethod == 1)
      AccountValue = AccountBalance();
   else
      AccountValue = AccountFreeMargin();
      
   lot = ( AccountValue * (TradeRiskPercent/100) )/( LotTickValue * StopInPips * 10.0 );
   
   lot = StrToDouble(DoubleToStr(lot,Decimals));

   if (lot < myMinLot) lot = myMinLot;
   if (lot > myMaxLot) lot = myMaxLot;

   return(lot);
}

bool NewBar()
{
   static datetime dt = 0;
   
   if (Time[0] != dt)
   {
      dt = Time[0];
      return(true);
   }
   return(false);
}

bool CheckTradeFilters()
{
   bool myStop, Expired;
   double CurrentSpread;
   
   myStop = false;
      
   if (myStop ==false)
   {
   if (UseTradingHours == 1)
   {
     myStop = CheckTradingTimes();
   
   }
   }
     
   
   return(myStop);
}

// Return true if time is not in session for trading
bool CheckOutsideSession( int StartHour, int EndHour, int ct)
{
  if(StartHour<=EndHour)
  {
    if(ct < StartHour || ct > EndHour) return(true) ;
  }
  else
  {
    if(ct > EndHour && ct < 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 = CheckOutsideSession(AsianStart, AsianStop, ct);
     }
     if (StopTrading == true)
     {
// Check trading European Market
       if (TradeEuropeanMarket == 1)
       {
         StopTrading = CheckOutsideSession(EurStart, EurStop, ct);
       }
     }
     if (StopTrading == true)
     {
// Check trading New York Market
       if (TradeNewYorkMarket == 1)
       {
         StopTrading = CheckOutsideSession(NYStart, NYStop, ct);
       }
     }
     
     return(StopTrading);
}

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("??");
}

void GetGlobalVars()
{
   NameGlobalVars();
   InitGlobalVars();
   GetGlobalVarValues();
}
  
void GetGlobalVarValues()
{
   double temp;

// Booleans stored as double so convert to boolean
// > 0 true, < 0 false

//    temp = GlobalVariableGet(gFirst_TP_LevelName);
//    if (temp > 0) First_TP_Level = true; else First_TP_Level = false;
    


    TPprice = GlobalVariableGet (gTPpriceName);
    STprice = GlobalVariableGet (gSTpriceName);
    
}

void InitGlobalVars()
{

// check variable before use

  if(!GlobalVariableCheck(gTPpriceName))
    GlobalVariableSet(gTPpriceName,0);
    
    
  if(!GlobalVariableCheck(gSTpriceName))
    GlobalVariableSet(gSTpriceName,0);



}

void NameGlobalVars()
{
   string  prefix;

   prefix = EA_ID + Symbol() +  tf2txt(Period());
   gTPpriceName = prefix + "_TPprice";
   gSTpriceName = prefix + "_STprice";
}


void SaveSTprice (double myVal)
{
    GlobalVariableSet(gSTpriceName,myVal);
}


void SaveTPprice (double myVal)
{
    GlobalVariableSet(gTPpriceName,myVal);
}
//+------------------------------------------------------------------+