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

#property copyright "Ronald Raygun"
#property link      "http://www.RonaldRaygunForex.com/Support/"


#import "wininet.dll"

#define INTERNET_FLAG_PRAGMA_NOCACHE    0x00000100 // Forces the request to be resolved by the origin server, even if a cached copy exists on the proxy.
#define INTERNET_FLAG_NO_CACHE_WRITE    0x04000000 // Does not add the returned entity to the cache. 
#define INTERNET_FLAG_RELOAD            0x80000000 // Forces a download of the requested file, object, or directory listing from the origin server, not from the cache.
#define INTERNET_FLAG_NO_COOKIES        0x00080000 // Does not automatically add cookie headers to requests, and does not automatically add returned cookies to the cookie database. This flag can be used by 


int InternetOpenA(
	string 	sAgent,
	int		lAccessType,
	string 	sProxyName="",
	string 	sProxyBypass="",
	int 	lFlags=0
);

int InternetOpenUrlA(
	int 	hInternetSession,
	string 	sUrl, 
	string 	sHeaders="",
	int 	lHeadersLength=0,
	int 	lFlags=0,
	int 	lContext=0 
);

int InternetReadFile(
	int 	hFile,
	string 	sBuffer,
	int 	lNumBytesToRead,
	int& 	lNumberOfBytesRead[]
);

int InternetCloseHandle(
	int 	hInet
);
#import


extern string Remark1 = "== Main Settings ==";
extern int MagicNumber = 0;
extern bool SignalsOnly = False;
extern bool Alerts = False;
extern bool SignalMail = False;
extern bool PlaySounds = False;
extern bool ECNBroker = False;
extern bool TickDatabase = True;
extern bool EachTickMode = True;
extern double Lots = 0;
extern bool MoneyManagement = False;
extern int Risk = 0;
extern int Slippage = 5;
extern double EntryMultiplier = 0.0;
extern int EntryBuffer = 0;
extern  bool UseStopLoss = True;
extern int StopLoss = 100;
extern double SLMultiplier = 0.0;
extern int SLMultiplierBuffer = 0;
extern bool UseTakeProfit = False;
extern int TakeProfit = 60;
extern double TPMultiplier = 0.0;
extern int TPMultiplierBuffer = 0;
extern bool UseTrailingStop = False;
extern int TrailingStop = 30;
extern bool MoveStopOnce = False;
extern int MoveStopWhenPrice = 50;
extern int MoveStopTo = 1;
extern string Remark2 = "";
extern string Remark3 = "== Define Doji ==";
extern int MinimumRange = 0;
extern int MaximumRange = -1;
extern int MinimumBody = 0;
extern int MaximumBody = 0;
extern int DojiCount = 2;


string SymbolUsed;
int TickCount = 0;
int RecordDay = -1;
string UserName = "";
bool ShowDiagnostics = False;

int Internet_Open_Type_Direct = 1;


   string URL;
   int URLHandle = 0;                                                              
   int SessionHandle = 0;
   int MaxTries = 0;

   
   string FinalStr ;
   int bytesreturned[1];
   int readresult;

   int GMTBar;
   string GMTTime;
   string BrokerTime;
   int GMTShift;

   datetime CurGMTTime;
   datetime CurBrokerTime;
   datetime CurrentGMTTime;



 
   string TempStr ="000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
#define  maxreadlen 200



int TradeBar;
int TradesThisBar;

int OpenBarCount;
int CloseBarCount;

int LongMailSignalBarCount;
int ShortMailSignalBarCount;

int LongAlertSignalBarCount;
int ShortAlertSignalBarCount;

int LongSoundSignalBarCount;
int ShortSoundSignalBarCount;

string BrokerType = "4-Digit Broker";
double BrokerMultiplier = 1;

