//+------------------------------------------------------------------+
//| Copyright 2018 YutakaYokouchi |
//| www.mql5.com/en/users/abundant |
//+------------------------------------------------------------------+
//| Constants and enumeration for migration |
//+------------------------------------------------------------------+
#define MODE_TIME 5
#define MODE_BID 9
#define MODE_ASK 10
#define MODE_POINT 11
#define MODE_DIGITS 12
#define MODE_STOPLEVEL 14
#define MODE_LOTSIZE 15
#define MODE_TICKVALUE 16
#define MODE_TICKSIZE 17
#define MODE_SWAPLONG 18
#define MODE_SWAPSHORT 19
#define MODE_STARTING 20
#define MODE_EXPIRATION 21
#define MODE_TRADEALLOWED 22
#define MODE_MINLOT 23
#define MODE_LOTSTEP 24
#define MODE_MAXLOT 25
#define MODE_SWAPTYPE 26
#define MODE_PROFITCALCMODE 27
#define MODE_MARGINCALCMODE 28
#define MODE_MARGININIT 29
#define MODE_MARGINMAINTENANCE 30
#define MODE_MARGINHEDGED 31
#define MODE_MARGINREQUIRED 32
#define MODE_FREEZELEVEL 33
#define MODE_CLOSEBY_ALLOWED 34
#define OP_BUY 0
#define EMPTY -1
#define MODE_TRADES 0
#define MODE_HISTORY 1
#define SELECT_BY_POS 0
#define SELECT_BY_TICKET 1
//+------------------------------------------------------------------+
//| Converted by BRiCK |
//| www.mql5.com/en/users/abundant |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| 7777777.mq4 |
//| — |
//| — |
//+------------------------------------------------------------------+
#property copyright «777»
#property link «777»
#property version «777»
#property strict

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

#define RUS
#define RESOURCE_IND
#define TESTER_HIGHT_IND

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

enum ENUM_ON{
ON = (int)true,
OFF = (int)false};

enum ENUM_TREND{
TREND_UP=0,
TREND_DN=1,
TREND_NO=-1,
TREND_ER=-2
};

datetime gl_tm_old = 0;

#ifdef RUS
enum ENUM_bar{
bar_0=0, //#0 текущий
bar_1=1, //#1 закрытый
};
#else
enum ENUM_bar{
bar_0=0, //#0 current
bar_1=1, //#1 close
};
#endif

#ifdef RUS
sinput string inp_s1 = "-----------ATRH----------"; //------ С Т Р Е Л О Ч Н И К —
input ENUM_bar inp_sign_bar = bar_1; //СИГНАЛ НА ТЕКУЩЕЙ СВЕЧЕ \ ПОСЛЕ ЗАКРЫТИЯ
input short inp_sign_shift = 0; //задержка (сек) от открытия бара
sinput string inp_s2 = "---------------------------"; //------ Торговля — input double inp_ord_lot = 0.01; //Л О Т
input uint inp_ord_tp = 0; //ТЕЙК
input uint inp_ord_sl = 0; //СТОП
input ushort inp_ord_magic = 888; //Магик
input ushort inp_ord_count = 1; //Макс.кол-во открытых ордеров
input ENUM_ON inp_cls = true; //Закрывать ордера при противоположном сигнале
#else
sinput string inp_s1 = "---------------------------"; //------ Indicator — input ENUM_bar inp_sign_bar = bar_1; //signal bar
input short inp_sign_shift = 0; //delay (sec) from bar opening
sinput string inp_s2 = "---------------------------"; //------ Trade — input double inp_ord_lot = 0.01; //Lot
input uint inp_ord_tp = 0; //TP pips
input uint inp_ord_sl = 0; //SL pips
input ushort inp_ord_magic = 888; //Magic
input ushort inp_ord_count = 1; //Max orders in the market
input ENUM_ON inp_cls = true; //Close orders opposite to the signal
#endif

//---------------INDICATOR
#define ind_name «ATRH»

