2019 lines
No EOL
141 KiB
MQL4
2019 lines
No EOL
141 KiB
MQL4
//+------------------------------------------------------------------+
|
|
//| trendmeEA.mq4 |
|
|
//| Copyright 2019, MetaQuotes Software Corp. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#define pdxversion "1.00"
|
|
#property copyright "Klymenko Roman (needtome@icloud.com)"
|
|
#property link "https://www.mql5.com/en/users/needtome"
|
|
#property version pdxversion
|
|
#property strict
|
|
|
|
enum TypeOfLimit //Limit Mode
|
|
{
|
|
STOP,//STOP
|
|
LIMIT,// LIMIT
|
|
};
|
|
enum TypeOfStop //Stop Mode
|
|
{
|
|
STOP_NONE,// none
|
|
STOP_HIGH,// by wicks
|
|
STOP_OPEN,// by open
|
|
STOP_CLOSE,// by close
|
|
};
|
|
enum TypeOfBar //Bar Mode
|
|
{
|
|
BAR_1,// bar 1
|
|
BAR_0,// bar 0
|
|
BAR_01,// bars 0 and 1
|
|
};
|
|
enum BarType //Bar Type
|
|
{
|
|
BAR_NONE,// do not enter
|
|
BAR_MIN,// take profit 1
|
|
};
|
|
enum TypeOfPos
|
|
{
|
|
MY_BUY,
|
|
MY_SELL,
|
|
MY_BUYSTOP,
|
|
MY_BUYLIMIT,
|
|
MY_SELLSTOP,
|
|
MY_SELLLIMIT,
|
|
MY_BUYSLTP,
|
|
MY_SELLSLTP,
|
|
};
|
|
enum TypeOfLang{
|
|
MY_ENG, // English
|
|
MY_RUS, // Русский
|
|
};
|
|
enum TypeOfLots //Lots Mode
|
|
{
|
|
MY_FIXED,//Fixed
|
|
MY_ARIFMET,// Arifmet
|
|
MY_GEOMET,// Geomet
|
|
};
|
|
|
|
input int EA_Magic=333;
|
|
input TypeOfLimit typeLimit=STOP; // (-) Limit order type
|
|
input string my_cmt="trendmeEA"; // Comment
|
|
input bool open_LONG = true; // Open Long
|
|
input bool open_SHORT = true; // Open Short
|
|
input double Lot=0.01; //Lot size
|
|
input TypeOfLots typeLot=MY_FIXED; // (-) Increasing a lot in a chain
|
|
input uint maxLimits=5; // Max number of limit orders in one direction
|
|
input bool noOpenFirstLine=false; // Do not place the nearest orders
|
|
input int desicion=3; // Decade for limit orders
|
|
input int d_offset=0; // Shift in points
|
|
input double order_TP=2.5; // Order take profit
|
|
input double order_SL=0; // Order stop loss
|
|
input int maxOnPrice=33; // Max orders at the same price
|
|
input int maxAll=300; // Max orders in one direction
|
|
input double noOpenLongMax=0; // Do not open Long if the price exceeds
|
|
input double noOpenLongMin=0; // Do not open Long if the price is less than
|
|
input double noOpenShortMax=0; // Do not open Short if the price exceeds
|
|
input double noOpenShortMin=0; // Do not open Short if the price is less than
|
|
input uint doubleLot1=0; // #1 Increase lot if the balance increases, $
|
|
input uint doubleLot2=0; // #2 Increase lot if the balance increases, $
|
|
input uint doubleLot3=0; // #3 Increase lot if the balance increases, $
|
|
sinput string delimeter_02=""; // --- Closing all positions
|
|
input double takeProfit=0; // Profit, $
|
|
input double equityGross=0; // If equity increased, $
|
|
input double equityLess=0; // If equity decreased, $
|
|
input double closeAllMax=0; // Close all at price exceeding
|
|
input double closeAllMin=0; // Close all at price less than
|
|
sinput string delimeter_05=""; // --- (-) Trailing Stop
|
|
input uint trailing1NumStepsStart=0;
|
|
input uint trailing1NumStepsSave=1;
|
|
input uint trailing1NumStepsTP=0;
|
|
input uint trailing2NumStepsStart=0;
|
|
input uint trailing2NumStepsSave=3;
|
|
input uint trailing2NumStepsTP=0;
|
|
sinput string delimeter_07=""; // --- In bar direction
|
|
input bool BARS_enabled=false; // Use entry by bar only
|
|
input BarType BARS_type=BAR_NONE; // Bar accounting type
|
|
input TypeOfBar typeBar=BAR_1; // Bar index
|
|
input ENUM_TIMEFRAMES BARS_Timeframe=PERIOD_M15; // Timeframe
|
|
sinput string delimeter_09=""; // --- Other
|
|
input TypeOfLang LANG=MY_RUS; // Language
|
|
|
|
#ifdef __MQL5__
|
|
#include <Trade\Trade.mqh>
|
|
CTrade Trade;
|
|
|
|
enum TypeOfFilling //Filling Mode
|
|
{
|
|
FOK,//ORDER_FILLING_FOK
|
|
RETURN,// ORDER_FILLING_RETURN
|
|
IOC,//ORDER_FILLING_IOC
|
|
};
|
|
input TypeOfFilling useORDER_FILLING_RETURN=FOK; // Order filling mode
|
|
#endif
|
|
|
|
|
|
MqlTick lastme;
|
|
double rawPrice=0;
|
|
double maxPrice=0;
|
|
double minPrice=0;
|
|
double step=0;
|
|
uint LongLimit=0;
|
|
uint ShortLimit=0;
|
|
uint LongPos=0;
|
|
uint ShortPos=0;
|
|
double LongVol=0;
|
|
double ShortVol=0;
|
|
double minStop=0;
|
|
string prefix_graph="trendme_";
|
|
string msg_lines[];
|
|
uchar lines_size=0;
|
|
double curLot;
|
|
int h;
|
|
double buf0[];
|
|
double buf1[];
|
|
double buf2[];
|
|
int cur_offset;
|
|
bool noLong=false;
|
|
bool noShort=false;
|
|
datetime Old_Time=0;
|
|
|
|
struct translate{
|
|
string err1;
|
|
string err2;
|
|
string err3;
|
|
string err4;
|
|
string err5;
|
|
string err6;
|
|
string err7;
|
|
string err8;
|
|
string err9;
|
|
string err64;
|
|
string err65;
|
|
string err128;
|
|
string err129;
|
|
string err130;
|
|
string err131;
|
|
string err132;
|
|
string err133;
|
|
string err134;
|
|
string err135;
|
|
string err136;
|
|
string err137;
|
|
string err138;
|
|
string err139;
|
|
string err140;
|
|
string err141;
|
|
string err145;
|
|
string err146;
|
|
string err147;
|
|
string err148;
|
|
string err0;
|
|
string retcode;
|
|
string retcode10004;
|
|
string retcode10006;
|
|
string retcode10007;
|
|
string retcode10010;
|
|
string retcode10011;
|
|
string retcode10012;
|
|
string retcode10013;
|
|
string retcode10014;
|
|
string retcode10015;
|
|
string retcode10016;
|
|
string retcode10017;
|
|
string retcode10018;
|
|
string retcode10019;
|
|
string retcode10020;
|
|
string retcode10021;
|
|
string retcode10022;
|
|
string retcode10023;
|
|
string retcode10024;
|
|
string retcode10025;
|
|
string retcode10026;
|
|
string retcode10027;
|
|
string retcode10028;
|
|
string retcode10029;
|
|
string retcode10030;
|
|
string retcode10031;
|
|
string retcode10032;
|
|
string retcode10033;
|
|
string retcode10034;
|
|
string retcode10035;
|
|
string retcode10036;
|
|
string retcode10038;
|
|
string retcode10039;
|
|
string retcode10040;
|
|
string retcode10041;
|
|
string retcode10042;
|
|
string retcode10043;
|
|
string retcode10044;
|
|
};
|
|
translate langs;
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
if(!MQLInfoInteger(MQL_TRADE_ALLOWED)){
|
|
Comment("The Expert Advisor is not allowed to trade! ("+(string) EA_Magic+")");
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
init_lang();
|
|
|
|
if(desicion>0){
|
|
step=1/MathPow(10, desicion);
|
|
}else if(desicion<0){
|
|
step=MathPow(10, MathAbs(desicion));
|
|
}else{
|
|
step=1;
|
|
}
|
|
cur_offset=d_offset;
|
|
if(_Digits==5 || _Digits==3){
|
|
if(cur_offset>0){
|
|
cur_offset*=10;
|
|
}
|
|
}
|
|
if( noOpenLongMax>0 && ObjectFind(0, prefix_graph+"_noOpenLongMax")<0 ){
|
|
ObjectCreate(0, prefix_graph+"_noOpenLongMax", OBJ_HLINE, 0, 0, maxPrice);
|
|
ObjectSetInteger(0,prefix_graph+"_noOpenLongMax",OBJPROP_COLOR,clrMagenta);
|
|
ObjectSetInteger(0,prefix_graph+"_noOpenLongMax",OBJPROP_SELECTABLE,false);
|
|
ObjectSetInteger(0,prefix_graph+"_noOpenLongMax",OBJPROP_BACK,true);
|
|
}
|
|
if( noOpenLongMin>0 && ObjectFind(0, prefix_graph+"_noOpenLongMin")<0 ){
|
|
ObjectCreate(0, prefix_graph+"_noOpenLongMin", OBJ_HLINE, 0, 0, maxPrice);
|
|
ObjectSetInteger(0,prefix_graph+"_noOpenLongMin",OBJPROP_COLOR,clrMagenta);
|
|
ObjectSetInteger(0,prefix_graph+"_noOpenLongMin",OBJPROP_SELECTABLE,false);
|
|
ObjectSetInteger(0,prefix_graph+"_noOpenLongMin",OBJPROP_BACK,true);
|
|
}
|
|
|
|
minStop=SymbolInfoDouble(_Symbol, SYMBOL_POINT)*SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
|
|
|
|
//---
|
|
|
|
//---
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
//---
|
|
ObjectsDeleteAll(0, prefix_graph);
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick()
|
|
{
|
|
if( equityLess>0 && AccountInfoDouble(ACCOUNT_BALANCE)-AccountInfoDouble(ACCOUNT_EQUITY)>= equityLess ){
|
|
closeAllPos();
|
|
}
|
|
if( equityGross>0 && GlobalVariableCheck(prefix_graph+"_equity") && AccountInfoDouble(ACCOUNT_EQUITY)-GlobalVariableGet(prefix_graph+"_equity")>= equityGross ){
|
|
closeAllPos();
|
|
}else if( checkTakeProfit()){
|
|
closeAllPos();
|
|
}
|
|
|
|
if( !pdxIsNewBar() ){
|
|
return;
|
|
}
|
|
|
|
if( GlobalVariableCheck(prefix_graph+"_equity") ){
|
|
Comment("Equity on begin: "+(string) GlobalVariableGet(prefix_graph+"_equity"));
|
|
}
|
|
|
|
#ifdef __MQL5__
|
|
LongPos=getCountOrdersForPrice(0, ORDER_TYPE_BUY);
|
|
ShortPos=getCountOrdersForPrice(0, ORDER_TYPE_SELL);
|
|
#else
|
|
LongPos=getCountOrdersForPrice(0, OP_BUY);
|
|
ShortPos=getCountOrdersForPrice(0, OP_SELL);
|
|
#endif
|
|
/*
|
|
if( LongPos > ShortPos*1.5 ){
|
|
closeProfit(MY_BUY, (int) (LongPos-ShortPos*1.3) );
|
|
}else if( ShortPos > LongPos*1.5 ){
|
|
closeProfit(MY_SELL, (int) (ShortPos-LongPos*1.3) );
|
|
}
|
|
*/
|
|
|
|
// checkTrailingStop();
|
|
getmeinfo_btn(_Symbol);
|
|
|
|
SymbolInfoTick(_Symbol, lastme);
|
|
if( lastme.bid==0 ){
|
|
return;
|
|
}
|
|
|
|
curLot=Lot;
|
|
if( doubleLot1>0 && AccountInfoDouble(ACCOUNT_BALANCE)>doubleLot1 && AccountInfoDouble(ACCOUNT_EQUITY) > doubleLot1/2 ){
|
|
curLot+=Lot;
|
|
}
|
|
if( doubleLot2>0 && AccountInfoDouble(ACCOUNT_BALANCE)>doubleLot2 && AccountInfoDouble(ACCOUNT_EQUITY) > doubleLot2/2 ){
|
|
curLot+=Lot;
|
|
}
|
|
if( doubleLot3>0 && AccountInfoDouble(ACCOUNT_BALANCE)>doubleLot3 && AccountInfoDouble(ACCOUNT_EQUITY) > doubleLot3/2 ){
|
|
curLot+=Lot;
|
|
}
|
|
|
|
if( closeAllMax>0 && lastme.bid>closeAllMax && LongVol<ShortVol ){
|
|
closeAllPos();
|
|
ExpertRemove();
|
|
}else if( closeAllMin>0 && lastme.ask<closeAllMin && LongVol>ShortVol ){
|
|
closeAllPos();
|
|
ExpertRemove();
|
|
}
|
|
|
|
noLong=false;
|
|
noShort=false;
|
|
|
|
rawPrice=getRawPrice();
|
|
maxPrice=rawPrice+step*(maxLimits+1);
|
|
minPrice=rawPrice-step*(maxLimits+1);
|
|
|
|
|
|
if( existLimits() ){
|
|
delDeadLimits();
|
|
addNewLimits();
|
|
}else{
|
|
initLimits();
|
|
}
|
|
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
double getRawPrice(){
|
|
if(desicion>=0){
|
|
return StringToDouble(DoubleToString(lastme.bid, desicion));
|
|
}else{
|
|
return StringToDouble(DoubleToString(lastme.bid/MathPow(10, MathAbs(desicion)), 0))*MathPow(10, MathAbs(desicion));
|
|
}
|
|
}
|
|
|
|
bool existLimits(){
|
|
#ifdef __MQL5__
|
|
int cntMyPos=PositionsTotal();
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(PositionGetSymbol(ti)!=_Symbol) continue;
|
|
if(EA_Magic>0 && PositionGetInteger(POSITION_MAGIC)!=EA_Magic) continue;
|
|
return true;
|
|
}
|
|
int cntMyPosO=OrdersTotal();
|
|
for(int ti=cntMyPosO-1; ti>=0; ti--){
|
|
ulong orderTicket=OrderGetTicket(ti);
|
|
if(OrderGetString(ORDER_SYMBOL)!=_Symbol) continue;
|
|
if(EA_Magic>0 && OrderGetInteger(ORDER_MAGIC)!=EA_Magic) continue;
|
|
return true;
|
|
}
|
|
#else
|
|
int cntMyPos=OrdersTotal();
|
|
if(cntMyPos>0){
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(OrderSelect(ti,SELECT_BY_POS,MODE_TRADES)==false) continue;
|
|
if(OrderSymbol()!=_Symbol) continue;
|
|
if(EA_Magic>0 && OrderMagicNumber()!=EA_Magic) continue;
|
|
return true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return false;
|
|
}
|
|
void initLimits(){
|
|
GlobalVariableSet(prefix_graph+"_equity", AccountInfoDouble(ACCOUNT_EQUITY));
|
|
|
|
double tp;
|
|
double sl;
|
|
MqlRates rates[];
|
|
|
|
bool BARS_noLong=false;
|
|
bool BARS_noShort=false;
|
|
if(BARS_enabled ){
|
|
ArraySetAsSeries(rates, true);
|
|
if( CopyRates( _Symbol, BARS_Timeframe, 0, 2, rates)==2 ){
|
|
switch(typeBar){
|
|
case BAR_1:
|
|
if( rates[1].close > rates[1].open ){
|
|
BARS_noShort=true;
|
|
}else if( rates[1].close < rates[1].open ){
|
|
BARS_noLong=true;
|
|
}else{
|
|
BARS_noShort=true;
|
|
BARS_noLong=true;
|
|
}
|
|
break;
|
|
case BAR_0:
|
|
if( rates[0].close > rates[0].open ){
|
|
BARS_noShort=true;
|
|
}else if( rates[0].close < rates[0].open ){
|
|
BARS_noLong=true;
|
|
}else{
|
|
BARS_noShort=true;
|
|
BARS_noLong=true;
|
|
}
|
|
break;
|
|
case BAR_01:
|
|
if( rates[0].close > rates[0].open && rates[1].close > rates[1].open ){
|
|
BARS_noShort=true;
|
|
}else if( rates[0].close < rates[0].open && rates[1].close < rates[1].open ){
|
|
BARS_noLong=true;
|
|
}else{
|
|
BARS_noShort=true;
|
|
BARS_noLong=true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if( BARS_type == BAR_NONE ){
|
|
if( BARS_noLong ){
|
|
noLong=true;
|
|
}
|
|
if( BARS_noShort ){
|
|
noShort=true;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
double curPrice=rawPrice;
|
|
if( lastme.bid<curPrice && curPrice-lastme.bid > minStop ){
|
|
curPrice-=step;
|
|
}
|
|
if(cur_offset>0){
|
|
curPrice+=cur_offset*SymbolInfoDouble(_Symbol, SYMBOL_POINT);
|
|
}
|
|
double curCurLot=curLot;
|
|
while(1==1){
|
|
if( !open_LONG || noLong ) break;
|
|
curPrice+=step;
|
|
if( curPrice>maxPrice ){
|
|
break;
|
|
}
|
|
if( noOpenLongMax>0 && curPrice>noOpenLongMax ){
|
|
break;
|
|
}
|
|
if( noOpenLongMin>0 && curPrice<noOpenLongMin ){
|
|
continue;
|
|
}
|
|
if( curPrice-lastme.ask < minStop ) continue;
|
|
tp=0;
|
|
sl=0;
|
|
if(typeLimit==STOP){
|
|
if(order_TP>0){
|
|
tp=curPrice+step*order_TP;
|
|
}
|
|
if(order_SL>0){
|
|
sl=curPrice-step*order_SL;
|
|
}
|
|
if( BARS_type == BAR_MIN && BARS_noLong ){
|
|
tp = curPrice+step*order_TP;
|
|
}
|
|
if(!pdxSendOrder(MY_BUYSTOP, curPrice, sl, tp, curCurLot, 0, "", _Symbol)){
|
|
}
|
|
}else{
|
|
if(order_TP>0){
|
|
tp=curPrice-step*order_TP;
|
|
}
|
|
if(order_SL>0){
|
|
sl=curPrice+step*order_SL;
|
|
}
|
|
if( BARS_type == BAR_MIN && BARS_noLong ){
|
|
tp = curPrice-step*order_TP;
|
|
}
|
|
if(!pdxSendOrder(MY_SELLLIMIT, curPrice, sl, tp, curCurLot, 0, "", _Symbol)){
|
|
}
|
|
}
|
|
switch(typeLot){
|
|
case MY_ARIFMET:
|
|
curCurLot+=curLot;
|
|
break;
|
|
case MY_GEOMET:
|
|
curCurLot*=2;
|
|
break;
|
|
}
|
|
}
|
|
curPrice=rawPrice;
|
|
if( lastme.bid>curPrice && lastme.bid-curPrice > minStop ){
|
|
curPrice+=step;
|
|
}
|
|
if(cur_offset>0){
|
|
curPrice-=cur_offset*SymbolInfoDouble(_Symbol, SYMBOL_POINT);
|
|
}
|
|
curCurLot=curLot;
|
|
while(1==1){
|
|
if( !open_SHORT || noShort ) break;
|
|
curPrice-=step;
|
|
if( curPrice<minPrice ){
|
|
break;
|
|
}
|
|
if( noOpenShortMax>0 && curPrice>noOpenShortMax ){
|
|
continue;
|
|
}
|
|
if( noOpenShortMin>0 && curPrice<noOpenShortMin ){
|
|
break;
|
|
}
|
|
if( lastme.bid-curPrice < minStop ) continue;
|
|
tp=0;
|
|
sl=0;
|
|
if(typeLimit==STOP){
|
|
if(order_TP>0){
|
|
tp=curPrice-step*order_TP;
|
|
}
|
|
if(order_SL>0){
|
|
sl=curPrice+step*order_SL;
|
|
}
|
|
if( BARS_type == BAR_MIN && BARS_noShort ){
|
|
tp = curPrice-step*order_TP;
|
|
}
|
|
if(!pdxSendOrder(MY_SELLSTOP, curPrice, sl, tp, curCurLot, 0, "", _Symbol)){
|
|
}
|
|
}else{
|
|
if(order_TP>0){
|
|
tp=curPrice+step*order_TP;
|
|
}
|
|
if(order_SL>0){
|
|
sl=curPrice-step*order_SL;
|
|
}
|
|
if( BARS_type == BAR_MIN && BARS_noShort ){
|
|
tp = curPrice+step*order_TP;
|
|
}
|
|
if(!pdxSendOrder(MY_BUYLIMIT, curPrice, sl, tp, curCurLot, 0, "", _Symbol)){
|
|
}
|
|
}
|
|
switch(typeLot){
|
|
case MY_ARIFMET:
|
|
curCurLot+=curLot;
|
|
break;
|
|
case MY_GEOMET:
|
|
curCurLot*=2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void delDeadLimits(){
|
|
LongLimit=0;
|
|
ShortLimit=0;
|
|
|
|
#ifdef __MQL5__
|
|
int cntMyPosO=OrdersTotal();
|
|
for(int ti=cntMyPosO-1; ti>=0; ti--){
|
|
ulong orderTicket=OrderGetTicket(ti);
|
|
if(OrderGetString(ORDER_SYMBOL)!=_Symbol) continue;
|
|
if(EA_Magic>0 && OrderGetInteger(ORDER_MAGIC)!=EA_Magic) continue;
|
|
|
|
if( OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_STOP && OrderGetDouble(ORDER_PRICE_OPEN)>maxPrice ){
|
|
Trade.OrderDelete(orderTicket);
|
|
continue;
|
|
}else if( OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_STOP && OrderGetDouble(ORDER_PRICE_OPEN)<minPrice ){
|
|
Trade.OrderDelete(orderTicket);
|
|
continue;
|
|
}else if( OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_STOP && OrderGetDouble(ORDER_PRICE_OPEN)<lastme.bid ){
|
|
Trade.OrderDelete(orderTicket);
|
|
continue;
|
|
}else if( OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_STOP && OrderGetDouble(ORDER_PRICE_OPEN)>lastme.bid ){
|
|
Trade.OrderDelete(orderTicket);
|
|
continue;
|
|
}else if( OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_LIMIT && OrderGetDouble(ORDER_PRICE_OPEN)<minPrice ){
|
|
Trade.OrderDelete(orderTicket);
|
|
continue;
|
|
}else if( OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_LIMIT && OrderGetDouble(ORDER_PRICE_OPEN)>maxPrice ){
|
|
Trade.OrderDelete(orderTicket);
|
|
continue;
|
|
}else if( OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_LIMIT && OrderGetDouble(ORDER_PRICE_OPEN)>lastme.bid ){
|
|
Trade.OrderDelete(orderTicket);
|
|
continue;
|
|
}else if( OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_LIMIT && OrderGetDouble(ORDER_PRICE_OPEN)<lastme.bid ){
|
|
Trade.OrderDelete(orderTicket);
|
|
continue;
|
|
}
|
|
|
|
if( OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_STOP ){
|
|
LongLimit++;
|
|
}else if(OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_STOP){
|
|
ShortLimit++;
|
|
}else if( OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_LIMIT ){
|
|
LongLimit++;
|
|
}else if(OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_LIMIT){
|
|
ShortLimit++;
|
|
}
|
|
|
|
}
|
|
#else
|
|
int cntMyPos=OrdersTotal();
|
|
if(cntMyPos>0){
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(OrderSelect(ti,SELECT_BY_POS,MODE_TRADES)==false) continue;
|
|
if(OrderSymbol()!=_Symbol) continue;
|
|
if(EA_Magic>0 && OrderMagicNumber()!=EA_Magic) continue;
|
|
if( OrderType()==OP_BUY || OrderType()==OP_SELL ){ continue; }
|
|
|
|
if( OrderType()==OP_BUYSTOP && OrderOpenPrice()>maxPrice ){
|
|
if(OrderDelete(OrderTicket())){
|
|
continue;
|
|
}
|
|
}else if( OrderType()==OP_SELLSTOP && OrderOpenPrice()<minPrice ){
|
|
if(OrderDelete(OrderTicket())){
|
|
continue;
|
|
}
|
|
}else if( OrderType()==OP_BUYSTOP && OrderOpenPrice()<lastme.bid ){
|
|
if(OrderDelete(OrderTicket())){
|
|
continue;
|
|
}
|
|
}else if( OrderType()==OP_SELLSTOP && OrderOpenPrice()>lastme.bid ){
|
|
if(OrderDelete(OrderTicket())){
|
|
continue;
|
|
}
|
|
}else if( OrderType()==OP_BUYLIMIT && OrderOpenPrice()<minPrice ){
|
|
if(OrderDelete(OrderTicket())){
|
|
continue;
|
|
}
|
|
}else if( OrderType()==OP_SELLLIMIT && OrderOpenPrice()>maxPrice ){
|
|
if(OrderDelete(OrderTicket())){
|
|
continue;
|
|
}
|
|
}else if( OrderType()==OP_BUYLIMIT && OrderOpenPrice()>lastme.bid ){
|
|
if(OrderDelete(OrderTicket())){
|
|
continue;
|
|
}
|
|
}else if( OrderType()==OP_SELLLIMIT && OrderOpenPrice()<lastme.bid ){
|
|
if(OrderDelete(OrderTicket())){
|
|
continue;
|
|
}
|
|
}
|
|
if(OrderType()==OP_BUYSTOP){
|
|
LongLimit++;
|
|
}else if(OrderType()==OP_SELLSTOP){
|
|
ShortLimit++;
|
|
}else if(OrderType()==OP_BUYLIMIT){
|
|
LongLimit++;
|
|
}else if(OrderType()==OP_SELLLIMIT){
|
|
ShortLimit++;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
#ifdef __MQL5__
|
|
int getCountOrdersForPrice(double price, ENUM_ORDER_TYPE type){
|
|
int count=0;
|
|
int cntMyPos=PositionsTotal();
|
|
|
|
MqlTick latest_price;
|
|
SymbolInfoTick(_Symbol,latest_price);
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(PositionGetSymbol(ti)!=_Symbol) continue;
|
|
if(EA_Magic>0 && PositionGetInteger(POSITION_MAGIC)!=EA_Magic) continue;
|
|
if( PositionGetInteger(POSITION_TYPE)!=type ) continue;
|
|
if(price>0){
|
|
if( PositionGetDouble(POSITION_PRICE_OPEN) < price-(step/3) ) continue;
|
|
if( PositionGetDouble(POSITION_PRICE_OPEN) > price+(step/3) ) continue;
|
|
}
|
|
|
|
if( trailing1NumStepsStart>1 && trailing1NumStepsSave>0 && PositionGetDouble(POSITION_SL)==0 ){
|
|
double tp;
|
|
if( PositionGetInteger(POSITION_TYPE)==ORDER_TYPE_BUY ){
|
|
if( latest_price.bid-PositionGetDouble(POSITION_PRICE_OPEN) > step*trailing1NumStepsStart ){
|
|
tp = PositionGetDouble(POSITION_TP);
|
|
if(tp>0){
|
|
tp+=step*trailing1NumStepsTP;
|
|
}
|
|
if( pdxSendOrder(MY_BUYSLTP, PositionGetDouble(POSITION_PRICE_OPEN), NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN)+step*trailing1NumStepsSave, _Digits), tp, PositionGetDouble(POSITION_VOLUME), PositionGetInteger(POSITION_TICKET), PositionGetString(POSITION_COMMENT), PositionGetString(POSITION_SYMBOL))){ }
|
|
}
|
|
}else{
|
|
if( PositionGetDouble(POSITION_PRICE_OPEN)-latest_price.ask > step*trailing1NumStepsStart ){
|
|
tp = PositionGetDouble(POSITION_TP);
|
|
if(tp>0){
|
|
tp-=step*trailing1NumStepsTP;
|
|
}
|
|
if( pdxSendOrder(MY_SELLSLTP, PositionGetDouble(POSITION_PRICE_OPEN), NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN)-step*trailing1NumStepsSave, _Digits), tp, PositionGetDouble(POSITION_VOLUME), PositionGetInteger(POSITION_TICKET), PositionGetString(POSITION_COMMENT), PositionGetString(POSITION_SYMBOL))){ }
|
|
}
|
|
}
|
|
}
|
|
if( trailing2NumStepsStart>1 && trailing2NumStepsSave>0 && PositionGetDouble(POSITION_SL)>0 ){
|
|
double tp;
|
|
if( PositionGetInteger(POSITION_TYPE)==ORDER_TYPE_BUY ){
|
|
if( PositionGetDouble(POSITION_SL)>PositionGetDouble(POSITION_PRICE_OPEN) && latest_price.bid-PositionGetDouble(POSITION_PRICE_OPEN) > step*trailing2NumStepsStart ){
|
|
tp = PositionGetDouble(POSITION_TP);
|
|
if(tp>0){
|
|
tp+=step*trailing2NumStepsTP;
|
|
}
|
|
if( pdxSendOrder(MY_BUYSLTP, PositionGetDouble(POSITION_PRICE_OPEN), NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN)+step*trailing2NumStepsSave, _Digits), tp, PositionGetDouble(POSITION_VOLUME), PositionGetInteger(POSITION_TICKET), PositionGetString(POSITION_COMMENT), PositionGetString(POSITION_SYMBOL))){ }
|
|
}
|
|
}else{
|
|
if( PositionGetDouble(POSITION_SL)<PositionGetDouble(POSITION_PRICE_OPEN) && PositionGetDouble(POSITION_PRICE_OPEN)-latest_price.ask > step*trailing2NumStepsStart ){
|
|
tp = PositionGetDouble(POSITION_TP);
|
|
if(tp>0){
|
|
tp-=step*trailing2NumStepsTP;
|
|
}
|
|
if( pdxSendOrder(MY_SELLSLTP, PositionGetDouble(POSITION_PRICE_OPEN), NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN)-step*trailing2NumStepsSave, _Digits), tp, PositionGetDouble(POSITION_VOLUME), PositionGetInteger(POSITION_TICKET), PositionGetString(POSITION_COMMENT), PositionGetString(POSITION_SYMBOL))){ }
|
|
}
|
|
}
|
|
}
|
|
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
#else
|
|
int getCountOrdersForPrice(double price, int type){
|
|
int count=0;
|
|
int cntMyPos=OrdersTotal();
|
|
if(cntMyPos>0){
|
|
MqlTick latest_price;
|
|
SymbolInfoTick(_Symbol,latest_price);
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(OrderSelect(ti,SELECT_BY_POS,MODE_TRADES)==false) continue;
|
|
if( OrderType()==OP_BUY || OrderType()==OP_SELL ){ }else{ continue; }
|
|
if(OrderSymbol()!=_Symbol) continue;
|
|
if(EA_Magic>0 && OrderMagicNumber()!=EA_Magic) continue;
|
|
if(OrderType()!=type) continue;
|
|
|
|
if( trailing1NumStepsStart>1 && trailing1NumStepsSave>0 && OrderStopLoss()==0 ){
|
|
double tp;
|
|
if( OrderType()==OP_BUY ){
|
|
if( latest_price.bid-OrderOpenPrice() > step*trailing1NumStepsStart ){
|
|
tp = OrderTakeProfit();
|
|
if(tp>0){
|
|
tp+=step*trailing1NumStepsTP;
|
|
}
|
|
if( OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(OrderOpenPrice()+step*trailing1NumStepsSave, _Digits),tp,0) ){}
|
|
}
|
|
}else{
|
|
if( OrderOpenPrice()-latest_price.ask > step*trailing1NumStepsStart ){
|
|
tp = OrderTakeProfit();
|
|
if(tp>0){
|
|
tp-=step*trailing1NumStepsTP;
|
|
}
|
|
if( OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(OrderOpenPrice()-step*trailing1NumStepsSave, _Digits),tp,0) ){}
|
|
}
|
|
}
|
|
}
|
|
if( trailing2NumStepsStart>1 && trailing2NumStepsSave>0 && OrderStopLoss()>0 ){
|
|
double tp;
|
|
if( OrderType()==OP_BUY ){
|
|
if( OrderStopLoss()>OrderOpenPrice() && latest_price.bid-OrderOpenPrice() > step*trailing2NumStepsStart ){
|
|
tp = OrderTakeProfit();
|
|
if(tp>0){
|
|
tp+=step*trailing2NumStepsTP;
|
|
}
|
|
if( OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(OrderOpenPrice()+step*trailing2NumStepsSave, _Digits),tp,0) ){}
|
|
}
|
|
}else{
|
|
if( OrderStopLoss()<OrderOpenPrice() && OrderOpenPrice()-latest_price.ask > step*trailing2NumStepsStart ){
|
|
tp = OrderTakeProfit();
|
|
if(tp>0){
|
|
tp-=step*trailing2NumStepsTP;
|
|
}
|
|
if( OrderModify(OrderTicket(),OrderOpenPrice(),NormalizeDouble(OrderOpenPrice()-step*trailing2NumStepsSave, _Digits),tp,0) ){}
|
|
}
|
|
}
|
|
}
|
|
if(price>0){
|
|
if( OrderOpenPrice() < price-(step/3) ) continue;
|
|
if( OrderOpenPrice() > price+(step/3) ) continue;
|
|
}
|
|
|
|
count++;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
#endif
|
|
void addNewLimits(){
|
|
if(AccountInfoDouble(ACCOUNT_BALANCE) < 1) return;
|
|
|
|
MqlDateTime curT;
|
|
TimeToStruct(Old_Time, curT);
|
|
|
|
MqlRates rates[];
|
|
double tp;
|
|
double sl;
|
|
|
|
int lotMult=1;
|
|
double rangeMax=0;
|
|
double rangeMin=0;
|
|
bool isSmallRange=false;
|
|
|
|
bool BARS_noLong=false;
|
|
bool BARS_noShort=false;
|
|
if(BARS_enabled ){
|
|
ArraySetAsSeries(rates, true);
|
|
if( CopyRates( _Symbol, BARS_Timeframe, 0, 3, rates)==3 ){
|
|
switch(typeBar){
|
|
case BAR_1:
|
|
if( rates[1].close > rates[1].open ){
|
|
BARS_noShort=true;
|
|
}else if( rates[1].close < rates[1].open ){
|
|
BARS_noLong=true;
|
|
}else{
|
|
BARS_noShort=true;
|
|
BARS_noLong=true;
|
|
}
|
|
break;
|
|
case BAR_0:
|
|
if( rates[0].close > rates[0].open ){
|
|
BARS_noShort=true;
|
|
}else if( rates[0].close < rates[0].open ){
|
|
BARS_noLong=true;
|
|
}else{
|
|
BARS_noShort=true;
|
|
BARS_noLong=true;
|
|
}
|
|
break;
|
|
case BAR_01:
|
|
if( rates[0].close > rates[0].open && rates[1].close > rates[1].open ){
|
|
BARS_noShort=true;
|
|
}else if( rates[0].close < rates[0].open && rates[1].close < rates[1].open ){
|
|
BARS_noLong=true;
|
|
}else{
|
|
BARS_noShort=true;
|
|
BARS_noLong=true;
|
|
}
|
|
break;
|
|
}
|
|
if( rangeMax==0 || rangeMax<rates[0].high ){
|
|
rangeMax=rates[0].high;
|
|
}
|
|
if( rangeMax==0 || rangeMax<rates[1].high ){
|
|
rangeMax=rates[1].high;
|
|
}
|
|
if( rangeMin==0 || rangeMin>rates[0].low ){
|
|
rangeMin=rates[0].low;
|
|
}
|
|
if( rangeMin==0 || rangeMin>rates[1].low ){
|
|
rangeMin=rates[1].low;
|
|
}
|
|
|
|
}
|
|
if( BARS_type == BAR_NONE ){
|
|
if( BARS_noLong ){
|
|
noLong=true;
|
|
}
|
|
if( BARS_noShort ){
|
|
noShort=true;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
double curPrice=rawPrice;
|
|
if(cur_offset>0){
|
|
curPrice+=cur_offset*SymbolInfoDouble(_Symbol, SYMBOL_POINT);
|
|
}
|
|
int count;
|
|
if(LongLimit<maxLimits && open_LONG && !noLong ){
|
|
double curCurLot=curLot;
|
|
curCurLot*=lotMult;
|
|
if( noOpenFirstLine ){
|
|
curPrice+=step;
|
|
}
|
|
while(1==1){
|
|
curPrice+=step;
|
|
if( curPrice>maxPrice ){
|
|
break;
|
|
}
|
|
if( isSmallRange && curPrice<rangeMax ){
|
|
continue;
|
|
}
|
|
if( noOpenLongMax>0 && curPrice>noOpenLongMax ){
|
|
break;
|
|
}
|
|
if( noOpenLongMin>0 && curPrice<noOpenLongMin ){
|
|
continue;
|
|
}
|
|
bool isCheckLimit=false;
|
|
if(typeLimit==STOP){
|
|
#ifdef __MQL5__
|
|
isCheckLimit=checkLimitOnPrice(curPrice, ORDER_TYPE_BUY_STOP);
|
|
#else
|
|
isCheckLimit=checkLimitOnPrice(curPrice, OP_BUYSTOP);
|
|
#endif
|
|
}else{
|
|
#ifdef __MQL5__
|
|
isCheckLimit=checkLimitOnPrice(curPrice, ORDER_TYPE_SELL_LIMIT);
|
|
#else
|
|
isCheckLimit=checkLimitOnPrice(curPrice, OP_SELLLIMIT);
|
|
#endif
|
|
}
|
|
if(isCheckLimit) break;
|
|
|
|
if(typeLimit==STOP){
|
|
#ifdef __MQL5__
|
|
if( maxAll>0 && getCountOrdersForPrice(0, ORDER_TYPE_BUY)<=maxAll ){
|
|
count=getCountOrdersForPrice(curPrice, ORDER_TYPE_BUY);
|
|
#else
|
|
if( maxAll>0 && getCountOrdersForPrice(0, OP_BUY)<=maxAll ){
|
|
count=getCountOrdersForPrice(curPrice, OP_BUY);
|
|
#endif
|
|
if( count<=maxOnPrice ){
|
|
tp=0;
|
|
sl=0;
|
|
if(typeLimit==STOP){
|
|
if(order_TP>0){
|
|
tp=curPrice+step*order_TP;
|
|
}
|
|
if(order_SL>0){
|
|
sl=curPrice-step*order_SL;
|
|
}
|
|
if( BARS_type == BAR_MIN && BARS_noLong ){
|
|
tp = curPrice+step*order_TP;
|
|
}
|
|
if(pdxSendOrder(MY_BUYSTOP, curPrice, sl, tp, curCurLot, 0, "", _Symbol)){
|
|
LongLimit++;
|
|
}
|
|
}else{
|
|
if(order_TP>0){
|
|
tp=curPrice-step*order_TP;
|
|
}
|
|
if(order_SL>0){
|
|
sl=curPrice+step*order_SL;
|
|
}
|
|
if( BARS_type == BAR_MIN && BARS_noLong ){
|
|
tp = curPrice-step*order_TP;
|
|
}
|
|
if(pdxSendOrder(MY_SELLLIMIT, curPrice, sl, tp, curCurLot, 0, "", _Symbol)){
|
|
ShortLimit++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}else{
|
|
#ifdef __MQL5__
|
|
if( maxAll>0 && getCountOrdersForPrice(0, ORDER_TYPE_SELL)<=maxAll ){
|
|
count=getCountOrdersForPrice(curPrice, ORDER_TYPE_SELL);
|
|
#else
|
|
if( maxAll>0 && getCountOrdersForPrice(0, OP_SELL)<=maxAll ){
|
|
count=getCountOrdersForPrice(curPrice, OP_SELL);
|
|
#endif
|
|
if( count<=maxOnPrice ){
|
|
tp=0;
|
|
sl=0;
|
|
if(typeLimit==STOP){
|
|
if(order_TP>0){
|
|
tp=curPrice+step*order_TP;
|
|
}
|
|
if(order_SL>0){
|
|
sl=curPrice-step*order_SL;
|
|
}
|
|
if( BARS_type == BAR_MIN && BARS_noLong ){
|
|
tp = curPrice+step*order_TP;
|
|
}
|
|
if(pdxSendOrder(MY_BUYSTOP, curPrice, sl, tp, curCurLot, 0, "", _Symbol)){
|
|
LongLimit++;
|
|
}
|
|
}else{
|
|
if(order_TP>0){
|
|
tp=curPrice-step*order_TP;
|
|
}
|
|
if(order_SL>0){
|
|
sl=curPrice+step*order_SL;
|
|
}
|
|
if( BARS_type == BAR_MIN && BARS_noLong ){
|
|
tp = curPrice-step*order_TP;
|
|
}
|
|
if(pdxSendOrder(MY_SELLLIMIT, curPrice, sl, tp, curCurLot, 0, "", _Symbol)){
|
|
ShortLimit++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
if(LongLimit>=maxLimits){
|
|
break;
|
|
}
|
|
switch(typeLot){
|
|
case MY_ARIFMET:
|
|
curCurLot+=curLot;
|
|
break;
|
|
case MY_GEOMET:
|
|
curCurLot*=2;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
if(ShortLimit<maxLimits && open_SHORT && !noShort ){
|
|
curPrice=rawPrice;
|
|
if(cur_offset<0){
|
|
curPrice-=cur_offset*SymbolInfoDouble(_Symbol, SYMBOL_POINT);
|
|
}
|
|
double curCurLot=curLot;
|
|
curCurLot*=lotMult;
|
|
if( noOpenFirstLine ){
|
|
curPrice-=step;
|
|
}
|
|
while(1==1){
|
|
curPrice-=step;
|
|
if( curPrice<minPrice ){
|
|
break;
|
|
}
|
|
if( isSmallRange && curPrice>rangeMin ){
|
|
continue;
|
|
}
|
|
if( noOpenShortMax>0 && curPrice>noOpenShortMax ){
|
|
break;
|
|
}
|
|
if( noOpenShortMin>0 && curPrice<noOpenShortMin ){
|
|
continue;
|
|
}
|
|
|
|
bool isCheckLimit=false;
|
|
if(typeLimit==STOP){
|
|
#ifdef __MQL5__
|
|
isCheckLimit=checkLimitOnPrice(curPrice, ORDER_TYPE_SELL_STOP);
|
|
#else
|
|
isCheckLimit=checkLimitOnPrice(curPrice, OP_SELLSTOP);
|
|
#endif
|
|
}else{
|
|
#ifdef __MQL5__
|
|
isCheckLimit=checkLimitOnPrice(curPrice, ORDER_TYPE_BUY_LIMIT);
|
|
#else
|
|
isCheckLimit=checkLimitOnPrice(curPrice, OP_BUYLIMIT);
|
|
#endif
|
|
}
|
|
if(isCheckLimit) break;
|
|
if(typeLimit==STOP){
|
|
#ifdef __MQL5__
|
|
if( maxAll>0 && getCountOrdersForPrice(0, ORDER_TYPE_SELL)<=maxAll ){
|
|
count=getCountOrdersForPrice(curPrice, ORDER_TYPE_SELL);
|
|
#else
|
|
if( maxAll>0 && getCountOrdersForPrice(0, OP_SELL)<=maxAll ){
|
|
count=getCountOrdersForPrice(curPrice, OP_SELL);
|
|
#endif
|
|
if( count<=maxOnPrice ){
|
|
tp=0;
|
|
sl=0;
|
|
if(order_TP>0){
|
|
tp=curPrice-step*order_TP;
|
|
}
|
|
if(order_SL>0){
|
|
sl=curPrice+step*order_SL;
|
|
}
|
|
if( BARS_type == BAR_MIN && BARS_noShort ){
|
|
tp = curPrice-step*order_TP;
|
|
}
|
|
if(typeLimit==STOP){
|
|
if(pdxSendOrder(MY_SELLSTOP, curPrice, sl, tp, curCurLot, 0, "", _Symbol)){
|
|
ShortLimit++;
|
|
}
|
|
}else{
|
|
if(pdxSendOrder(MY_BUYLIMIT, curPrice, 0, 0, curCurLot, 0, "", _Symbol)){
|
|
ShortLimit++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}else{
|
|
#ifdef __MQL5__
|
|
if( maxAll>0 && getCountOrdersForPrice(0, ORDER_TYPE_BUY)<=maxAll ){
|
|
count=getCountOrdersForPrice(curPrice, ORDER_TYPE_BUY);
|
|
#else
|
|
if( maxAll>0 && getCountOrdersForPrice(0, OP_BUY)<=maxAll ){
|
|
count=getCountOrdersForPrice(curPrice, OP_BUY);
|
|
#endif
|
|
if( count<=maxOnPrice ){
|
|
tp=0;
|
|
sl=0;
|
|
if(order_TP>0){
|
|
tp=curPrice-step*order_TP;
|
|
}
|
|
if(order_SL>0){
|
|
sl=curPrice+step*order_SL;
|
|
}
|
|
if( BARS_type == BAR_MIN && BARS_noShort ){
|
|
tp = curPrice-step*order_TP;
|
|
}
|
|
if(typeLimit==STOP){
|
|
if(pdxSendOrder(MY_SELLSTOP, curPrice, sl, tp, curCurLot, 0, "", _Symbol)){
|
|
ShortLimit++;
|
|
}
|
|
}else{
|
|
if(pdxSendOrder(MY_BUYLIMIT, curPrice, 0, 0, curCurLot, 0, "", _Symbol)){
|
|
ShortLimit++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(ShortLimit>=maxLimits){
|
|
break;
|
|
}
|
|
switch(typeLot){
|
|
case MY_ARIFMET:
|
|
curCurLot+=curLot;
|
|
break;
|
|
case MY_GEOMET:
|
|
curCurLot*=2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#ifdef __MQL5__
|
|
bool checkLimitOnPrice(double price, ENUM_ORDER_TYPE type){
|
|
int cntMyPosO=OrdersTotal();
|
|
for(int ti=cntMyPosO-1; ti>=0; ti--){
|
|
ulong orderTicket=OrderGetTicket(ti);
|
|
if(OrderGetString(ORDER_SYMBOL)!=_Symbol) continue;
|
|
if(EA_Magic>0 && OrderGetInteger(ORDER_MAGIC)!=EA_Magic) continue;
|
|
if( OrderGetInteger(ORDER_TYPE)!=type ) continue;
|
|
|
|
if( OrderGetDouble(ORDER_PRICE_OPEN) < price-(step/3) ) continue;
|
|
if( OrderGetDouble(ORDER_PRICE_OPEN) > price+(step/3) ) continue;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
#else
|
|
bool checkLimitOnPrice(double price, int type){
|
|
int cntMyPos=OrdersTotal();
|
|
if(cntMyPos>0){
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(OrderSelect(ti,SELECT_BY_POS,MODE_TRADES)==false) continue;
|
|
if(OrderSymbol()!=_Symbol) continue;
|
|
if(EA_Magic>0 && OrderMagicNumber()!=EA_Magic) continue;
|
|
if(OrderType()!=type) continue;
|
|
|
|
if( OrderOpenPrice() < price-(step/3) ) continue;
|
|
if( OrderOpenPrice() > price+(step/3) ) continue;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
bool pdxIsNewBar(){
|
|
datetime New_Time[1];
|
|
|
|
if(CopyTime(_Symbol,_Period,0,1,New_Time)>0){
|
|
if(Old_Time!=New_Time[0]){
|
|
Old_Time=New_Time[0];
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
void checkTrailingStop(){
|
|
#ifdef __MQL5__
|
|
#else
|
|
int cntMyPos=OrdersTotal();
|
|
if(cntMyPos>0){
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(OrderSelect(ti,SELECT_BY_POS,MODE_TRADES)==false) continue;
|
|
if( OrderType()==OP_BUY || OrderType()==OP_SELL ){}else{ continue; }
|
|
if(OrderSymbol()!=_Symbol) continue;
|
|
if(EA_Magic>0 && OrderMagicNumber()!=EA_Magic) continue;
|
|
|
|
double profit=0;
|
|
profit+=OrderCommission();
|
|
profit+=OrderProfit();
|
|
profit+=OrderSwap();
|
|
|
|
if(profit>40 ){
|
|
MqlTick latest_price;
|
|
SymbolInfoTick(OrderSymbol(),latest_price);
|
|
|
|
if( latest_price.bid>OrderOpenPrice() ){
|
|
double newStop=NormalizeDouble(OrderOpenPrice()+((profit-30)*SymbolInfoDouble(_Symbol, SYMBOL_POINT)), _Digits);
|
|
if(newStop>OrderStopLoss()){
|
|
if( !OrderModify(OrderTicket(), OrderOpenPrice(), newStop, OrderTakeProfit(), 0 ) ){ ExpertRemove(); }
|
|
}
|
|
}else{
|
|
double newStop=NormalizeDouble(OrderOpenPrice()-((profit-30)*SymbolInfoDouble(_Symbol, SYMBOL_POINT)), _Digits);
|
|
if(newStop<OrderStopLoss()){
|
|
if( !OrderModify(OrderTicket(), OrderOpenPrice(), newStop, OrderTakeProfit(), 0 ) ){ ExpertRemove(); }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
bool checkTakeProfit(){
|
|
if( takeProfit<=0 ) return false;
|
|
double curProfit=0;
|
|
double profit=0;
|
|
|
|
#ifdef __MQL5__
|
|
int cntMyPos=PositionsTotal();
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(PositionGetSymbol(ti)!=_Symbol) continue;
|
|
if(EA_Magic>0 && PositionGetInteger(POSITION_MAGIC)!=EA_Magic) continue;
|
|
|
|
profit+=PositionGetDouble(POSITION_PROFIT);
|
|
profit+=PositionGetDouble(POSITION_SWAP);
|
|
}
|
|
#else
|
|
int cntMyPos=OrdersTotal();
|
|
if(cntMyPos>0){
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(OrderSelect(ti,SELECT_BY_POS,MODE_TRADES)==false) continue;
|
|
if( OrderType()==OP_BUY || OrderType()==OP_SELL ){}else{ continue; }
|
|
if(OrderSymbol()!=_Symbol) continue;
|
|
if(EA_Magic>0 && OrderMagicNumber()!=EA_Magic) continue;
|
|
|
|
profit+=OrderCommission();
|
|
profit+=OrderProfit();
|
|
profit+=OrderSwap();
|
|
}
|
|
}
|
|
#endif
|
|
if(profit>takeProfit){
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void closeByPos(){
|
|
bool repeatOpen=false;
|
|
#ifdef __MQL5__
|
|
int cntMyPos=PositionsTotal();
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(PositionGetSymbol(ti)!=_Symbol) continue;
|
|
if(EA_Magic>0 && PositionGetInteger(POSITION_MAGIC)!=EA_Magic) continue;
|
|
|
|
if( PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY ){
|
|
long closefirst=PositionGetInteger(POSITION_TICKET);
|
|
double closeLots=PositionGetDouble(POSITION_VOLUME);
|
|
|
|
for(int ti2=cntMyPos-1; ti2>=0; ti2--){
|
|
if(PositionGetSymbol(ti2)!=_Symbol) continue;
|
|
if(EA_Magic>0 && PositionGetInteger(POSITION_MAGIC)!=EA_Magic) continue;
|
|
if( PositionGetInteger(POSITION_TYPE)!=POSITION_TYPE_SELL ) continue;
|
|
if( PositionGetDouble(POSITION_VOLUME)!=closeLots ) continue;
|
|
|
|
MqlTradeRequest request;
|
|
MqlTradeResult result;
|
|
ZeroMemory(request);
|
|
ZeroMemory(result);
|
|
request.action=TRADE_ACTION_CLOSE_BY;
|
|
request.position=closefirst;
|
|
request.position_by=PositionGetInteger(POSITION_TICKET);
|
|
if(EA_Magic>0) request.magic=EA_Magic;
|
|
if(OrderSend(request,result)){
|
|
repeatOpen=true;
|
|
break;
|
|
}
|
|
}
|
|
if(repeatOpen){
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
int cntMyPos=OrdersTotal();
|
|
if(cntMyPos>0){
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(OrderSelect(ti,SELECT_BY_POS,MODE_TRADES)==false) continue;
|
|
if( OrderSymbol()!=_Symbol ) continue;
|
|
if(EA_Magic>0 && OrderMagicNumber()!=EA_Magic) continue;
|
|
|
|
if( OrderType()==OP_BUY ){
|
|
int closefirst=OrderTicket();
|
|
double closeLots=OrderLots();
|
|
|
|
for(int ti2=cntMyPos-1; ti2>=0; ti2--){
|
|
if(OrderSelect(ti2,SELECT_BY_POS,MODE_TRADES)==false) continue;
|
|
if( OrderSymbol()!=_Symbol ) continue;
|
|
if(EA_Magic>0 && OrderMagicNumber()!=EA_Magic) continue;
|
|
if( OrderType()!=OP_SELL ) continue;
|
|
if( OrderLots()<closeLots ) continue;
|
|
|
|
if( OrderCloseBy(closefirst, OrderTicket()) ){
|
|
repeatOpen=true;
|
|
break;
|
|
}
|
|
}
|
|
if(repeatOpen){
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
#endif
|
|
// if we closed a position by an opposite one,
|
|
// launch the closeByPos function again
|
|
if(repeatOpen){
|
|
closeByPos();
|
|
}
|
|
}
|
|
void closeAllPos(){
|
|
closeByPos();
|
|
#ifdef __MQL5__
|
|
int cntMyPos=PositionsTotal();
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(PositionGetSymbol(ti)!=_Symbol) continue;
|
|
if(EA_Magic>0 && PositionGetInteger(POSITION_MAGIC)!=EA_Magic) continue;
|
|
|
|
Trade.PositionClose(PositionGetInteger(POSITION_TICKET));
|
|
}
|
|
int cntMyPosO=OrdersTotal();
|
|
for(int ti=cntMyPosO-1; ti>=0; ti--){
|
|
ulong orderTicket=OrderGetTicket(ti);
|
|
if(OrderGetString(ORDER_SYMBOL)!=_Symbol) continue;
|
|
if(EA_Magic>0 && OrderGetInteger(ORDER_MAGIC)!=EA_Magic) continue;
|
|
|
|
Trade.OrderDelete(orderTicket);
|
|
}
|
|
#else
|
|
int cntMyPos=OrdersTotal();
|
|
if(cntMyPos>0){
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(OrderSelect(ti,SELECT_BY_POS,MODE_TRADES)==false) continue;
|
|
if( OrderSymbol()!=_Symbol ) continue;
|
|
if(EA_Magic>0 && OrderMagicNumber()!=EA_Magic) continue;
|
|
|
|
if( OrderType()==OP_BUY ){
|
|
MqlTick latest_price;
|
|
if(!SymbolInfoTick(OrderSymbol(),latest_price)){
|
|
Alert(GetLastError());
|
|
return;
|
|
}
|
|
if(!OrderClose(OrderTicket(), OrderLots(),latest_price.bid,100)){
|
|
}
|
|
}else if(OrderType()==OP_SELL){
|
|
MqlTick latest_price;
|
|
if(!SymbolInfoTick(OrderSymbol(),latest_price)){
|
|
Alert(GetLastError());
|
|
return;
|
|
}
|
|
if(!OrderClose(OrderTicket(), OrderLots(),latest_price.ask,100)){
|
|
}
|
|
}else{
|
|
if(!OrderDelete(OrderTicket())){
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
#endif
|
|
// remove the position closing button
|
|
if(ObjectFind(0, prefix_graph+"delall")>0){
|
|
ObjectDelete(0, prefix_graph+"delall");
|
|
}
|
|
|
|
}
|
|
bool pdxSendOrder(TypeOfPos mytype, double price, double sl, double tp, double volume, ulong position=0, string comment="", string sym=""){
|
|
if( !StringLen(sym) ){
|
|
sym=_Symbol;
|
|
}
|
|
int curDigits=(int) SymbolInfoInteger(sym, SYMBOL_DIGITS);
|
|
if(sl>0){
|
|
sl=NormalizeDouble(sl,curDigits);
|
|
}
|
|
if(tp>0){
|
|
tp=NormalizeDouble(tp,curDigits);
|
|
}
|
|
if(price>0){
|
|
price=NormalizeDouble(price,curDigits);
|
|
}else{
|
|
#ifdef __MQL5__
|
|
#else
|
|
MqlTick latest_price;
|
|
SymbolInfoTick(sym,latest_price);
|
|
if( mytype == MY_SELL ){
|
|
price=latest_price.ask;
|
|
}else if( mytype == MY_BUY ){
|
|
price=latest_price.bid;
|
|
}
|
|
#endif
|
|
}
|
|
if( StringLen(my_cmt) && comment=="" ){
|
|
comment=my_cmt;
|
|
}
|
|
#ifdef __MQL5__
|
|
ENUM_TRADE_REQUEST_ACTIONS action=TRADE_ACTION_DEAL;
|
|
ENUM_ORDER_TYPE type=ORDER_TYPE_BUY;
|
|
switch(mytype){
|
|
case MY_BUY:
|
|
action=TRADE_ACTION_DEAL;
|
|
type=ORDER_TYPE_BUY;
|
|
break;
|
|
case MY_BUYSLTP:
|
|
action=TRADE_ACTION_SLTP;
|
|
type=ORDER_TYPE_BUY;
|
|
break;
|
|
case MY_BUYSTOP:
|
|
action=TRADE_ACTION_PENDING;
|
|
type=ORDER_TYPE_BUY_STOP;
|
|
break;
|
|
case MY_BUYLIMIT:
|
|
action=TRADE_ACTION_PENDING;
|
|
type=ORDER_TYPE_BUY_LIMIT;
|
|
break;
|
|
case MY_SELL:
|
|
action=TRADE_ACTION_DEAL;
|
|
type=ORDER_TYPE_SELL;
|
|
break;
|
|
case MY_SELLSLTP:
|
|
action=TRADE_ACTION_SLTP;
|
|
type=ORDER_TYPE_SELL;
|
|
break;
|
|
case MY_SELLSTOP:
|
|
action=TRADE_ACTION_PENDING;
|
|
type=ORDER_TYPE_SELL_STOP;
|
|
break;
|
|
case MY_SELLLIMIT:
|
|
action=TRADE_ACTION_PENDING;
|
|
type=ORDER_TYPE_SELL_LIMIT;
|
|
break;
|
|
}
|
|
|
|
MqlTradeRequest mrequest;
|
|
MqlTradeResult mresult;
|
|
ZeroMemory(mrequest);
|
|
|
|
mrequest.action = action;
|
|
mrequest.sl = sl;
|
|
mrequest.tp = tp;
|
|
mrequest.symbol = sym;
|
|
if(position>0){
|
|
mrequest.position = position;
|
|
}
|
|
if(StringLen(comment)){
|
|
mrequest.comment=comment;
|
|
}
|
|
if(action!=TRADE_ACTION_SLTP){
|
|
if(price>0){
|
|
mrequest.price = price;
|
|
}
|
|
if(volume>0){
|
|
mrequest.volume = volume;
|
|
}
|
|
mrequest.type = type;
|
|
mrequest.magic = EA_Magic;
|
|
switch(useORDER_FILLING_RETURN){
|
|
case FOK:
|
|
mrequest.type_filling = ORDER_FILLING_FOK;
|
|
break;
|
|
case RETURN:
|
|
mrequest.type_filling = ORDER_FILLING_RETURN;
|
|
break;
|
|
case IOC:
|
|
mrequest.type_filling = ORDER_FILLING_IOC;
|
|
break;
|
|
}
|
|
mrequest.deviation=100;
|
|
}
|
|
if(OrderSend(mrequest,mresult)){
|
|
if(mresult.retcode==10009 || mresult.retcode==10008){
|
|
if(action!=TRADE_ACTION_SLTP){
|
|
switch(type){
|
|
case ORDER_TYPE_BUY:
|
|
// Alert("Order Buy #:",mresult.order," sl",sl," tp",tp," p",price," !!");
|
|
break;
|
|
case ORDER_TYPE_SELL:
|
|
// Alert("Order Sell #:",mresult.order," sl",sl," tp",tp," p",price," !!");
|
|
break;
|
|
}
|
|
}else{
|
|
// Alert("Order Modify SL #:",mresult.order," sl",sl," tp",tp," !!");
|
|
}
|
|
return true;
|
|
}else{
|
|
msgErr(GetLastError(), mresult.retcode);
|
|
}
|
|
}
|
|
#else
|
|
int type=OP_BUY;
|
|
switch(mytype){
|
|
case MY_BUY:
|
|
type=OP_BUY;
|
|
break;
|
|
case MY_BUYSTOP:
|
|
type=OP_BUYSTOP;
|
|
break;
|
|
case MY_BUYLIMIT:
|
|
type=OP_BUYLIMIT;
|
|
break;
|
|
case MY_SELL:
|
|
type=OP_SELL;
|
|
break;
|
|
case MY_SELLSTOP:
|
|
type=OP_SELLSTOP;
|
|
break;
|
|
case MY_SELLLIMIT:
|
|
type=OP_SELLLIMIT;
|
|
break;
|
|
}
|
|
|
|
if(OrderSend(sym, type, volume, price, 100, sl, tp, comment, EA_Magic, 0)<0){
|
|
msgErr(GetLastError());
|
|
}else{
|
|
switch(type){
|
|
case OP_BUY:
|
|
Alert("Order Buy sl",sl," tp",tp," p",price," !!");
|
|
break;
|
|
case OP_SELL:
|
|
Alert("Order Sell sl",sl," tp",tp," p",price," !!");
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
void msgErr(int err, int retcode=0){
|
|
string curErr="";
|
|
switch(err){
|
|
case 1:
|
|
curErr=langs.err1;
|
|
break;
|
|
case 2:
|
|
curErr=langs.err2;
|
|
break;
|
|
case 3:
|
|
curErr=langs.err3;
|
|
break;
|
|
case 4:
|
|
curErr=langs.err4;
|
|
break;
|
|
case 5:
|
|
curErr=langs.err5;
|
|
break;
|
|
case 6:
|
|
curErr=langs.err6;
|
|
break;
|
|
case 7:
|
|
curErr=langs.err7;
|
|
break;
|
|
case 8:
|
|
curErr=langs.err8;
|
|
break;
|
|
case 9:
|
|
curErr=langs.err9;
|
|
break;
|
|
case 64:
|
|
curErr=langs.err64;
|
|
break;
|
|
case 65:
|
|
curErr=langs.err65;
|
|
break;
|
|
case 128:
|
|
curErr=langs.err128;
|
|
break;
|
|
case 129:
|
|
curErr=langs.err129;
|
|
break;
|
|
case 130:
|
|
curErr=langs.err130;
|
|
break;
|
|
case 131:
|
|
curErr=langs.err131;
|
|
break;
|
|
case 132:
|
|
curErr=langs.err132;
|
|
break;
|
|
case 133:
|
|
curErr=langs.err133;
|
|
break;
|
|
case 134:
|
|
curErr=langs.err134;
|
|
break;
|
|
case 135:
|
|
curErr=langs.err135;
|
|
break;
|
|
case 136:
|
|
curErr=langs.err136;
|
|
break;
|
|
case 137:
|
|
curErr=langs.err137;
|
|
break;
|
|
case 138:
|
|
curErr=langs.err138;
|
|
break;
|
|
case 139:
|
|
curErr=langs.err139;
|
|
break;
|
|
case 140:
|
|
curErr=langs.err140;
|
|
break;
|
|
case 141:
|
|
curErr=langs.err141;
|
|
break;
|
|
case 145:
|
|
curErr=langs.err145;
|
|
break;
|
|
case 146:
|
|
curErr=langs.err146;
|
|
break;
|
|
case 147:
|
|
curErr=langs.err147;
|
|
break;
|
|
case 148:
|
|
curErr=langs.err148;
|
|
break;
|
|
default:
|
|
curErr=langs.err0+": "+(string) err;
|
|
}
|
|
if(retcode>0){
|
|
curErr+=" ";
|
|
switch(retcode){
|
|
case 10004:
|
|
curErr+=langs.retcode10004;
|
|
break;
|
|
case 10006:
|
|
curErr+=langs.retcode10006;
|
|
break;
|
|
case 10007:
|
|
curErr+=langs.retcode10007;
|
|
break;
|
|
case 10010:
|
|
curErr+=langs.retcode10010;
|
|
break;
|
|
case 10011:
|
|
curErr+=langs.retcode10011;
|
|
break;
|
|
case 10012:
|
|
curErr+=langs.retcode10012;
|
|
break;
|
|
case 10013:
|
|
curErr+=langs.retcode10013;
|
|
break;
|
|
case 10014:
|
|
curErr+=langs.retcode10014;
|
|
break;
|
|
case 10015:
|
|
curErr+=langs.retcode10015;
|
|
break;
|
|
case 10016:
|
|
curErr+=langs.retcode10016;
|
|
break;
|
|
case 10017:
|
|
curErr+=langs.retcode10017;
|
|
break;
|
|
case 10018:
|
|
curErr+=langs.retcode10018;
|
|
break;
|
|
case 10019:
|
|
curErr+=langs.retcode10019;
|
|
break;
|
|
case 10020:
|
|
curErr+=langs.retcode10020;
|
|
break;
|
|
case 10021:
|
|
curErr+=langs.retcode10021;
|
|
break;
|
|
case 10022:
|
|
curErr+=langs.retcode10022;
|
|
break;
|
|
case 10023:
|
|
curErr+=langs.retcode10023;
|
|
break;
|
|
case 10024:
|
|
curErr+=langs.retcode10024;
|
|
break;
|
|
case 10025:
|
|
curErr+=langs.retcode10025;
|
|
break;
|
|
case 10026:
|
|
curErr+=langs.retcode10026;
|
|
break;
|
|
case 10027:
|
|
curErr+=langs.retcode10027;
|
|
break;
|
|
case 10028:
|
|
curErr+=langs.retcode10028;
|
|
break;
|
|
case 10029:
|
|
curErr+=langs.retcode10029;
|
|
break;
|
|
case 10030:
|
|
curErr+=langs.retcode10030;
|
|
break;
|
|
case 10031:
|
|
curErr+=langs.retcode10031;
|
|
break;
|
|
case 10032:
|
|
curErr+=langs.retcode10032;
|
|
break;
|
|
case 10033:
|
|
curErr+=langs.retcode10033;
|
|
break;
|
|
case 10034:
|
|
curErr+=langs.retcode10034;
|
|
break;
|
|
case 10035:
|
|
curErr+=langs.retcode10035;
|
|
break;
|
|
case 10036:
|
|
curErr+=langs.retcode10036;
|
|
break;
|
|
case 10038:
|
|
curErr+=langs.retcode10038;
|
|
break;
|
|
case 10039:
|
|
curErr+=langs.retcode10039;
|
|
break;
|
|
case 10040:
|
|
curErr+=langs.retcode10040;
|
|
break;
|
|
case 10041:
|
|
curErr+=langs.retcode10041;
|
|
break;
|
|
case 10042:
|
|
curErr+=langs.retcode10042;
|
|
break;
|
|
case 10043:
|
|
curErr+=langs.retcode10043;
|
|
break;
|
|
case 10044:
|
|
curErr+=langs.retcode10044;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Alert(curErr);
|
|
}
|
|
|
|
void init_lang(){
|
|
switch(LANG){
|
|
case MY_ENG:
|
|
langs.err1="No error, but unknown result. (1)";
|
|
langs.err2="General error (2)";
|
|
langs.err3="Incorrect parameters (3)";
|
|
langs.err4="Trade server busy (4)";
|
|
langs.err5="Old client terminal version (5)";
|
|
langs.err6="No connection to trade server (6)";
|
|
langs.err7="Not enough rights (7)";
|
|
langs.err8="Too frequent requests (8)";
|
|
langs.err9="Invalid operation disruptive server operation (9)";
|
|
langs.err64="Account blocked (64)";
|
|
langs.err65="Invalid account number (65)";
|
|
langs.err128="Expired waiting period for transaction (128)";
|
|
langs.err129="Invalid price (129)";
|
|
langs.err130="Wrong stop loss (130)";
|
|
langs.err131="Wrong volume (131)";
|
|
langs.err132="Market closed (132)";
|
|
langs.err133="Trade prohibited (133)";
|
|
langs.err134="Not enough money to complete transaction. (134)";
|
|
langs.err135="Price changed (135)";
|
|
langs.err136="No prices (136)";
|
|
langs.err137="Broker busy (137)";
|
|
langs.err138="New prices (138)";
|
|
langs.err139="Order blocked and already being processed (139)";
|
|
langs.err140="Only purchase allowed (140)";
|
|
langs.err141="Too many requests (141)";
|
|
langs.err145="Modification prohibited because order too close to market. (145)";
|
|
langs.err146="Trading subsystem busy (146)";
|
|
langs.err147="Using order expiration date prohibited by broker (147)";
|
|
langs.err148="Number of open and pending orders reached limit set by broker (148)";
|
|
langs.err0="Error occurred while running request";
|
|
langs.retcode="Reason";
|
|
langs.retcode10004="Requote";
|
|
langs.retcode10006="Request rejected";
|
|
langs.retcode10007="Request canceled by trader";
|
|
langs.retcode10010="Only part of request completed";
|
|
langs.retcode10011="Request processing error";
|
|
langs.retcode10012="Request canceled by timeout";
|
|
langs.retcode10013="Invalid request";
|
|
langs.retcode10014="Invalid volume in request";
|
|
langs.retcode10015="Invalid price in request";
|
|
langs.retcode10016="Invalid stops in request";
|
|
langs.retcode10017="Trade disabled";
|
|
langs.retcode10018="Market closed";
|
|
langs.retcode10019="Not enough money to complete request";
|
|
langs.retcode10020="Prices changed";
|
|
langs.retcode10021="No quotes to process request";
|
|
langs.retcode10022="Invalid order expiration date in request";
|
|
langs.retcode10023="Order state changed";
|
|
langs.retcode10024="Too frequent requests";
|
|
langs.retcode10025="No changes in request";
|
|
langs.retcode10026="Autotrading disabled by server";
|
|
langs.retcode10027="Autotrading disabled by client terminal";
|
|
langs.retcode10028="Request locked for processing";
|
|
langs.retcode10029="Order or position frozen";
|
|
langs.retcode10030="Invalid order filling type";
|
|
langs.retcode10031="No connection with trade server";
|
|
langs.retcode10032="Operation allowed only for live accounts";
|
|
langs.retcode10033="Number of pending orders reached limit";
|
|
langs.retcode10034="Volume of orders and positions for symbol reached limit";
|
|
langs.retcode10035="Incorrect or prohibited order type";
|
|
langs.retcode10036="Position with specified POSITION_IDENTIFIER already closed";
|
|
langs.retcode10038="Close volume exceeds current position volume";
|
|
langs.retcode10039="Close order already exists for specified position";
|
|
langs.retcode10040="Number of open items exceeded";
|
|
langs.retcode10041="Pending order activation request rejected, order canceled";
|
|
langs.retcode10042="Only long positions allowed";
|
|
langs.retcode10043="Only short positions allowed";
|
|
langs.retcode10044="Only position closing allowed";
|
|
break;
|
|
case MY_RUS:
|
|
langs.err0="Во время выполнения запроса произошла ошибка";
|
|
langs.err1="Нет ошибки, но результат неизвестен (1)";
|
|
langs.err2="Общая ошибка (2)";
|
|
langs.err3="Неправильные параметры (3)";
|
|
langs.err4="Торговый сервер занят (4)";
|
|
langs.err5="Старая версия клиентского терминала (5)";
|
|
langs.err6="Нет связи с торговым сервером (6)";
|
|
langs.err7="Недостаточно прав (7)";
|
|
langs.err8="Слишком частые запросы (8)";
|
|
langs.err9="Недопустимая операция нарушающая функционирование сервера (9)";
|
|
langs.err64="Счет заблокирован (64)";
|
|
langs.err65="Неправильный номер счета (65)";
|
|
langs.err128="Истек срок ожидания совершения сделки (128)";
|
|
langs.err129="Неправильная цена (129)";
|
|
langs.err130="Неправильные стопы (130)";
|
|
langs.err131="Неправильный объем (131)";
|
|
langs.err132="Рынок закрыт (132)";
|
|
langs.err133="Торговля запрещена (133)";
|
|
langs.err134="Недостаточно денег для совершения операции (134)";
|
|
langs.err135="Цена изменилась (135)";
|
|
langs.err136="Нет цен (136)";
|
|
langs.err137="Брокер занят (137)";
|
|
langs.err138="Новые цены (138)";
|
|
langs.err139="Ордер заблокирован и уже обрабатывается (139)";
|
|
langs.err140="Разрешена только покупка (140)";
|
|
langs.err141="Слишком много запросов (141)";
|
|
langs.err145="Модификация запрещена, так как ордер слишком близок к рынку (145)";
|
|
langs.err146="Подсистема торговли занята (146)";
|
|
langs.err147="Использование даты истечения ордера запрещено брокером (147)";
|
|
langs.err148="Количество открытых и отложенных ордеров достигло предела, установленного брокером (148)";
|
|
langs.retcode="Причина";
|
|
langs.retcode10004="Реквота";
|
|
langs.retcode10006="Запрос отклонен";
|
|
langs.retcode10007="Запрос отменен трейдером";
|
|
langs.retcode10010="Заявка выполнена частично";
|
|
langs.retcode10011="Ошибка обработки запроса";
|
|
langs.retcode10012="Запрос отменен по истечению времени";
|
|
langs.retcode10013="Неправильный запрос";
|
|
langs.retcode10014="Неправильный объем в запросе";
|
|
langs.retcode10015="Неправильная цена в запросе";
|
|
langs.retcode10016="Неправильные стопы в запросе";
|
|
langs.retcode10017="Торговля запрещена";
|
|
langs.retcode10018="Рынок закрыт";
|
|
langs.retcode10019="Нет достаточных денежных средств для выполнения запроса";
|
|
langs.retcode10020="Цены изменились";
|
|
langs.retcode10021="Отсутствуют котировки для обработки запроса";
|
|
langs.retcode10022="Неверная дата истечения ордера в запросе";
|
|
langs.retcode10023="Состояние ордера изменилось";
|
|
langs.retcode10024="Слишком частые запросы";
|
|
langs.retcode10025="В запросе нет изменений";
|
|
langs.retcode10026="Автотрейдинг запрещен сервером";
|
|
langs.retcode10027="Автотрейдинг запрещен клиентским терминалом";
|
|
langs.retcode10028="Запрос заблокирован для обработки";
|
|
langs.retcode10029="Ордер или позиция заморожены";
|
|
langs.retcode10030="Указан неподдерживаемый тип исполнения ордера по остатку ";
|
|
langs.retcode10031="Нет соединения с торговым сервером";
|
|
langs.retcode10032="Операция разрешена только для реальных счетов";
|
|
langs.retcode10033="Достигнут лимит на количество отложенных ордеров";
|
|
langs.retcode10034="Достигнут лимит на объем ордеров и позиций для данного символа";
|
|
langs.retcode10035="Неверный или запрещённый тип ордера";
|
|
langs.retcode10036="Позиция с указанным POSITION_IDENTIFIER уже закрыта";
|
|
langs.retcode10038="Закрываемый объем превышает текущий объем позиции";
|
|
langs.retcode10039="Для указанной позиции уже есть ордер на закрытие";
|
|
langs.retcode10040="Количество открытых позиций превышено";
|
|
langs.retcode10041="Запрос на активацию отложенного ордера отклонен, а сам ордер отменен";
|
|
langs.retcode10042="Разрешены только длинные позиции";
|
|
langs.retcode10043="Разрешены только короткие позиции";
|
|
langs.retcode10044="Разрешено только закрывать существующие позиции";
|
|
break;
|
|
}
|
|
}
|
|
void getmeinfo_btn(string symname){
|
|
double profit=0;
|
|
double positionExist=false;
|
|
LongVol=0;
|
|
ShortVol=0;
|
|
|
|
// count the number of open Long and Short positions,
|
|
// as well as their total profit
|
|
#ifdef __MQL5__
|
|
int cntMyPos=PositionsTotal();
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(PositionGetSymbol(ti)!=symname) continue;
|
|
if(EA_Magic>0 && PositionGetInteger(POSITION_MAGIC)!=EA_Magic) continue;
|
|
|
|
positionExist=true;
|
|
|
|
profit+=PositionGetDouble(POSITION_PROFIT);
|
|
profit+=PositionGetDouble(POSITION_SWAP);
|
|
|
|
if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY){
|
|
LongVol+=PositionGetDouble(POSITION_VOLUME);
|
|
}else{
|
|
ShortVol+=PositionGetDouble(POSITION_VOLUME);
|
|
}
|
|
}
|
|
#else
|
|
int cntMyPos=OrdersTotal();
|
|
if(cntMyPos>0){
|
|
for(int ti=cntMyPos-1; ti>=0; ti--){
|
|
if(OrderSelect(ti,SELECT_BY_POS,MODE_TRADES)==false) continue;
|
|
if( OrderType()==OP_BUY || OrderType()==OP_SELL ){}else{ continue; }
|
|
if(OrderSymbol()!=symname) continue;
|
|
if(EA_Magic>0 && OrderMagicNumber()!=EA_Magic) continue;
|
|
|
|
positionExist=true;
|
|
|
|
profit+=OrderCommission();
|
|
profit+=OrderProfit();
|
|
profit+=OrderSwap();
|
|
|
|
if(OrderType()==OP_BUY){
|
|
LongVol+=OrderLots();
|
|
}else{
|
|
ShortVol+=OrderLots();
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// if there are open positions,
|
|
// then add the button for closing them
|
|
if(positionExist){
|
|
createObject(prefix_graph+"delall", 163, "Закрыть все ("+(string) profit+") L: "+(string) LongVol+" S: "+(string) ShortVol);
|
|
}else{
|
|
// otherwise, remove the position closing button
|
|
if(ObjectFind(0, prefix_graph+"delall")>0){
|
|
ObjectDelete(0, prefix_graph+"delall");
|
|
}
|
|
}
|
|
|
|
// update the current chart to implement
|
|
// changes
|
|
ChartRedraw(0);
|
|
}
|
|
void createObject(string name, int weight, string title){
|
|
// if there is no 'name' button on the chart, create it
|
|
if(ObjectFind(0, name)<0){
|
|
// define the shift relative to the chart right angle where the button is to be displayed
|
|
long offset= ChartGetInteger(0, CHART_WIDTH_IN_PIXELS)-87;
|
|
long offsetY=0;
|
|
for(int ti=0; ti<ObjectsTotal((long) 0); ti++){
|
|
string objName= ObjectName(0, ti);
|
|
if( StringFind(objName, prefix_graph)<0 ){
|
|
continue;
|
|
}
|
|
long tmpOffset=ObjectGetInteger(0, objName, OBJPROP_YDISTANCE);
|
|
if( tmpOffset>offsetY){
|
|
offsetY=tmpOffset;
|
|
}
|
|
}
|
|
|
|
for(int ti=0; ti<ObjectsTotal((long) 0); ti++){
|
|
string objName= ObjectName(0, ti);
|
|
if( StringFind(objName, prefix_graph)<0 ){
|
|
continue;
|
|
}
|
|
long tmpOffset=ObjectGetInteger(0, objName, OBJPROP_YDISTANCE);
|
|
if( tmpOffset!=offsetY ){
|
|
continue;
|
|
}
|
|
|
|
tmpOffset=ObjectGetInteger(0, objName, OBJPROP_XDISTANCE);
|
|
if( tmpOffset>0 && tmpOffset<offset){
|
|
offset=tmpOffset;
|
|
}
|
|
}
|
|
offset-=(weight+1);
|
|
if(offset<0){
|
|
offset=ChartGetInteger(0, CHART_WIDTH_IN_PIXELS)-87;
|
|
offsetY+=25;
|
|
offset-=(weight+1);
|
|
}
|
|
|
|
ObjectCreate(0, name, OBJ_BUTTON, 0, 0, 0);
|
|
ObjectSetInteger(0,name,OBJPROP_XDISTANCE,offset);
|
|
ObjectSetInteger(0,name,OBJPROP_YDISTANCE,offsetY);
|
|
ObjectSetString(0,name,OBJPROP_TEXT, title);
|
|
ObjectSetInteger(0,name,OBJPROP_XSIZE,weight);
|
|
ObjectSetInteger(0,name,OBJPROP_FONTSIZE, 8);
|
|
ObjectSetInteger(0,name,OBJPROP_COLOR, clrBlack);
|
|
ObjectSetInteger(0,name,OBJPROP_YSIZE,25);
|
|
ObjectSetInteger(0,name,OBJPROP_BGCOLOR, clrLightGray);
|
|
ChartRedraw(0);
|
|
}else{
|
|
ObjectSetString(0,name,OBJPROP_TEXT, title);
|
|
}
|
|
}
|
|
|
|
void OnChartEvent(const int id, // event ID
|
|
const long& lparam, // event parameter of the long type
|
|
const double& dparam, // event parameter of the double type
|
|
const string& sparam) // event parameter of the string type
|
|
{
|
|
string text="";
|
|
switch(id){
|
|
case CHARTEVENT_OBJECT_CLICK:
|
|
// if the clicked button name is prefix_graph+"delall", then
|
|
if (sparam==prefix_graph+"delall"){
|
|
closeAllPos();
|
|
}
|
|
break;
|
|
}
|
|
} |