int Current;
bool TickCheck = False;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init() {
   OpenBarCount = Bars;
   CloseBarCount = Bars;
   
   LongMailSignalBarCount = Bars;
   ShortMailSignalBarCount = Bars;
   
   LongAlertSignalBarCount = Bars;
   ShortAlertSignalBarCount = Bars;
   
   LongAlertSignalBarCount = Bars;
   ShortAlertSignalBarCount = Bars;
   
   if(TickDatabase && !IsDllsAllowed())
      {
      Alert("Please enable DLLs");
      return(0);
      }
      
   
   if(Digits == 3 || Digits == 5)
      {
      BrokerType = "5-Digit Broker";
      BrokerMultiplier = 10;
      }


   if (EachTickMode) Current = 0; else Current = 1;

   return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit() {

   for(int OT = ObjectsTotal(); OT >= 0; OT--)
      {
      if(StringFind(ObjectName(OT), WindowExpertName(), 0) == 0) ObjectDelete(ObjectName(OT));
      }

   return(0);
}
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start() 


{
   int Order = SIGNAL_NONE;
   int Total, Ticket;
   double StopLossLevel, TakeProfitLevel;
   double PotentialStopLoss;
   double BEven; 
   double TrailStop;



   if (EachTickMode && Bars != CloseBarCount) TickCheck = False;
   Total = OrdersTotal();
   Order = SIGNAL_NONE;

//Limit Trades Per Bar
if(TradeBar != Bars)
   {
   TradeBar = Bars;
   TradesThisBar = 0;
   }


//Money Management sequence
 if (MoneyManagement)
   {
      if (Risk<1 || Risk>100)
      {
         Comment("Invalid Risk Value.");
         return(0);
      }
      else
      {
         Lots=MathFloor((AccountFreeMargin()*AccountLeverage()*Risk*Point*BrokerMultiplier*100)/(Ask*MarketInfo(Symbol(),MODE_LOTSIZE)*MarketInfo(Symbol(),MODE_MINLOT)))*MarketInfo(Symbol(),MODE_MINLOT);
      }
   }

   //+------------------------------------------------------------------+
   //| Variable Begin                                                   |
   //+------------------------------------------------------------------+
   
   //Find the last set of dojis in bar history
   int TestShift = Current + 1;
   string DojiFound = "Found";
   int FoundCount = 0;
   int NotFoundCount = 0;
   int TotalCount = 0;
   double DojiHigh;
   double DojiLow;
   double DojiShift = 0;
   
   while(DojiFound == "Not Found" || TestShift < Bars)
      {
      DojiHigh = 0.0;
      DojiLow = 0.0;
      FoundCount = 0;
      NotFoundCount = 0;
      TotalCount = 0;
      
      for(int DT = 0; DT < DojiCount; DT++)
         {
         //Print("Here I am: ", DT);
         //Print("DT: ", DT);
         if(!CheckDoji(TestShift + DT)) 
            {
            NotFoundCount++;
            }
            else
            {
            FoundCount++;
            }
         TotalCount++;   
         }
      
      if(FoundCount == TotalCount && FoundCount != 0 && TotalCount != 0)
         {
         DojiFound = "Found";
         DojiHigh = iHigh(NULL, 0, iHighest(NULL, 0, MODE_HIGH, DojiCount, TestShift));
         DojiLow = iLow(NULL, 0, iLowest(NULL, 0, MODE_LOW, DojiCount, TestShift));
         DojiShift = TestShift;
         break;
         }
      TestShift++;   
      //Print("Checking Another Bar: ", TestShift, " ", TimeToStr(iTime(NULL, 0, TestShift), TIME_DATE|TIME_SECONDS));
      }
   
   double Range = DojiHigh - DojiLow;
   
   double Buffer = (Range * EntryMultiplier) + (EntryBuffer * Point);
   
   double LongEntry = DojiHigh + Buffer;
   double ShortEntry = DojiLow - Buffer;
   //Print("DojiFound: ", DojiFound);
   
   //Paint Doji Lines
   ObjectDelete(WindowExpertName()+" DojiStart");
   ObjectCreate(WindowExpertName()+" DojiStart", OBJ_TREND, 0, iTime(NULL, 0, DojiShift + DojiCount - 1), DojiHigh, iTime(NULL, 0, DojiShift + DojiCount - 1), DojiLow);
   ObjectSet(WindowExpertName()+" DojiStart", OBJPROP_COLOR, Yellow);
   ObjectSet(WindowExpertName()+" DojiStart", OBJPROP_STYLE, STYLE_DASH);
   ObjectSet(WindowExpertName()+" DojiStart", OBJPROP_BACK, True);
   ObjectSet(WindowExpertName()+" DojiStart", OBJPROP_RAY, False);
   
   ObjectDelete(WindowExpertName()+" DojiStop");
   ObjectCreate(WindowExpertName()+" DojiStop", OBJ_TREND, 0, iTime(NULL, 0, DojiShift), DojiHigh, iTime(NULL, 0, DojiShift), DojiLow);
   ObjectSet(WindowExpertName()+" DojiStop", OBJPROP_COLOR, Yellow);
   ObjectSet(WindowExpertName()+" DojiStop", OBJPROP_STYLE, STYLE_DASH);
   ObjectSet(WindowExpertName()+" DojiStop", OBJPROP_BACK, True);
   ObjectSet(WindowExpertName()+" DojiStop", OBJPROP_RAY, False);
   
   ObjectDelete(WindowExpertName()+" DojiHigh");
   ObjectCreate(WindowExpertName()+" DojiHigh", OBJ_TREND, 0, iTime(NULL, 0, DojiShift + DojiCount - 1), DojiHigh, iTime(NULL, 0, DojiShift), DojiHigh);
   ObjectSet(WindowExpertName()+" DojiHigh", OBJPROP_COLOR, Yellow);
   ObjectSet(WindowExpertName()+" DojiHigh", OBJPROP_STYLE, STYLE_DASH);
   ObjectSet(WindowExpertName()+" DojiHigh", OBJPROP_BACK, True);
   ObjectSet(WindowExpertName()+" DojiHigh", OBJPROP_RAY, True);
   
   ObjectDelete(WindowExpertName()+" DojiLow");
   ObjectCreate(WindowExpertName()+" DojiLow", OBJ_TREND, 0, iTime(NULL, 0, DojiShift + DojiCount - 1), DojiLow, iTime(NULL, 0, DojiShift), DojiLow);
   ObjectSet(WindowExpertName()+" DojiLow", OBJPROP_COLOR, Yellow);
   ObjectSet(WindowExpertName()+" DojiLow", OBJPROP_STYLE, STYLE_DASH);
   ObjectSet(WindowExpertName()+" DojiLow", OBJPROP_BACK, True);
   ObjectSet(WindowExpertName()+" DojiLow", OBJPROP_RAY, True);
   
   ObjectDelete(WindowExpertName()+" LongEntry");
   ObjectCreate(WindowExpertName()+" LongEntry", OBJ_TREND, 0, iTime(NULL, 0, DojiShift + DojiCount - 1), LongEntry, iTime(NULL, 0, DojiShift), LongEntry);
   ObjectSet(WindowExpertName()+" LongEntry", OBJPROP_COLOR, Lime);
   ObjectSet(WindowExpertName()+" LongEntry", OBJPROP_STYLE, STYLE_DASH);
   ObjectSet(WindowExpertName()+" LongEntry", OBJPROP_BACK, True);
   ObjectSet(WindowExpertName()+" LongEntry", OBJPROP_RAY, True);
   
   ObjectDelete(WindowExpertName()+" ShortEntry");
   ObjectCreate(WindowExpertName()+" ShortEntry", OBJ_TREND, 0, iTime(NULL, 0, DojiShift + DojiCount - 1), ShortEntry, iTime(NULL, 0, DojiShift), ShortEntry);
   ObjectSet(WindowExpertName()+" ShortEntry", OBJPROP_COLOR, Red);
   ObjectSet(WindowExpertName()+" ShortEntry", OBJPROP_STYLE, STYLE_DASH);
   ObjectSet(WindowExpertName()+" ShortEntry", OBJPROP_BACK, True);
   ObjectSet(WindowExpertName()+" ShortEntry", OBJPROP_RAY, True);
   
   static double PreviousTick;
   static double CurrentTick;
   
   PreviousTick = CurrentTick;
   CurrentTick = iClose(NULL, 0, Current + 0);
   
   string TradeTrigger = "None";
   if(CurrentTick >= LongEntry && PreviousTick < LongEntry && iOpen(NULL, 0, Current + 0) < LongEntry) TradeTrigger = "Open Long";
   if(CurrentTick <= ShortEntry && PreviousTick > ShortEntry && iOpen(NULL, 0, Current + 0) > ShortEntry) TradeTrigger = "Open Short";
   
   
   //+------------------------------------------------------------------+
   //| Variable End                                                     |
   //+------------------------------------------------------------------+

   //Check position
   bool IsTrade = False;

   for (int i = 0; i < Total; i ++) {
      OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
      if(OrderType() <= OP_SELL &&  OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber) {
         IsTrade = True;
         if(OrderType() == OP_BUY) {
         
            
            //Close

            //+------------------------------------------------------------------+
            //| Signal Begin(Exit Buy)                                           |
            //+------------------------------------------------------------------+


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

            if (Order == SIGNAL_CLOSEBUY && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != CloseBarCount)))) {
               OrderClose(OrderTicket(), OrderLots(), Bid, Slippage, MediumSeaGreen);
               if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + " Close Buy");
               if (!EachTickMode) CloseBarCount = Bars;
               IsTrade = False;
               continue;
            }
            
            PotentialStopLoss = OrderStopLoss();
            BEven = BreakEvenValue(MoveStopOnce, OrderTicket(), MoveStopTo, MoveStopWhenPrice);
            TrailStop = TrailingStopValue(UseTrailingStop, OrderTicket(), TrailingStop);
            
            if(BEven > PotentialStopLoss && BEven != 0) PotentialStopLoss = BEven;
            if(TrailStop > PotentialStopLoss && TrailStop != 0) PotentialStopLoss = TrailStop;
             
            if(PotentialStopLoss != OrderStopLoss()) OrderModify(OrderTicket(),OrderOpenPrice(), PotentialStopLoss, OrderTakeProfit(), 0, MediumSeaGreen); 
         
         } else {
        
            //Close

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



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

            if (Order == SIGNAL_CLOSESELL && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != CloseBarCount)))) {
               OrderClose(OrderTicket(), OrderLots(), Ask, Slippage, DarkOrange);
               if (SignalMail) SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + " Close Sell");
               if (!EachTickMode) CloseBarCount = Bars;
               IsTrade = False;
               continue;
            }
            
            PotentialStopLoss = OrderStopLoss();
            BEven = BreakEvenValue(MoveStopOnce, OrderTicket(), MoveStopTo, MoveStopWhenPrice);
            TrailStop = TrailingStopValue(UseTrailingStop, OrderTicket(), TrailingStop);
            
            if((BEven < PotentialStopLoss && BEven != 0) || (PotentialStopLoss == 0)) PotentialStopLoss = BEven;
            if((TrailStop < PotentialStopLoss && TrailStop != 0) || (PotentialStopLoss == 0)) PotentialStopLoss = TrailStop;
            
            if(PotentialStopLoss != OrderStopLoss() || OrderStopLoss() == 0) OrderModify(OrderTicket(),OrderOpenPrice(), PotentialStopLoss, OrderTakeProfit(), 0, DarkOrange);
              
         }
      }
   }

   //+------------------------------------------------------------------+
   //| Signal Begin(Entry)                                              |
   //+------------------------------------------------------------------+