#ifdef RESOURCE_IND
#resource "\\Indicators\\"+ind_name+".ex4"
#endif

//--------------- MESSAGE
#define MessageBoxE(msg) MessageBox(msg, msg_e, MB_ICONERROR|MB_OK);
#define MessageBoxQ(msg) MessageBox(msg, "", MB_OKCANCEL|MB_ICONQUESTION)==IDOK

#ifdef RUS
#define msg_e «Ошибка»
#define msg_s " сек "
#define msg_10 «Настройка \»задержка (сек) от открытия бара\" \nне может быть более чем секунд в баре "
#else
#define msg_e «Error»
#define msg_s " sec "
#define msg_10 «The setting is \»delay (sec) from bar opening\" \ncannot be more than seconds in the bar "
#endif

//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit(){
BRiCK();

if(inp_sign_shift>=PeriodSeconds()){ MessageBoxE(msg_10+" ["+IntegerToString(PeriodSeconds())+msg_s+"] !"); return(INIT_FAILED);}
gl_tm_old = Time[0];
#ifdef TESTER_HIGHT_IND
TesterHideIndicators(true);
#endif
return(INIT_SUCCEEDED);}

//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick(){
BRiCK();

datetime tm_new = Time[0];

if(gl_tm_old != tm_new){
bool b = false;

//--- GET SIGNAL
ENUM_TREND sig = ( TimeCurrent() < (tm_new+inp_sign_shift)? TREND_NO: Fn_signal(inp_sign_bar) );
if(sig==TREND_UP || sig==TREND_DN){ b = true;

//--- CLOSE
if(inp_cls)
b = Fn_ord_cls_all( (sig!=TREND_UP), _Symbol, inp_ord_magic) && b;

//--- OPEN
if(inp_ord_count<=0 || inp_ord_count > Fn_ord_count(-1, _Symbol, inp_ord_magic) )
b = Fn_ord_set( (sig==TREND_UP), inp_ord_lot, inp_ord_sl, inp_ord_tp, inp_ord_magic, NULL, tm_new) && b;

}

if(b) gl_tm_old = tm_new;}

}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason){
BRiCK();

}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Signal |
//+------------------------------------------------------------------+
double Fn_ind_get_value(int buf_num, int index){
return(iCustom_MQL4(_Symbol,PERIOD_CURRENT, #ifdef RESOURCE_IND "::Indicators\\"+ #endif ind_name, 5, 10, 3.0, 0.8, true, true, 4, 1, 55, true, true, 15332840, 15066623, true, 1, 2632959, 5287756, true, 14262365, 6513125, true, 5287756, 2632959, 12, "***************", true, true, false, true, «alert.wav», buf_num, index)); }

ENUM_TREND Fn_signal(int index=1){
double val_b = Fn_ind_get_value(0, index); bool is_b = (val_b!=0.0 && val_b!=EMPTY_VALUE);
double val_s = Fn_ind_get_value(1, index); bool is_s = (val_s!=0.0 && val_s!=EMPTY_VALUE);
if( is_b && !is_s){ return(TREND_UP); }
if(!is_b && is_s){ return(TREND_DN); }
return(TREND_NO); }

//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| |
//| ORDS |
//| |
//+------------------------------------------------------------------+
int Sp_order_select(int index, int is_buy=-1, string symb=NULL, int magic=-1, string comm=NULL, int pool = MODE_TRADES, datetime time_start=0, bool only_loss = false){
if(!OrderSelect(index, SELECT_BY_POS, pool) ) return(0);
if( magic >= 0 && magic != OrderMagicNumber() ) return(0);
if( time_start >= 0 && time_start > OrderOpenTime () ) return(0);
if( is_buy >= 0 && is_buy != ((OrderType()%2)==0) ) return(0);
if( symb != NULL && StringFind(OrderSymbol (), symb)<0 ) return(0);
if( comm != NULL && StringFind(OrderComment(), comm)<0 ) return(0);
if( only_loss && (OrderProfit()+OrderSwap()+OrderCommission())>=0 ) return(0);
return(OrderTicket());}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
#define IN int is_buy=-1, string symb = NULL, int magic=-1, string comm=NULL, bool is_hist=false, datetime time_start=0, bool only_loss = false
#define FOR for(int i = (is_hist?OrdersHistoryTotal():OrdersTotal_MQL4())-1; i>=0; i--){ \
int tic = Sp_order_select(i, is_buy, symb, magic, comm, (is_hist?MODE_HISTORY:MODE_TRADES), time_start, only_loss);
//…
int Fn_ord_find(IN){
FOR if(tic>0) return(tic); }
return(0);}
//…
int Fn_ord_count(IN){
int rez = 0;
FOR if(tic>0) rez++; }
return(rez);}
//…
bool Fn_ord_cls_all(int is_buy=-1, string symb = NULL, int magic=-1, string comm=NULL, datetime time_start=0, bool only_loss = false){
const bool is_hist=false;
bool rez = true;
FOR if(!Fn_ord_cls(tic)) rez = false; }
return(rez);}
//…

