Reverse Ea

//+------------------------------------------------------------------+
//| ReverseEA.mq4 |
//| Copyright 2014, tidicofx |
//| tidicofx@yahoo.com |
//| developed for loocoom |
//+------------------------------------------------------------------+
#property copyright "Copyright 2014, tidicofx"
#property link "tidicofx@yahoo.com"
#property version "1.52"
#property strict
//+------------------------------------------------------------------+
#include <stdlib.mqh>
#include <stderror.mqh>
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Input Parameters Definition |
//+------------------------------------------------------------------+
input string hint1 = "===== trade entry settings =====";
input int MaxOrdersPerCandle = 0;
input double InitialLot = 0.01;
input bool IncrementBuy = true;
input double IncrementBuyBy = 0.01;
input int IncrementBuyMaxLevels = 10;
input bool IncrementSell = true;
input double IncrementSellBy = 0.01;
input int IncrementSellMaxLevels = 10;
input double RealSL = 20;
input double TakeProfit = 50;
input double ProfitLevel1 = 10.0;
input double StopLevel1 = 2.0;
input double MinCandleSize = 5;
input double MaxCandleSize = 50;

input int MaxBuyOrders = 20;
input int MaxSellOrders = 20;
input string hint3 = "===== other setting =====";
input bool IsEcn = true;
input int MagicNumber = 22138;
input ENUM_LINE_STYLE SLLineStyle = STYLE_DASHDOT;
input color SLLineTextColor = clrWhite;
input string SLLineTextFontName = "Tahoma";
input int SLLineTextFontSize = 7;
//+------------------------------------------------------------------+
//| Local Parameters Definition |
//+------------------------------------------------------------------+
string lbl = "ReverseEA.", gbl;
int DecimalPoints;
bool _res;
//+------------------------------------------------------------------+
//| expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//-----------------------------------------------------------------DecimalPoints = 1;
double x = MarketInfo(Symbol(), MODE_LOTSTEP) * 10;
while (x < 1)
{ x *= 10; DecimalPoints += 1; }
//-----------------------------------------------------------------gbl = lbl+Symbol()+"."+IntegerToString(MagicNumber)+".";
if (IsTesting()) { gbl = "B."+gbl; GlobalVariablesDeleteAll(gbl); }
//-----------------------------------------------------------------return (INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//-----------------------------------------------------------------if (reason == REASON_REMOVE) GlobalVariablesDeleteAll(gbl);
if (!IsTesting())
for (int i = ObjectsTotal(0, -1, -1)-1; i >= 0; i--)
if (StringFind(ObjectName(0, i), lbl) != -1)
ObjectDelete(0, ObjectName(0, i));
Comment("");
//-----------------------------------------------------------------}
//+------------------------------------------------------------------+
//| expert start function |
//+------------------------------------------------------------------+
void OnTick()
{
//-----------------------------------------------------------------if (!IsConnected() || AccountNumber() == 0 || Bars <= 30 || ArraySize(Time) == 0) return;
//-----------------------------------------------------------------if (MaxCandleSize == 0 || NormalizeDouble(High[1]-Low[1],
_Digits)<=NormalizeDouble(PipsToPoints(MaxCandleSize), _Digits))
if (MinCandleSize == 0 || NormalizeDouble(High[1]-Low[1],
_Digits)>=NormalizeDouble(PipsToPoints(MinCandleSize), _Digits))
{
if (NormalizeDouble(High[1], _Digits)>NormalizeDouble(High[2], _Digits) &&
NormalizeDouble(Low[1], _Digits)>=NormalizeDouble(Low[2], _Digits))
if (NormalizeDouble(Close[1], _Digits)<=NormalizeDouble((High[1]+Low[1])/2, _Digits))
if (DoesSignalCatched(OP_SELL, Time[0]) == -1 && (GetOrderCount(OP_SELL)<MaxSellOrders ||
MaxSellOrders==0))
SetOrder(OP_SELL, Time[1]);
if (NormalizeDouble(Low[1], _Digits)<NormalizeDouble(Low[2], _Digits) &&
NormalizeDouble(High[1], _Digits)<=NormalizeDouble(High[2], _Digits))
if (NormalizeDouble(Close[1], _Digits)>=NormalizeDouble((High[1]+Low[1])/2, _Digits))
if (DoesSignalCatched(OP_BUY, Time[0]) == -1 && (GetOrderCount(OP_BUY)<MaxBuyOrders ||
MaxBuyOrders==0))
SetOrder(OP_BUY, Time[1]);
if (NormalizeDouble(High[0], _Digits)>NormalizeDouble(High[1], _Digits) &&
NormalizeDouble(Low[0], _Digits)<NormalizeDouble(Low[1], _Digits))
if (NormalizeDouble(Close[0], _Digits)<NormalizeDouble(Low[1], _Digits))

if (DoesSignalCatched(OP_SELL, Time[0]) == -1 && (GetOrderCount(OP_SELL)<MaxSellOrders ||
MaxSellOrders==0))
SetOrder(OP_SELL, Time[0]);
if (NormalizeDouble(Low[0], _Digits)<NormalizeDouble(Low[1], _Digits) &&
NormalizeDouble(High[0], _Digits)>NormalizeDouble(High[1], _Digits))
if (NormalizeDouble(Close[0], _Digits)>NormalizeDouble(High[1], _Digits))
if (DoesSignalCatched(OP_BUY, Time[0]) == -1 && (GetOrderCount(OP_BUY)<MaxBuyOrders ||
MaxBuyOrders==0))
SetOrder(OP_BUY, Time[0]);
}
//-----------------------------------------------------------------ManageSLTP();
//-----------------------------------------------------------------}
//+------------------------------------------------------------------+
int SetOrder(int type, datetime fore)
{
double sl = 0, sl2 = 0, tp = 0, sl3, tp3;
double price = 0;
if (type == OP_BUY)
{
price = Ask;
sl = Low[1] - _Point;
tp = price + PipsToPoints(TakeProfit);
sl2 = sl - PipsToPoints(RealSL);
}
if (type == OP_SELL)
{
price = Bid;
sl = High[1] + _Point;
tp = price - PipsToPoints(TakeProfit);
sl2 = sl + PipsToPoints(RealSL);
}
sl3 = sl2; tp3 = tp;
if (IsEcn) { sl3 = 0; tp3 = 0; }
double lot = InitialLot;
int last = GetLastClosedOrder(type);

if (last != -1)
if ((int)GlobalVariableGet(gbl+IntegerToString(last)+".ClosedByHiddenSL") == true)
{
if (type == OP_BUY && IncrementBuy)
{
lot = OrderLots()+IncrementBuyBy;
if (NormalizeDouble(lot,
DecimalPoints)>NormalizeDouble(InitialLot+IncrementBuyMaxLevels*IncrementBuyBy,
DecimalPoints))
lot = InitialLot+IncrementBuyMaxLevels*IncrementBuyBy;
}
if (type == OP_SELL && IncrementSell)
{
lot = OrderLots()+IncrementSellBy;
if (NormalizeDouble(lot,
DecimalPoints)>NormalizeDouble(InitialLot+IncrementSellMaxLevels*IncrementSellBy,
DecimalPoints))
lot = InitialLot+IncrementSellMaxLevels*IncrementSellBy;
}
}
int ticket = OrderSend(Symbol(), type, lot, price, 0, sl3, tp3, TimeToStr(fore), MagicNumber, 0);
int err = GetLastError();
if (ticket == -1 && err > 0)
Print("err=", IntegerToString(err), ", type=" + IntegerToString(type), ", price=", DoubleToStr(price,
_Digits), ", lot=", DoubleToStr(lot, DecimalPoints), ", ", ErrorDescription(err));
else if (ticket != -1)
{
GlobalVariableSet(gbl+IntegerToString(ticket)+".SL", sl);
GlobalVariableSet(gbl+IntegerToString(ticket)+".TP", tp);
if (IsEcn) ManageSLTP();
}
return (ticket);
}
//+------------------------------------------------------------------+
void ManageSLTP()
{
double isl, sl, tp;

for (int i = OrdersTotal() - 1; i >= 0; i--)
if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
{
if (IsEcn && OrderStopLoss() == 0 && OrderTakeProfit() == 0)
{
sl = 0; tp = 0;
if (OrderType() == OP_BUY)
{
tp = OrderOpenPrice() + PipsToPoints(TakeProfit);
sl = GlobalVariableGet(gbl+IntegerToString(OrderTicket())+".SL") - PipsToPoints(RealSL);
}
else if (OrderType() == OP_SELL)
{
tp = OrderOpenPrice() - PipsToPoints(TakeProfit);
sl = GlobalVariableGet(gbl+IntegerToString(OrderTicket())+".SL") + PipsToPoints(RealSL);
}
if (sl != 0 || tp != 0) _res = OrderModify(OrderTicket(), OrderOpenPrice(), sl, tp, 0);
continue;
}
sl = OrderStopLoss();
isl = GlobalVariableGet(gbl+IntegerToString(OrderTicket())+".SL");
int index = (int)ChartGetInteger(0, CHART_VISIBLE_BARS)-3;
datetime time2 = Time[0]; if (index >= 0) time2 = Time[index];
if (ObjectFind(0, lbl+IntegerToString(OrderTicket())+".SL") == -1)
DrawLine(lbl+IntegerToString(OrderTicket())+".SL", Time[0], isl, clrRed, SLLineStyle, 1);
else
isl = ObjectGetDouble(0, lbl+IntegerToString(OrderTicket())+".SL", OBJPROP_PRICE, 0);
if (sl != 0) DrawText(lbl+IntegerToString(OrderTicket())+".TSL", "#"+IntegerToString(OrderTicket())+"
sl", time2, sl, SLLineTextColor);
int ticket = OrderTicket();
if (OrderType() == OP_BUY)
{
if (isl != 0 && NormalizeDouble(Bid, _Digits)<=NormalizeDouble(isl, _Digits))
if (OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 0))
{
GlobalVariableSet(gbl+IntegerToString(ticket)+".ClosedByHiddenSL", true);
Print("order closed on virtual sl");
continue;
}
if (ProfitLevel4 != 0 && NormalizeDouble(Bid-OrderOpenPrice(),
_Digits)>=NormalizeDouble(PipsToPoints(ProfitLevel4), _Digits))
{
if (NormalizeDouble(sl, _Digits)<NormalizeDouble(OrderOpenPrice()+PipsToPoints(StopLevel4),
_Digits))
{
sl = NormalizeDouble(OrderOpenPrice()+PipsToPoints(StopLevel4), _Digits);
Print("trail sl of order #"+IntegerToString(OrderTicket())+" to "+DoubleToStr(sl, _Digits)+" on
ProfitLevel4");
_res = OrderModify(OrderTicket(), OrderOpenPrice(), sl, OrderTakeProfit(), 0);
}
}
else if (ProfitLevel3 != 0 && NormalizeDouble(Bid-OrderOpenPrice(),
{
_Digits))
{
ProfitLevel3");
}
}
{
_Digits))
{
ProfitLevel2");

}
}
{
_Digits))
{
ProfitLevel1");
}
}
}
else if (OrderType() == OP_SELL)
{
if (isl != 0 && NormalizeDouble(Bid, _Digits)>=NormalizeDouble(isl, _Digits))
if (OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 0))
{
GlobalVariableSet(gbl+IntegerToString(ticket)+".ClosedByHiddenSL", true);
Print("order closed on virtual sl");
continue;
}
if (ProfitLevel4 != 0 && NormalizeDouble(OrderOpenPrice()-Ask,
{
if (NormalizeDouble(sl, _Digits)>NormalizeDouble(OrderOpenPrice()-PipsToPoints(StopLevel4),
_Digits))
{
sl = NormalizeDouble(OrderOpenPrice()-PipsToPoints(StopLevel4), _Digits);
ProfitLevel4");
}
}
else if (ProfitLevel3 != 0 && NormalizeDouble(OrderOpenPrice()-Ask,

{
_Digits))
{
ProfitLevel3");
}
}
{
_Digits))
{
ProfitLevel2");
}
}
{
_Digits))
{
ProfitLevel1");
}
}
}
}
//-----------------------------------------------------------------for (int i = ObjectsTotal()-1; i >= 0; i--)
if (StringFind(ObjectName(0, i), lbl) != -1)
if (ObjectType(ObjectName(0, i)) == OBJ_HLINE || ObjectType(ObjectName(0, i)) == OBJ_TEXT)
{
int index = StringFind(ObjectName(0, i), ".", StringLen(lbl));
int ticket = StrToInteger(StringSubstr(ObjectName(0, i), StringLen(lbl), index-StringLen(lbl)));
if (OrderSelect(ticket, SELECT_BY_TICKET))
if (OrderCloseTime() != 0)
{
GlobalVariableDel(gbl+IntegerToString(OrderTicket())+".SL");
GlobalVariableDel(gbl+IntegerToString(OrderTicket())+".TP");
ObjectDelete(ObjectName(0, i));
}
}
//-----------------------------------------------------------------}
//+------------------------------------------------------------------+
int DoesSignalCatched(int type, datetime from)
{
if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && OrderType() == type
&& OrderOpenTime()>=from)
return (OrderTicket());
for (int i = OrdersHistoryTotal() - 1; i >= 0; i--)
if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && OrderType() == type
&& OrderOpenTime()>=from)
return (-1);
}
//+------------------------------------------------------------------+
int GetOrderCount(int type)
{
int count = 0;

if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && OrderType() == type)
count ++;
return (count);
}
//+------------------------------------------------------------------+
int GetLastClosedOrder(int type)
{
for (int i = OrdersHistoryTotal() - 1; i >= 0; i--)
if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber && OrderType() == type)
return (-1);
}
//+------------------------------------------------------------------+
double PipsToPoints(double pips)
{
if (_Digits == 5 || _Digits == 3) pips *= 10;
return (pips * _Point);
}
//+------------------------------------------------------------------+
string GetSignalName(int sig)
{
if (sig == OP_BUY) return ("Long");
else if (sig == OP_SELL) return ("Short");
else return ("None");
}
//+------------------------------------------------------------------+
string GetTimeFrameName(int TimeFrame)
{
switch (TimeFrame)
{
case PERIOD_M1: return("M1");
case PERIOD_H1: return("H1");

case PERIOD_H4: return("H4");
case PERIOD_D1: return("D1");
case PERIOD_W1: return("W1");
case PERIOD_MN1: return("MN1");
case 0: return(GetTimeFrameName(Period()));
}
return ("");
}
//+------------------------------------------------------------------+
void DrawText(string name, string text, datetime time, double price, color col)
{
if (ObjectFind(name) == -1)
{
ObjectCreate(name, OBJ_TEXT, 0, time, price);
ObjectSet(name, OBJPROP_BACK, false);
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
}
ObjectSet(name, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);
if (ObjectGet(name, OBJPROP_COLOR)!=col) ObjectSet(name, OBJPROP_COLOR, col);
if (ObjectGet(name, OBJPROP_TIME1)!=time) ObjectSet(name, OBJPROP_TIME1, time);
if (ObjectGet(name, OBJPROP_PRICE1)!=price) ObjectSet(name, OBJPROP_PRICE1, price);
if (ObjectDescription(name)!=text || ObjectGet(name, OBJPROP_FONTSIZE)!=SLLineTextFontSize)
ObjectSetText(name, text, SLLineTextFontSize, SLLineTextFontName);
}
//+------------------------------------------------------------------+
void SetText(string name, string text, int _size, string _font, color col = clrNONE)
{
ObjectSetInteger(0, name, OBJPROP_FONTSIZE, _size);
if (col != clrNONE) ObjectSetInteger(0, name, OBJPROP_COLOR, col);
ObjectSetString(0, name, OBJPROP_FONT, _font);
ObjectSetString(0, name, OBJPROP_TEXT, text);
}
//+------------------------------------------------------------------+
void DrawLine(string name, datetime time, double price, color col, int style, int width)
{
if (ObjectFind(0, name) == -1)

{
ObjectCreate(0, name, OBJ_HLINE, 0, time, price);
ObjectSetInteger(0, name, OBJPROP_RAY, false);
ObjectSetInteger(0, name, OBJPROP_BACK, false);
ObjectSetInteger(0, name, OBJPROP_SELECTED, false);
ObjectSetInteger(0, name, OBJPROP_SELECTABLE, true);
ObjectSetInteger(0, name, OBJPROP_HIDDEN, false);
}
if (ObjectGetInteger(0, name, OBJPROP_COLOR) != col) ObjectSetInteger(0, name,
OBJPROP_COLOR, col);
if (ObjectGetInteger(0, name, OBJPROP_WIDTH) != width) ObjectSetInteger(0, name,
OBJPROP_WIDTH, width);
if (ObjectGetInteger(0, name, OBJPROP_STYLE) != style) ObjectSetInteger(0, name,
OBJPROP_STYLE, style);
if (ObjectGetInteger(0, name, OBJPROP_TIME, 0) != time) ObjectSetInteger(0, name,
OBJPROP_TIME, 0, time);
if (ObjectGetInteger(0, name, OBJPROP_TIME, 1) != time) ObjectSetInteger(0, name,
OBJPROP_TIME, 1, time);
if (NormalizeDouble(ObjectGetDouble(0, name, OBJPROP_PRICE, 0), _Digits) != price)
ObjectSetDouble(0, name, OBJPROP_PRICE, 0, price);
if (NormalizeDouble(ObjectGetDouble(0, name, OBJPROP_PRICE, 1), _Digits) != price)
ObjectSetDouble(0, name, OBJPROP_PRICE, 1, price);
}
//+------------------------------------------------------------------+
bang power,copy ini dah namai mq4..ni EA trend reverse untuk sell limit/buy limit
untuk indi ketik di google " MTF_Fractal_638.ex4 site:mql5.com "
cuma 2 ini barang bagus yang ku punya..yang lain masih dalam proses

Reverse Ea

Uploaded by

Copyright:

Available Formats

Reverse Ea

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Reverse Ea

Uploaded by

Copyright:

Available Formats

//+------------------------------------------------------------------+

input double MaxCandleSize = 50;

if (NormalizeDouble(Close[0], _Digits)<NormalizeDouble(Low[1], _Digits))

int last = GetLastClosedOrder(type);

double isl, sl, tp;

_res = OrderModify(OrderTicket(), OrderOpenPrice(), sl, OrderTakeProfit(), 0);

else if (ProfitLevel3 != 0 && NormalizeDouble(OrderOpenPrice()-Ask,

for (int i = OrdersTotal() - 1; i >= 0; i--)

case PERIOD_H1: return("H1");

if (ObjectFind(0, name) == -1)

You might also like