if(TradeTrigger == "Open Long") Order = SIGNAL_BUY;
if(TradeTrigger == "Open Short") Order = SIGNAL_SELL;

   //+------------------------------------------------------------------+
   //| Signal End                                                       |
   //+------------------------------------------------------------------+

   //Buy
   if (Order == SIGNAL_BUY && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != OpenBarCount)))) {
      if(SignalsOnly) {
         if (SignalMail && LongMailSignalBarCount != Bars) 
            {
            SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + "Buy Signal");
            LongMailSignalBarCount = Bars;
            }
         if (Alerts && LongAlertSignalBarCount != Bars)
            {
            Alert("[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + "Buy Signal");
            LongAlertSignalBarCount = Bars;
            }
         if (PlaySounds && LongSoundSignalBarCount != Bars) 
            {
            PlaySound("alert.wav");
            LongSoundSignalBarCount = Bars;
            }
      }
      
      if(!IsTrade && !SignalsOnly && TradesThisBar < 1) {
         //Check free margin
         if (AccountFreeMarginCheck(Symbol(), OP_BUY, Lots) < 0) {
            Print("We have no money. Free Margin = ", AccountFreeMargin());
            return(0);
         }

         StopLossLevel = 0.0;
         TakeProfitLevel = 0.0;
         if (UseStopLoss) 
            {
            if(StopLoss != 0 && Ask - StopLoss * Point > StopLossLevel) StopLossLevel = Ask - StopLoss * Point; 
            if(SLMultiplier != 0.0 && Ask - (Range * SLMultiplier) - (SLMultiplierBuffer * Point) > StopLossLevel) StopLossLevel = Ask - (Range * SLMultiplier) - (SLMultiplierBuffer * Point);
            }
         if(!UseStopLoss) StopLossLevel = 0.0;
            
         if (UseTakeProfit) 
            {
            if(TakeProfit != 0 && Ask + TakeProfit * Point >= TakeProfitLevel) TakeProfitLevel = Ask + TakeProfit * Point; 
            if(TPMultiplier != 0.0 && Ask + (Range * TPMultiplier) + (TPMultiplierBuffer * Point) > TakeProfitLevel) TakeProfitLevel = Ask + (Range * TPMultiplier) + (TPMultiplierBuffer * Point);
            }
         
         if (!UseTakeProfit) TakeProfitLevel = 0.0;
         Ticket = SendOrder(Symbol(), OP_BUY, Lots, Ask, Slippage, StopLossLevel, TakeProfitLevel, "Buy(#" + MagicNumber + ")", MagicNumber, 0, DodgerBlue);
            if(Ticket > 0) {
               if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES)) {
				  Print("BUY order opened : ", OrderOpenPrice());
                  if (SignalMail && LongMailSignalBarCount != Bars) 
                     {
                     SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + "Buy Signal");
                     LongMailSignalBarCount = Bars;
                     }
                  if (Alerts && LongAlertSignalBarCount != Bars)
                     {
                     Alert("[" + Symbol() + "] " + DoubleToStr(Ask, Digits) + "Buy Signal");
                     LongAlertSignalBarCount = Bars;
                     }
                  if (PlaySounds && LongSoundSignalBarCount != Bars) 
                     {
                     PlaySound("alert.wav");
                     LongSoundSignalBarCount = Bars;
                     }
                  TradesThisBar++;
			   } else {
   				Print("Error opening BUY order : ", GetLastError());
			   }
            }
            
         if (EachTickMode) TickCheck = True;
         if (!EachTickMode) OpenBarCount = Bars;
         return(0);
      }
   }

   //Sell
   if (Order == SIGNAL_SELL && ((EachTickMode && !TickCheck) || (!EachTickMode && (Bars != OpenBarCount)))) {
      if(SignalsOnly) {
          if (SignalMail && ShortMailSignalBarCount != Bars) 
            {
            SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + "Sell Signal");
            ShortMailSignalBarCount = Bars;
            }
          if (Alerts && ShortAlertSignalBarCount != Bars)
            {
            Alert("[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + "Sell Signal");
            ShortAlertSignalBarCount = Bars;
            }
          if (PlaySounds && ShortSoundSignalBarCount != Bars) 
            {
            PlaySound("alert.wav");
            ShortSoundSignalBarCount = Bars;
            }
         }
      if(!IsTrade && !SignalsOnly && TradesThisBar < 1) {
         //Check free margin
         if (AccountFreeMarginCheck(Symbol(), OP_SELL, Lots) < 0) {
            Print("We have no money. Free Margin = ", AccountFreeMargin());
            return(0);
         }

         StopLossLevel = 0.0;
         TakeProfitLevel = 0.0;
         if (UseStopLoss) 
            {
            if(StopLoss != 0 && ((Bid + StopLoss * Point <= StopLossLevel) || StopLossLevel == 0.0)) StopLossLevel = Bid + StopLoss * Point; 
            if(SLMultiplier != 0 && (((Bid + (SLMultiplier * Range) + (SLMultiplierBuffer * Point)) <= StopLossLevel) || StopLossLevel == 0.0)) StopLossLevel = Bid + (SLMultiplier * Range) + (SLMultiplierBuffer * Point); 
            }
         
         if (!UseStopLoss) StopLossLevel = 0.0;
         
         
         if (UseTakeProfit) 
            {
            if(TakeProfit != 0 && ((Bid - TakeProfit * Point <= TakeProfitLevel) || TakeProfitLevel == 0)) TakeProfitLevel = Bid - TakeProfit * Point; 
            if(TPMultiplier != 0.0 && (((Bid - (Range * TPMultiplier) + (TPMultiplierBuffer * Point)) < TakeProfitLevel) || TakeProfitLevel == 0)) TakeProfitLevel = Bid - (Range * TPMultiplier) + (TPMultiplierBuffer * Point);
            }
         if (!UseTakeProfit) TakeProfitLevel = 0.0;
         
         if(ECNBroker) Ticket = OrderModify(OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, "Sell(#" + MagicNumber + ")", MagicNumber, 0, DeepPink), OrderOpenPrice(), StopLossLevel, TakeProfitLevel, 0, CLR_NONE);
         if(!ECNBroker) Ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, StopLossLevel, TakeProfitLevel, "Sell(#" + MagicNumber + ")", MagicNumber, 0, DeepPink);
         if(Ticket > 0) {
            if (OrderSelect(Ticket, SELECT_BY_TICKET, MODE_TRADES)) {
				Print("SELL order opened : ", OrderOpenPrice());
                if (SignalMail && ShortMailSignalBarCount != Bars) 
                  {
                  SendMail("[Signal Alert]", "[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + "Sell Signal");
                  ShortMailSignalBarCount = Bars;
                  }
               if (Alerts && ShortAlertSignalBarCount != Bars)
                  {
                  Alert("[" + Symbol() + "] " + DoubleToStr(Bid, Digits) + "Sell Signal");
                  ShortAlertSignalBarCount = Bars;
                  }
               if (PlaySounds && ShortSoundSignalBarCount != Bars) 
                  {
                  PlaySound("alert.wav");
                  ShortSoundSignalBarCount = Bars;
                  }
                TradesThisBar++;
			} else {
				Print("Error opening SELL order : ", GetLastError());
			}
         }
         if (EachTickMode) TickCheck = True;
         if (!EachTickMode) OpenBarCount = Bars;
         return(0);
      }
   }

   if (!EachTickMode) CloseBarCount = Bars;
   if(TickDatabase && !IsTesting() && !IsOptimization() && IsDllsAllowed()) TickData();
   return(0);
}