#undef IN
#undef FOR
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
void _print_err(string s){ Print(«ERROR! „+s); }

bool IsOkTerminal(){
static bool alrt = true;
if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) ) { string str=“Terminal trade NO allowed!»; if(alrt){ alrt=false; _print_err(str); } return(false); }
if(!MQLInfoInteger (MQL_TRADE_ALLOWED) ) { string str=«MQL trade NO allowed!»; if(alrt){ alrt=false; _print_err(str); } return(false); }
alrt = true;
return(true);}

double NormalizeLevel(double val, bool is_up, double lev, double point, int min_dist=0){
if (lev<=0 || val<=0) return(val);
int razn=(int)((is_up?(val-lev) lev-val))/point);
if(razn<min_dist) return(is_up?(lev+min_dist*point) lev-min_dist*point));
return(val); }

double NormalizeLot(string symbol, double lot, bool is_margin=true){
if(lot<=0) return(0);
double min=SymbolInfoDouble(symbol,SYMBOL_VOLUME_MIN);
double max=SymbolInfoDouble(symbol,SYMBOL_VOLUME_MAX);
double step=SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP);
double free = AccountFreeMargin();
double margin = MarketInfo(Symbol(),MODE_MARGINREQUIRED);
double _lot=(lot<min)?min (lot>max)?max:lot);
_lot=MathRound(_lot/step)*step;
if(is_margin && _lot*margin>=free) { _lot= MathFloor(free/margin/step)*step; }
return(_lot);}

//+------------------------------------------------------------------+
bool Fn_ord_set(bool is_buy, double volume, int SL, int TP, int magic, string comm, datetime time_start=0){

if(!IsOkTerminal()) return(false);

//…
static bool is_alert = true;
string symb = _Symbol;
int Min_SL =(int)SymbolInfoInteger(symb,SYMBOL_TRADE_STOPS_LEVEL)+1;
int dig =(int)SymbolInfoInteger(symb,SYMBOL_DIGITS);
double point = SymbolInfoDouble (symb,SYMBOL_POINT);
double zn = (is_buy?1 -1));

//…
for(int i=0; (i<5 && !IsStopped()); i++){

if(volume<=0) return(false);

if(time_start>0){
if(Fn_ord_find((int)is_buy, symb, magic, comm, false, time_start)> 0 ) return(true);
if(Fn_ord_find((int)is_buy, symb, magic, comm, true, time_start)> 0 ) return(true); }

//------
double pr_opn = NormalizeDouble((is_buy?SymbolInfoDouble(symb, SYMBOL_ASK):SymbolInfoDouble(symb, SYMBOL_BID)), dig);
double pr_cls = NormalizeDouble((is_buy?SymbolInfoDouble(symb, SYMBOL_BID):SymbolInfoDouble(symb, SYMBOL_ASK)), dig);

//---- level
double tp = ((TP<=0)?0:NormalizeDouble(NormalizeLevel((pr_opn+(is_buy?( 1) -1))*TP*point), is_buy, pr_opn, point, Min_SL), dig));
double sl = ((SL<=0)?0:NormalizeDouble(NormalizeLevel((pr_opn-(is_buy?( 1) -1))*SL*point), !is_buy, pr_cls, point, Min_SL), dig));