void TickData ()
   {
   UserName = WindowExpertName();
   SymbolUsed = StringSubstr(Symbol(), 0, 6);
   if(GMTBar != Bars)
      {
      GMTTime = LoadURL("http://www.ronaldraygunforex.com/TickDB/Time.php");
      GMTBar = Bars;
      GMTShift = TimeCurrent() - StrToTime(GMTTime);
      } 

   if(TimeDayOfYear(TimeCurrent()) != RecordDay)
      {
      URL = LoadURL("http://www.ronaldraygunforex.com/TickDB/UserLog.php?UN="+UserName+"&P="+SymbolUsed+"&TL="+TickCount);
   
      if(StringFind(URL, "1 record added") != -1)
         {
         TickCount = 0;
         RecordDay = TimeDayOfYear(TimeCurrent());
         }
      }
   
   CurGMTTime = StrToTime(GMTTime);
  
   CurrentGMTTime = TimeCurrent() - GMTShift;
   //CurrentGMTTime = CurGMTTime + TimeCurrent - CurBrokerTime
   
   URL = LoadURL("http://www.ronaldraygunforex.com/TickDB/Load.php?TN="+SymbolUsed+"&GMT="+CurrentGMTTime+"&TT="+TimeCurrent()+"&B="+DoubleToStr(NormalizeDouble(Bid,Digits),Digits)+"&A="+DoubleToStr(NormalizeDouble(Ask,Digits),Digits)+"&BN="+AccountCompany()+"&UN="+UserName);
  
   if(StringFind(URL, "1 record added") != -1)
      {
      TickCount++;
      }
      else
      {
      Print(SymbolUsed+" Error: "+URL);
      LoadURL("http://www.ronaldraygunforex.com/TickDB/Error.php?UN="+UserName+"&Error="+URL);
      }
   }
   
   
string LoadURL (string URLLoad)
   {
   int Position = StringFind(URLLoad, " ");
   
   while (Position != -1)
      {
      string InitialURLA = StringTrimLeft(StringTrimRight(StringSubstr(URLLoad, 0, StringFind(URLLoad, " ", 0))));
      string InitialURLB = StringTrimLeft(StringTrimRight(StringSubstr(URLLoad, StringFind(URLLoad, " ", 0))));
      URLLoad = InitialURLA+"%20"+InitialURLB;
      Position = StringFind(URLLoad, " ");
      if(ShowDiagnostics) Print("Processing URL: "+URLLoad);
      }
      
   MaxTries =0; 
   URLHandle=0;
   while (MaxTries < 3 && URLHandle == 0)
      {
      if(SessionHandle != 0)
         {
         URLHandle = InternetOpenUrlA(SessionHandle, URLLoad, NULL, 0, INTERNET_FLAG_NO_CACHE_WRITE |
                                                                   INTERNET_FLAG_PRAGMA_NOCACHE |
                                                                   INTERNET_FLAG_RELOAD |
                                                                   INTERNET_FLAG_NO_COOKIES, 0);
         }
      if(URLHandle == 0)
         {
         InternetCloseHandle(SessionHandle);
         if(ShowDiagnostics) Print("Closing Handle");
         SessionHandle = InternetOpenA("mymt4InetSession", Internet_Open_Type_Direct, NULL, NULL, 0);
         }
         
      MaxTries++;   
      }
      
   if(ShowDiagnostics) Print("URL Handle: ", URLHandle);   
      
   //Parse file 
    
   FinalStr = "";
   bytesreturned[0]=1;
   
   while (bytesreturned[0] > 0)
      {

    
     
      // get next chunk
      InternetReadFile(URLHandle, TempStr , maxreadlen, bytesreturned);
      if(ShowDiagnostics) Print("bytes returned: "+bytesreturned[0]);
      
      

      if(bytesreturned[0] > 0)
      FinalStr = FinalStr + StringSubstr(TempStr, 0, bytesreturned[0]);
            
      }

      if(ShowDiagnostics) Print("FinalStr: "+FinalStr);

   // now we are done with the URL we can close its handle 
   InternetCloseHandle(URLHandle);
   
   return(FinalStr);    
   }