//----- Lot
double lot=NormalizeLot(symb, volume);
if(lot<=0){ if(is_alert){Alert(«Very big lot!»); is_alert=false;} return(false);}

//----- Set
int tic=OrderSend(symb, (is_buy?ORDER_TYPE_BUY:ORDER_TYPE_SELL), lot, pr_opn, 0, sl, tp, comm, magic);

//----- Err
if (tic>0){ is_alert=true; return(true); }
else if (!Errors(GetLastError(), is_alert)) return(false);}
//--------------------
return(false); }

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

bool Fn_ord_cls(int ticket, double lot_close=0, string comm=""){
if(!IsOkTerminal()) return(false);
static bool is_alert = true;

for(int i=0; (i<5 && !IsStopped()); i++){

if(!OrderSelect(ticket, SELECT_BY_TICKET)) return(true);
if(OrderCloseTime()>0) return(true);

bool ans = true;
if(OrderType()==ORDER_TYPE_BUY || OrderType()==ORDER_TYPE_SELL){
double pr = SymbolInfoDouble(OrderSymbol(), (OrderType()==ORDER_TYPE_BUY?SYMBOL_BID:SYMBOL_ASK) );
double lot = (lot_close<=0 || lot_close>OrderLots())?OrderLots():NormalizeLot(OrderSymbol(), lot_close);
ans = OrderClose(ticket, lot, pr, 0);}
else{ ans = OrderDelete(ticket); }

if (ans) {is_alert=true; if(comm!="") Print(«CLOSE Order: „+comm); return(true); }
else if (!Errors(GetLastError(), is_alert)) return(false);

}

return(false); }

//+------------------------------------------------------------------+
bool Errors(int err, bool &alerts){
string str=“»;
bool rez=false;
switch(err) {
case 4: str=«Trade server is busy. once again...»; Sleep(500); RefreshRates(); rez=true; break;
case 128: str=«Trade timeout. once again...»; RefreshRates(); rez=true; break;
case 135: str=«Price changed. once again...»; RefreshRates(); rez=true; break;
case 136: str=«Off quotes. once again...»; RefreshRates(); rez=true; break;
case 137: str=«Broker is busy. once again...»; Sleep(500); RefreshRates(); rez=true; break;
case 138: str=«Requote. once again...»; Sleep(500); RefreshRates(); rez=true; break;
case 146: str=«Trade context is busy. once again...»; Sleep(500); RefreshRates(); rez=true; break;
//------------------------------------------------------------
case 2: str=«Common error»; rez=false; break;
case 5: str=«Old version of the client terminal»; rez=false; break;
case 6: str=«No connection with trade server»; rez=false; break;
case 64: str=«Account disabled»; rez=false; break;
case 65: str=«Invalid account»; rez=false; break;
case 129: str=«Invalid price»; rez=false; break;
case 130: str=«Invalid stops»; rez=false; break;
case 131: str=«Invalid trade volume»; rez=false; break;
case 132: str=«Market is closed»; rez=false; break;
case 133: str=«Trade is disabled»; rez=false; break;
case 134: str=«Not enough money»; rez=false; break;
case 145: str=«Modification denied because order is too close to market»; rez=false; break;
case 4109: str=«Trade is not allowed»; rez=false; break;
case 4108: /*ордер закрылся прежде чем мы смогли что-то сделать*/ rez=false; break;
default: str= «Error ord „+IntegerToString(err); rez=false; break;}
if(str!=“» && alerts){ Alert(str); alerts=false;}
return (rez);}

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