bool CheckDoji(int Shift)
   {
   int Range = (iHigh(NULL, 0, Shift) - iLow(NULL, 0, Shift)) / Point;
   int Body = (MathAbs(iOpen(NULL, 0, Shift) - iClose(NULL, 0, Shift)) / Point);
   //Print("Range: ", Range, " Body: ", Body, " Shift: ", Shift);
   if((MinimumRange >= 0 && Range >= MinimumRange) || (MinimumRange < 0)) 
      {
      if((MaximumRange >= 0 && Range <= MaximumRange) || (MaximumRange < 0))
         {
         if((MinimumBody >= 0 && Body >= MinimumBody) || (MinimumBody < 0))
            {
            if((MaximumBody >= 0 && Body <= MaximumBody) || (MaximumBody < 0))
               {
               return(True);
               }
               else
               {
               return(False);
               }
            }
            else
            {
            return(False);
            }
         }
         else
         {
         return(False);
         }
      }
      else
      {
      return(False);
      }
   }
   
int SendOrder(string OpenSymbol, int OpenCommand, double OpenVolume, double OpenPrice, int OpenSlippage, double OpenStopLoss, double OpenTakeProfit, string OpenComment, int OpenMagicNumber, datetime OpenExpiration, color OpenColor)
   {
   int FTicket = -2;
   
   if(ECNBroker) 
      {
      FTicket = OrderSend(OpenSymbol, OpenCommand, OpenVolume, OpenPrice, OpenSlippage, 0.0, 0.0, OpenComment, OpenMagicNumber, OpenExpiration, OpenColor);
      if(OrderModify(FTicket, OrderOpenPrice(), OpenStopLoss, OpenTakeProfit, OrderExpiration(), CLR_NONE)) 
         {
         return(FTicket);
         }
         else
         {
         return(-1);
         }
      }
   if(!ECNBroker) 
      {
      FTicket = OrderSend(OpenSymbol, OpenCommand, OpenVolume, OpenPrice, OpenSlippage, OpenStopLoss, OpenTakeProfit, OpenComment, OpenMagicNumber, OpenExpiration, OpenColor);
      return(FTicket);
      }       
   } 
   
double BreakEvenValue (bool Decision, int OrderTicketNum, int MoveStopTo, int MoveStopwhenPrice)
   {
   //Select the appropriate order ticket
   OrderSelect(OrderTicketNum, SELECT_BY_TICKET, MODE_TRADES);
   
   //If the Order is a BUY order...
   if(OrderType() == OP_BUY)
      {
      //Check if the user wants to use the MoveStopOnce function and did it correctly
      if(Decision && MoveStopWhenPrice > 0) 
         {
         //Check if the trade is above the required profit threshold
         if(Bid - OrderOpenPrice() >= Point * MoveStopWhenPrice) 
            {
            //Return the value of the stoploss
            return(OrderOpenPrice() + Point * MoveStopTo);
            }
         }
      }
   
   //If the Order is a SELL order...   
   if(OrderType() == OP_SELL)
      {
      //Check if the user wants to use the MoveStopOnce function and did it correctly
      if(Decision && MoveStopWhenPrice > 0) 
         {
         //Check if the trade is above the required profit threshold
         if(OrderOpenPrice() - Ask >= Point * MoveStopWhenPrice) 
            {
            //Return the value of the stoploss
            return(OrderOpenPrice() - Point * MoveStopTo);
            }
         }
      }   
      
   if(OrderType() != OP_BUY || OrderType() != OP_SELL) return(0);
   }
   