//+------------------------------------------------------------------+
//| Copyright 2018 YutakaYokouchi |
//| www.mql5.com/en/users/abundant |
//+------------------------------------------------------------------+
//| Functions for migration |
//+------------------------------------------------------------------+
double Ask=0;
int Bars=0;
double Bid=0;
int Digits=0;
double Point=0;
double Close[];
double High[];
double Low[];
double Open[];
datetime Time[];
long Volume[];
void BRiCK()
{
Ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
Bars=Bars(_Symbol, _Period);
Bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);
Digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);
Point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);

ArraySetAsSeries(Close, true);
ArraySetAsSeries(High, true);
ArraySetAsSeries(Low, true);
ArraySetAsSeries(Open, true);
ArraySetAsSeries(Time, true);
ArraySetAsSeries(Volume, true);

int count = Bars(_Symbol, _Period);

ArrayResize(Close, count);
ArrayResize(High, count);
ArrayResize(Low, count);
ArrayResize(Open, count);
ArrayResize(Time, count);
ArrayResize(Volume, count);

CopyClose(_Symbol, _Period, 0, Bars, Close);
CopyHigh(_Symbol, _Period, 0, Bars, High);
CopyLow(_Symbol, _Period, 0, Bars, Low);
CopyOpen(_Symbol, _Period, 0, Bars, Open);
CopyTime(_Symbol, _Period, 0, Bars, Time);
CopyTickVolume(_Symbol, _Period, 0, Bars, Volume);
}

double AccountFreeMargin()
{
return(AccountInfoDouble(ACCOUNT_MARGIN_FREE));
}

int Seconds()
{
MqlDateTime tm;
TimeCurrent(tm);
return(tm.sec);
}
double MarketInfo(string symbol, int type)
{
int fill_type=SYMBOL_ORDER_CLOSEBY;
int filling=(int)SymbolInfoInteger(symbol,SYMBOL_FILLING_MODE);
switch(type){
case MODE_LOW:
return(SymbolInfoDouble(symbol,SYMBOL_LASTLOW));
case MODE_HIGH:
return(SymbolInfoDouble(symbol,SYMBOL_LASTHIGH));
case MODE_TIME:
return((double)SymbolInfoInteger(symbol,SYMBOL_TIME));
case MODE_BID:
return(SymbolInfoDouble(symbol,SYMBOL_BID));
case MODE_ASK:
return(SymbolInfoDouble(symbol,SYMBOL_ASK));
case MODE_POINT:
return(SymbolInfoDouble(symbol,SYMBOL_POINT));
case MODE_DIGITS:
return((double)SymbolInfoInteger(symbol,SYMBOL_DIGITS));
case MODE_SPREAD:
return((double)SymbolInfoInteger(symbol,SYMBOL_SPREAD));
case MODE_STOPLEVEL:
return((double)SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL));
case MODE_LOTSIZE:
return(SymbolInfoDouble(symbol,SYMBOL_TRADE_CONTRACT_SIZE));
case MODE_TICKVALUE:
return(SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_VALUE));
case MODE_TICKSIZE:
return(SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_SIZE));
case MODE_SWAPLONG:
return(SymbolInfoDouble(symbol,SYMBOL_SWAP_LONG));
case MODE_SWAPSHORT:
return(SymbolInfoDouble(symbol,SYMBOL_SWAP_SHORT));
case MODE_STARTING:
return((double)SymbolInfoInteger(symbol,SYMBOL_START_TIME));
case MODE_EXPIRATION:
return((double)SymbolInfoInteger(symbol,SYMBOL_EXPIRATION_TIME));
case MODE_TRADEALLOWED:
return((double)MQLInfoInteger(MQL_TRADE_ALLOWED));
case MODE_MINLOT:
return(SymbolInfoDouble(symbol,SYMBOL_VOLUME_MIN));
case MODE_LOTSTEP:
return(SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP));
case MODE_MAXLOT:
return(SymbolInfoDouble(symbol,SYMBOL_VOLUME_MAX));
case MODE_SWAPTYPE:
return((double)SymbolInfoInteger(symbol,SYMBOL_SWAP_MODE));
case MODE_PROFITCALCMODE:
return((double)SymbolCalcMode((int)SymbolInfoInteger(symbol,SYMBOL_TRADE_CALC_MODE)));
case MODE_MARGINCALCMODE:
return((double)SymbolCalcMode((int)SymbolInfoInteger(symbol,SYMBOL_TRADE_CALC_MODE)));
case MODE_MARGININIT:
return(SymbolInfoDouble(symbol,SYMBOL_MARGIN_INITIAL));
case MODE_MARGINMAINTENANCE:
return(SymbolInfoDouble(symbol,SYMBOL_MARGIN_MAINTENANCE));
case MODE_MARGINHEDGED:
return(SymbolInfoDouble(symbol,SYMBOL_MARGIN_HEDGED));
case MODE_FREEZELEVEL:
return((double)SymbolInfoInteger(symbol,SYMBOL_TRADE_FREEZE_LEVEL));
case MODE_CLOSEBY_ALLOWED:
return((double)(filling & fill_type)==fill_type);
}
return(0);
}
int SymbolCalcMode(int mode)
{
switch(mode)
{
case 0:
return(0);
case 5:
return(0);
case 2:
return(1);
case 4:
return(1);
case 1:
return(2);
case 33:
return(2);
case 34:
return(2);
case 3:
return(3);
default:
break;
}
return(mode);
}
double iCustom_MQL4(string symbol,int timeframe,string name,double arg1=-1,double arg2=-1,double arg3=-1,double arg4=-1,double arg5=-1,double arg6=-1,double arg7=-1,double arg8=-1,double arg9=-1)
{
return(0);
}
bool RefreshRates()
{
return(false);
}
bool OrderClose(int ticket_,double volume_,double price_,int slippage_,color color_=clrNONE)
{
return(false);
}
datetime OrderCloseTime()
{
return(0);
}
string OrderComment()
{
return("");
}
double OrderCommission()
{
return(0);
}
bool OrderDelete(int ticket_,color color_=clrNONE)
{
return(false);
}
double OrderLots()
{
return(0);
}
int OrderMagicNumber()
{
return(0);
}
double OrderProfit()
{
return(0);
}
bool OrderSelect(int index,int select,int pool_=MODE_TRADES)
{
return(false);
}
int OrderSend(string symbol_,int cmd_,double volume_,double price_,int slippage_,double sl_,double tp_,string comment_=NULL,int magic_=0,datetime expiration_=0,color color_=clrNONE)
{
return(0);
}
int OrdersHistoryTotal()
{
return(0);
}
int OrdersTotal_MQL4()
{
return(0);
}
double OrderSwap()
{
return(0);
}
string OrderSymbol()
{
return("");
}
int OrderTicket()
{
return(0);
}
int OrderType()
{
return(OP_BUY);
}
uint last_error_trade=0;
int GetLastError_Trade()
{
int _last_error_trade=(int)last_error_trade;
last_error_trade=0;
return(_last_error_trade);
}

ENUM_TIMEFRAMES IntegerToTimeframe(int value){
switch(value){
case 1:
return(PERIOD_M1);
case 2:
return(PERIOD_M2);
case 3:
return(PERIOD_M3);
case 4:
return(PERIOD_M4);
case 5:
return(PERIOD_M5);
case 6:
return(PERIOD_M6);
case 10:
return(PERIOD_M10);
case 12:
return(PERIOD_M12);
case 15:
return(PERIOD_M15);
case 20:
return(PERIOD_M20);
case 30:
return(PERIOD_M30);
case 60:
return(PERIOD_H1);
case 120:
return(PERIOD_H2);
case 180:
return(PERIOD_H3);
case 240:
return(PERIOD_H4);
case 360:
return(PERIOD_H6);
case 480:
return(PERIOD_H8);
case 720:
return(PERIOD_H12);
case 1440:
return(PERIOD_D1);
case 10080:
return(PERIOD_W1);
case 43200:
return(PERIOD_MN1);
default:
return(PERIOD_CURRENT);
}
}
//+------------------------------------------------------------------+
//| Converted by BRiCK |
//| www.mql5.com/en/users/abundant |
//+------------------------------------------------------------------+