double TrailingStopValue (bool Decision, int OrderTicketNum, int FTrailingStop)
   {
   //Select the appropriate order ticket
   OrderSelect(OrderTicketNum, SELECT_BY_TICKET, MODE_TRADES);
   
   //If the Order is a BUY order...
   if(OrderType() == OP_BUY)
      {
      //Check if the user wants to use teh Trailingstop function and did it correctly
      if(Decision && FTrailingStop > 0) 
         {                 
         //Check to see that the profit threshold is met
         if(Bid - OrderOpenPrice() > Point * FTrailingStop) 
            {
            //Return the value of the potential stoploss
            return(Bid - Point * FTrailingStop);
            }
         }
      }
   //If the Order is a SELL order...
   if(OrderType() == OP_SELL)
      {
      //Check if the user wants to use teh Trailingstop function and did it correctly
      if(Decision && FTrailingStop > 0) 
         {                 
         //Check to see that the profit threshold is met
         if((OrderOpenPrice() - Ask) > (Point * FTrailingStop)) 
            {
            //Return the value of the potential stoploss
            return(Ask + Point * FTrailingStop);
            }
         }
      }     
   //If the trade is not the right order type, give a stoploss of 0   
   if(OrderType() != OP_BUY || OrderType() != OP_SELL) return(0);
   }