098745/robo-InsideOutsideBarFibo
1
0
Fork 0
forked from marcosptf/robo-InsideOutsideBarFibo
Code Pull requests Activity
robo-InsideOutsideBarFibo/adxpsar_v4.mq5
marcosptf c355373437 new files added
2026-01-19 20:09:07 -03:00

2349 lines
177 KiB
MQL5
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| adxpsar_v4.mq5 |
//| Copyright 2024, MetaQuotes Ltd. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| adxpsar_v4.mq5 |
//| Copyright 2024, MetaQuotes Ltd. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| ADXPSAR_MCEA.mq5 |
//| Copyright 2023, Roberto Jacobs (3rjfx) ~ Date: 2023-07-13 |
//| https://www.mql5.com/en/users/3rjfx |
//+------------------------------------------------------------------+
/**
* aqui eh o tutorial oficial deste robo =>
* Criando um Expert Advisor simples multimoeda usando MQL5 (Parte 1):
* Sinais baseados no ADX em combinação com o Parabolic SAR
* https://www.mql5.com/pt/articles/13008
*
* este projeto aqui eh relacionado a um tutorial de como criar um robo no MT5
* que ultilize uma combinacao de indicadores de analise grafica
* 1.grafico com indicador ADX
* 2.grafico com indicador Parabolic SAR
* estes dois indicadores de analise grafica sao ultilizados em conjuntos para
* trades, eu nao conheco nao tenho ideia de como funcionam eles, precisaria ao menos
* de uma ideia de como eles fazem o gatilho de entrada como funciona este setup,
* agora estos fazendo back-testes na ferramenta pra entender o nivel de assertividade;
*
* ###############################
* #Detalhes sobre esta versao v4#
* ###############################
* este projeto se refere a versao 4 deste robozinho, que pegamos em um tutorial,
* estamos em fase de aprendizado da linguagem MQL5, estamos lendo, fazendo debuggers
* lendo o livro oficial, compilando e rodando os back-testes para testar e entender
* ateh onde este robozinho pode nos ajudar e tentando aprender como toda a plataforma
* funciona para quem sabe um dia agente seja um expert em criação de robos no MT;
*
* Na versao v2, agente apenas pegou o codigo fonte original, para que nao mechesse agente
* criou um projeto v2 apenas para que pudessimos compilar e rodar do jeito que ele estava,
* pode ate ser que agente mude alguma coisa no codigo fonte porem ali eu quero apenas executar
* nos back-testes automatizados para que eu consiga compreender como ele funciona como eh o
* comportamento do robo na sua originalidade;
*
* porque estamos criando agora esta versao v4???
* simplesmente pelo motivo que eu acredito que seja impossivel ser lucrativo no mercado mesmo
* que seja usando robos, mas abrindo muitas boletagens ao mesmo tempo em diversos ativos
* aleatorios, eu nao acredito nisto nao acho isto legal nem lucrativo porque ja tentei fazer
* isto em trade manual em futuros e eh dificil acompanhar tudo, e as vezes o q vc ja lucrou
* em um ativo vc devolve o dobrou ou triplo em outros entao nao acredito que seja lucrativo;
* Eu gostaria de criar uma versao que apenas ultilize o AUD/USD, para que agente teste ele
* e veja se apenas usando um par de Forex agente consiga uma boa oportunidade;
* Entao resumindo esta versao V4 sera uma refatoração para que o robozinho apenas ultilize
* o par AUD/USD, vamos ver no que vai dar kkk
*
*/
#property copyright "Copyright 2023, Roberto Jacobs (3rjfx) ~ Date: 2023-07-13"
#property link "https://www.mql5.com/en/users/3rjfx"
#property version "1.00"
#property strict
#property description "The Expert ADXPSAR_MCEA is the Automated Trading Multi Currency Forex Expert Advisor for MetaTrader 5"
#property description "by using a combination of ADX and Parabolic SAR SAR indicators which trade Multiple Pairs in one Chart."
#property description "esta eh a versao v4-debugger ultilizando H1"
#property description "nesta versao vamos tentar remover esta caracteristica deste robo ser multimoeda"
#property description "pois ateh mesmo quando agente vai tentar fazer um back-test quando o MT5 começa"
#property description "a coletar dados historicos para começar a trabalhar, ele consome todo espaço em disco"
#property description "do computador, vamos tentar deixar este robo especialista em AUD/USD;"
//#property icon "\\Images\\ADXPSAR_MCEA.ico";
//+------------------------------------------------------------------+
//| Include |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\AccountInfo.mqh>
CTrade mc_trade;
CSymbolInfo mc_symbol;
CPositionInfo mc_position;
CAccountInfo mc_account;
enum YN {
No,
Yes
};
enum mmt {
FixedLot, // Fixed Lot Size
DynamLot // Dynamic Lot Size
};
enum TFX {
TFH1, // PERIOD_H1
TFH2, // PERIOD_H2
TFH3, // PERIOD_H3
TFH4, // PERIOD_H4
TFH6, // PERIOD_H6
TFH8, // PERIOD_H8
TFH12, // PERIOD_H12
TFD1 // PERIOD_D1
};
input group "=== Global Strategy EA Parameter ==="; // Global Strategy EA Parameter
input TFX TimeFrames = TFH1; // Select Expert TimeFrame, default PERIOD_H1
input int ADXPeriod = 7; // Input ADX Period
input group "=== Money Management Lot Size Parameter ==="; // Money Management Lot Size Parameter
input mmt mmlot = DynamLot; // Money Management Type
input double Risk = 10.0; // Percent Equity Risk per Trade (Min=1.0% / Max=10.0%)
input double Lots = 0.01; // Input Manual Lot Size FixedLot
//--Day Trading On/Off
input group "=== Day Trading On/Off ==="; // Day Trading On/Off
input YN ttd0 = Yes; // Select Trading on Sunday (Yes) or (No)
input YN ttd1 = Yes; // Select Trading on Monday (Yes) or (No)
input YN ttd2 = Yes; // Select Trading on Tuesday (Yes) or (No)
input YN ttd3 = Yes; // Select Trading on Wednesday (Yes) or (No)
input YN ttd4 = Yes; // Select Trading on Thursday (Yes) or (No)
input YN ttd5 = Yes; // Select Trading on Friday (Yes) or (No)
input YN ttd6 = No; // Select Trading on Saturday (Yes) or (No)
//--Trade & Order management Parameter
input group "=== Trade & Order management Parameter ==="; // Trade & Order management Parameter
input YN use_sl = No; // Use Order Stop Loss (Yes) or (No)
input YN autosl = Yes; // Use Automatic Calculation Stop Loss (Yes) or (No)
input double SLval = 30; // If Not Use Automatic SL - Input SL value in Pips
input YN use_tp = No; // Use Order Take Profit (Yes) or (No)
input YN autotp = Yes; // Use Automatic Calculation Take Profit (Yes) or (No)
input double TPval = 50; // If Not Use Automatic TP - Input TP value in Pips
input YN TrailingSLTP = Yes; // Use Trailing SL/TP (Yes) or (No)
input YN autotrl = No; // Use Automatic Trailing (Yes) or (No)
input double TSval = 5; // If Not Use Automatic Trailing Input Trailing value in Pips
input double TSmin = 5; // Minimum Pips to start Trailing Stop
input YN Close_by_Opps = Yes; // Close Trade By Opposite Signal (Yes) or (No)
input YN SaveOnRev = Yes; // Close Trade and Save profit due to weak signal (Yes) or (No)
//--Others Expert Advisor Parameter
input group "=== Others Expert Advisor Parameter ==="; // Others EA Parameter
input YN alerts = Yes; // Display Alerts / Messages (Yes) or (No)
input YN UseEmailAlert = No; // Email Alert (Yes) or (No)
input YN UseSendnotify = Yes; // Send Notification (Yes) or (No)
input YN trade_info_display = Yes; // Select Display Trading Info on Chart (Yes) or (No)
input ulong magicEA = 202307; // Expert ID (Magic Number)
//+------------------------------------------------------------------+
//| Class for working Expert Advisor |
//+------------------------------------------------------------------+
class MCEA {
private:
int x_year, // Year
x_mon, // Month
x_day, // Day of the month
x_hour, // Hour in a day
x_min, // Minutes
x_sec, // Seconds
oBm,
oSm,
ldig,
posCur1,
posCur2;
double LotPS,
difDi,
slv,
tpv,
pip,
xpip,
floatprofit,
fixclprofit,
ADXDIp[],
ADXDIm[],
OPEN[],
HIGH[],
LOW[],
CLOSE[];
string pairs,
hariini,
daytrade,
trade_mode;
datetime TIME[],
closetime;
int iADXCross(const string symbol);
int iADXpct(const string symbol,const int index);
int PARSAR05(const string symbol);
int PARSAR15(const string symbol);
int PARSAROp(const string symbol);
int LotDig(const string symbol);
double MLots(const string symbx);
double NonZeroDiv(double val1,double val2);
double OrderSLSet(const string xsymb,ENUM_ORDER_TYPE type,double atprice);
double OrderTPSet(const string xsymb,ENUM_ORDER_TYPE type,double atprice);
double SetOrderSL(const string xsymb,ENUM_POSITION_TYPE type,double atprice);
double SetOrderTP(const string xsymb,ENUM_POSITION_TYPE type,double atprice);
double TSPrice(const string xsymb,ENUM_POSITION_TYPE ptype,int TS_type);
string ReqDate(int d,int h,int m);
string TF2Str(ENUM_TIMEFRAMES period);
string timehr(int hr,int mn);
string TradingDay(void);
string AccountMode();
string GetCommentForOrder(void) { return(expname); }
public:
//-- ADXPSAR_MCEA Config --
int Buy,
Sell,
ccur,
psec,
xtto,
checktml,
OpOr[],
xob[],
xos[],
year, // Year
mon, // Month
day, // Day
hour, // Hour
min, // Minutes
sec, // Seconds
dow, // Day of week (0-Sunday, 1-Monday, ... ,6-Saturday)
doy, // Day number of the year (January 1st is assigned the number value of zero)
handADX[],
hParOp[],
hPar15[],
hPar05[],
ALO,
dgts,
arrsymbx,
sall,
arper;
string DIRI[],
AS30[],
expname;
ulong slip;
ENUM_TIMEFRAMES TFt,
TFT15,
TFT05;
double SARstep,
SARmaxi,
profitb[],
profits[];
bool PanelExtra;
/**
precisamos entender o q significa isto aqui,
se eh alguma declaracao ou invocacao simplesmente uma chamada
pq ela esta aqui no meio das declaracoes das propriedades
da classe MCEA();
*/
MCEA(void);
~MCEA(void);
/**
o q eh virtual void???
*/
virtual void ADXPSAR_MCEA_Config(void);
virtual void ExpertActionTrade(void);
void ArraySymbolResize(void);
void CurrentSymbolSet(const string symbol);
void Pips(const string symbol);
void TradeInfo(void);
void Do_Alerts(const string symbx,string msgText);
void CheckOpenPMx(const string symbx);
void SetSLTPOrders(void);
void CloseBuyPositions(const string symbol);
void CloseSellPositions(const string symbol);
void CloseAllOrders(void);
void CheckClose(const string symbx);
void TodayOrders(void);
void UpdatePrice(const string symbol,ENUM_TIMEFRAMES xtf);
void RefreshPrice(const string symbx,ENUM_TIMEFRAMES xtf,int bars);
bool RefreshTick(const string symbx);
bool TradingToday(void);
bool OpenBuy(const string symbol);
bool OpenSell(const string symbol);
bool ModifyOrderSLTP(double mStop,double ordtp);
bool ModifySLTP(const string symbx,int TS_type);
bool CloseAllProfit(void);
bool ManualCloseAllProfit(void);
int PairsIdxArray(const string symbol);
int GetOpenPosition(const string symbol);
int DirectionMove(const string symbol);
int GetCloseInWeakSignal(const string symbol,int exis);
int CheckToCloseInWeakSignal(const string symbol,int exis);
int ThisTime(const int reqmode);
string getUninitReasonText(int reasonCode);
}; //-end class MCEA
/**
* aqui eh uma instancia da classe criada acima eh a classe principal para o
* robozinho, mc eh a variavel da instancia que representa esta classe;
*/
MCEA mc;
//+------------------------------------------------------------------+
//| Constructor |
//+------------------------------------------------------------------+
MCEA::MCEA(void): x_year(0),
x_mon(0),
x_day(0),
x_hour(0),
x_min(0),
x_sec(0),
year(0),
mon(1),
day(2),
hour(3),
min(4),
sec(5),
dow(6),
doy(7),
psec(0),
Buy(1),
Sell(-1),
slip(16),
arper(25),
checktml(0),
difDi(0.34),
SARstep(0.02),
SARmaxi(0.2),
TFT05(PERIOD_M5),
TFT15(PERIOD_M15),
expname("ADXPSAR_MCEA-v4 robo para AUD/USD - M15"),
closetime(TimeCurrent()) { }
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
MCEA::~MCEA(void) { }
//+------------------------------------------------------------------+
//| Expert Configuration |
//+------------------------------------------------------------------+
void MCEA::ADXPSAR_MCEA_Config(void) {
/**
* array original onde tem todos os pares usados pelo robo para realizar as operacoes
* ele executa operacoes nos 30 pares de moedas, eu mesmo acredito que isto eh um absurdo
* porque eu nao quero acreditar que existe uma soh estrategia que funcione para todos
* os ativos existentes, ateh porque cada ativo eh unico, cada ativo funciona de uma
* maneira unica se comporta de maneira unica a velocidade de movimentação de cada uma
* funciona de um jeito muito particular, duvido muito que uma soh estrategia funcione para
* todos os ativos existentes, entao nossa estrategia neste v4 seria especializar este
* robozinho apenas para o ativo AUD/USD, apenas este ativo de forex que eu quero trabalhar
* e de preferencia em timeframes menores como M5 ou M15, eu acho que robos com tempos
* maiores nao sei se seria assertivo, e gostaria que fosse scalper;
*
* entao vamos manter em originalidade este array abaixo nesta refatoracao porem vamos
* manter o nome dela para nao ter problema no funcionamento;
*
* string All30[]={"EURUSD","GBPUSD","AUDUSD","NZDUSD","USDCAD","USDCHF","USDJPY","EURGBP",
* "EURAUD","EURNZD","EURCAD","EURCHF","EURJPY","GBPAUD","GBPNZD","GBPCAD",
* "GBPCHF","GBPJPY","AUDNZD","AUDCAD","AUDCHF","AUDJPY","NZDCAD","NZDCHF",
* "NZDJPY","CADCHF","CADJPY","CHFJPY","XAUUSD","XAGUSD"}; // 30 pairs
*/
string All30[] = {"AUDUSD"};
/* obtem a quantidade total de todos os arrays, agora retornara apenas 1 */
sall=ArraySize(All30);
/**
* A função define um tamanho novo para a primeira dimensão
* int ArrayResize(
* void& array[], // array passado por referência
* int new_size, // novo tamanho de array
* int reserve_size=0 // valor do tamanho de reserva (excesso)
* );
*/
ArrayResize(AS30,sall,sall);
/**
* Copia um array em um outro array.
*
* int ArrayCopy(
* void& dst_array[], // array de destino
* const void& src_array[], // array de origem
* int dst_start=0, // índice de início do array destino a partir do qual se escreve
* int src_start=0, // primeiro índice de um array de origem
* int count=WHOLE_ARRAY // número de elementos
* );
*
*/
ArrayCopy(AS30,All30,0,0,WHOLE_ARRAY);
arrsymbx=sall;
/**
* chamada da function que limpa algumas variaveis de array,
* da resize nas mesmas na sequencia e depois seta alguns arrays como series;
*/
ArraySymbolResize();
//faz copia de array de um para outro
ArrayCopy(DIRI,All30,0,0,WHOLE_ARRAY);
/**
* neste for ele usa uma variavel de array q eh uma copia daquele array que contem
* todos os pares que no original seriam 30, ele diz para o MT5 que ira dar foco para
* aquele par de forex naquele grafico;
* no nosso caso ele precisa abrir somente para o AUD/USD;
* Selects a symbol in the Market Watch window or removes a symbol from the window.
*
* bool SymbolSelect(
* string name, // symbol name
* bool select // add or remove
* );
*/
for(int x=0; x<arrsymbx; x++) {SymbolSelect(DIRI[x],true);}
pairs="robo para operar adxpsar para o aud/usd";
/* enum de timeframes */
ENUM_TIMEFRAMES TFs[]={PERIOD_H1,PERIOD_H2,PERIOD_H3,PERIOD_H4,PERIOD_H6,PERIOD_H8,PERIOD_H12,PERIOD_D1};
/**
* obtem o tamanho da quantidade de timeframes declarados, ele percorre para saber
* qual o timeframe que foi selecionado, neste caso o default eh o H4;
*/
int arTFs=ArraySize(TFs);
for(int x=0; x<arTFs; x++) { if(x==TimeFrames) { TFt=TFs[x]; break; } }
/**
* neste trecho ele percorre pela quantidade de pares
* arrsymbx = quantidade de pares forex
* e aplica configurações de adx e sar
*/
for(int x=0; x<arrsymbx; x++) {
handADX[x] = iADX(DIRI[x],TFt,ADXPeriod);
hParOp[x] = iSAR(DIRI[x],TFt,SARstep,SARmaxi);
hPar15[x] = iSAR(DIRI[x],TFT15,SARstep,SARmaxi);
hPar05[x] = iSAR(DIRI[x],TFT05,SARstep,SARmaxi);
}
/**
* if ternario onde verifica se ja ultrapassou a quantidade de limit orders para
* aquela conta, ele verifica por exemplo se a quantidade de ordens eh maior que a quantidade
* de ativos forex no original do robo sao 30, como agora eh somente 1, precisamos estar atento
* para saber em que momento isto pode impactar no comportamento do robo;
*/
ALO = (int)mc_account.LimitOrders()>arrsymbx ? arrsymbx : (int)mc_account.LimitOrders();
//faz o parser de integer para double para atribuir em outra variavel
LotPS=(double)ALO;
mc_trade.SetExpertMagicNumber(magicEA);
mc_trade.SetDeviationInPoints(slip);
mc_trade.SetMarginMode();
return;
} //-end ADXPSAR_MCEA_Config()
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit(void) {
Print("inicializando OnInit(); function;");
mc.ADXPSAR_MCEA_Config();
return(INIT_SUCCEEDED);
} //-end OnInit()
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
Print("inicializando OnInit(); function;");
Comment("inicializando OnDeinit(); function;");
//-- Release all handle indicators for all symbols
for(int x=0; x<mc.arrsymbx; x++) {
IndicatorRelease(mc.handADX[x]);
IndicatorRelease(mc.hParOp[x]);
IndicatorRelease(mc.hPar05[x]);
IndicatorRelease(mc.hPar15[x]);
}
PrintFormat("%s: Deinitialization reason code=%d",__FUNCTION__,reason);
Print(mc.getUninitReasonText(reason));
ObjectsDeleteAll(0,0,OBJ_BUTTON);
ObjectsDeleteAll(0,0,OBJ_LABEL);
ObjectsDeleteAll(0,0,OBJ_RECTANGLE_LABEL);
return;
} //-end OnDeinit()
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick(void) {
mc.ExpertActionTrade();
return;
} //-end OnTick()
void MCEA::ExpertActionTrade(void) {
//Check Trading Terminal
ResetLastError();
//-- Check whether MT5 Algorithmic trading is Allow or Prohibit
if(!MQLInfoInteger(MQL_TRADE_ALLOWED) && mc.checktml==0) {
mc.Do_Alerts(Symbol(),"Trading Expert at "+Symbol()+" are NOT Allowed by Setting.");
mc.checktml=1; //-- Variable checktml is given a value of 1, so that the alert is only done once.
return;
}
//-- Show the expert manual button panel
if(!DisplayManualButton("M","C","R")) DisplayManualButton();
//-- Displayed Trading Info on Chart
if(trade_info_display==Yes) mc.TradeInfo();
int mcsec=mc.ThisTime(mc.sec);
if(fmod((double)mcsec,5.0)==0) mc.ccur=mcsec;
if(mc.ccur!=mc.psec) {
string symbol;
//-- Here we start with the rotation of the name of all symbol or pairs to be traded
for(int x=0; x<mc.arrsymbx && !IsStopped(); x++) {
if(mc.DIRI[x]==Symbol()) {
symbol=Symbol();
} else {
symbol=mc.DIRI[x];
}
//esta chamada de function seta o ativo para que seja o principal
mc.CurrentSymbolSet(symbol);
if(mc.TradingToday()) {
/**
* //-- Get trading signals to open positions
* //-- and store in the variable OpOr[x]
*/
mc.OpOr[x]=mc.GetOpenPosition(symbol);
//-- If variable OpOr[x] get result of GetOpenPosition(symbol) as "Buy" (value=1)
if(mc.OpOr[x]==mc.Buy) {
mc.CheckOpenPMx(symbol);
if(Close_by_Opps==Yes && mc.xos[x]>0) mc.CloseSellPositions(symbol);
if(mc.xob[x]==0 && mc.xtto<mc.ALO) {
mc.OpenBuy(symbol);
} else if(mc.xtto>=mc.ALO) {
//--
mc.Do_Alerts(symbol,"Maximum amount of open positions and active pending orders has reached"+
"\n the limit = "+string(mc.ALO)+" Orders ");
//--
mc.CheckOpenPMx(symbol);
//--
if(mc.xos[x]>0 && mc.profits[x]<-1.02 && mc.xob[x]==0) {mc.CloseSellPositions(symbol); mc.OpenBuy(symbol);}
else
if(SaveOnRev==Yes) mc.CloseAllProfit();
}
}
//-- If variable OpOr[x] get result of GetOpenPosition(symbol) as "Sell" (value=-1)
if(mc.OpOr[x]==mc.Sell) {
mc.CheckOpenPMx(symbol);
if(Close_by_Opps==Yes && mc.xob[x]>0) mc.CloseBuyPositions(symbol);
if(mc.xos[x]==0 && mc.xtto<mc.ALO) {
mc.OpenSell(symbol);
} else if(mc.xtto>=mc.ALO) {
mc.Do_Alerts(symbol,"Maximum amount of open positions and active pending orders has reached"+
"\n the limit = "+string(mc.ALO)+" Orders ");
mc.CheckOpenPMx(symbol);
if(mc.xob[x]>0 && mc.profitb[x]<-1.02 && mc.xos[x]==0) {
mc.CloseBuyPositions(symbol); mc.OpenSell(symbol);
} else if(SaveOnRev==Yes) {
mc.CloseAllProfit();
}
}
}
mc.CheckOpenPMx(symbol);
if(mc.xob[x]>0 && mc.CheckToCloseInWeakSignal(symbol,mc.Buy)==mc.Sell) {mc.CloseBuyPositions(symbol); mc.OpenSell(symbol);}
if(mc.xos[x]>0 && mc.CheckToCloseInWeakSignal(symbol,mc.Sell)==mc.Buy) {mc.CloseSellPositions(symbol); mc.OpenBuy(symbol);}
}
if(mc.xtto>0) {
//-- Close Trade and Save profit due to weak signal (Yes)
if(SaveOnRev==Yes) {
mc.CheckOpenPMx(symbol);
if(mc.profitb[x]>0.02 && mc.xob[x]>0 && mc.GetCloseInWeakSignal(symbol,mc.Buy)==mc.Sell) {
mc.CloseBuyPositions(symbol);
mc.Do_Alerts(symbol,"Close BUY order "+symbol+" to save profit due to weak signal.");
}
if(mc.profits[x]>0.02 && mc.xos[x]>0 && mc.GetCloseInWeakSignal(symbol,mc.Sell)==mc.Buy) {
mc.CloseSellPositions(symbol);
mc.Do_Alerts(symbol,"Close SELL order "+symbol+" to save profit due to weak signal.");
}
if(mc.xob[x]>0 && mc.CheckToCloseInWeakSignal(symbol,mc.Buy)==mc.Sell) mc.CloseBuyPositions(symbol);
if(mc.xos[x]>0 && mc.CheckToCloseInWeakSignal(symbol,mc.Sell)==mc.Buy) mc.CloseSellPositions(symbol);
}
//-- Use Trailing SL/TP (Yes)
if(TrailingSLTP==Yes) {
if(autotrl==Yes) mc.ModifySLTP(symbol,1); //-- If Use Automatic Trailing (Yes)
if(autotrl==No) mc.ModifySLTP(symbol,0); //-- Use Automatic Trailing (No)
}
}
mc.CheckClose(symbol);
}
mc.psec=mc.ccur;
}
return;
} //-end ExpertActionTrade()
int MCEA::PairsIdxArray(const string symbol) {
int pidx=0; for(int x=0; x<arrsymbx; x++) { if(DIRI[x]==symbol) { pidx=x; break; } } return(pidx);
} //-end PairsIdxArray()
/**
* metodo ou function para ArraySymbolResize();
* Libera um buffer de qualquer array dinâmico e define o tamanho da dimensão zero para 0.
* void ArrayFree(
* void& array[] // array
* );
*
*
* A função define um tamanho novo para a primeira dimensão
* int ArrayResize(
* void& array[], // array passado por referência
* int new_size, // novo tamanho de array
* int reserve_size=0 // valor do tamanho de reserva (excesso)
* );
*
*
* A função define o flag AS_SERIES para um objeto de um array dinâmico, e os elementos serão indexados como em timeseries.
* bool ArraySetAsSeries(
* const void& array[], // array passado por referência
* bool flag // true significa ordem reversa de indexação
* );
*
*/
void MCEA::ArraySymbolResize(void) {
ArrayFree(DIRI);
ArrayFree(xob);
ArrayFree(xos);
ArrayFree(OpOr);
ArrayFree(profitb);
ArrayFree(profits);
ArrayFree(hPar15);
ArrayFree(hPar05);
ArrayFree(hParOp);
ArrayFree(ADXDIp);
ArrayFree(ADXDIm);
ArrayFree(handADX);
ArrayResize(DIRI,arrsymbx,arrsymbx);
ArrayResize(xob,arrsymbx,arrsymbx);
ArrayResize(xos,arrsymbx,arrsymbx);
ArrayResize(OpOr,arrsymbx,arrsymbx);
ArrayResize(profitb,arrsymbx,arrsymbx);
ArrayResize(profits,arrsymbx,arrsymbx);
ArrayResize(hPar15,arrsymbx,arrsymbx);
ArrayResize(hPar05,arrsymbx,arrsymbx);
ArrayResize(hParOp,arrsymbx,arrsymbx);
ArrayResize(handADX,arrsymbx,arrsymbx);
ArrayResize(ADXDIp,arrsymbx,arrsymbx);
ArrayResize(ADXDIm,arrsymbx,arrsymbx);
ArraySetAsSeries(ADXDIp,true);
ArraySetAsSeries(ADXDIm,true);
return;
} //-end ArraySymbolResize()
void MCEA::UpdatePrice(const string symbol,ENUM_TIMEFRAMES xtf) {
ArrayFree(OPEN);
ArrayFree(HIGH);
ArrayFree(LOW);
ArrayFree(CLOSE);
ArrayFree(TIME);
ArrayResize(OPEN,arper,arper);
ArrayResize(HIGH,arper,arper);
ArrayResize(LOW,arper,arper);
ArrayResize(CLOSE,arper,arper);
ArrayResize(TIME,arper,arper);
ArraySetAsSeries(OPEN,true);
ArraySetAsSeries(HIGH,true);
ArraySetAsSeries(LOW,true);
ArraySetAsSeries(CLOSE,true);
ArraySetAsSeries(TIME,true);
ArrayInitialize(OPEN,0.0);
ArrayInitialize(HIGH,0.0);
ArrayInitialize(LOW,0.0);
ArrayInitialize(CLOSE,0.0);
ArrayInitialize(TIME,0);
RefreshPrice(symbol,xtf,arper);
/**
Call by the first position and the number of required elements
int CopyOpen(
string symbol_name, // symbol name
ENUM_TIMEFRAMES timeframe, // period
int start_pos, // start position
int count, // data count to copy
double open_array[] // target array to copy open prices
);
Call by the start date and the number of required elements
int CopyOpen(
string symbol_name, // symbol name
ENUM_TIMEFRAMES timeframe, // period
datetime start_time, // start date and time
int count, // data count to copy
double open_array[] // target array for bar open prices
);
Call by the start and end dates of a required time interval
int CopyOpen(
string symbol_name, // symbol name
ENUM_TIMEFRAMES timeframe, // period
datetime start_time, // start date and time
datetime stop_time, // stop date and time
double open_array[] // target array for bar open values
);
*/
int co=CopyOpen(symbol,xtf,0,arper,OPEN);
int ch=CopyHigh(symbol,xtf,0,arper,HIGH);
int cl=CopyLow(symbol,xtf,0,arper,LOW);
int cc=CopyClose(symbol,xtf,0,arper,CLOSE);
int ct=CopyTime(symbol,xtf,0,arper,TIME);
return;
} //-end UpdatePrice()
void MCEA::RefreshPrice(const string symbx,ENUM_TIMEFRAMES xtf,int bars) {
MqlRates parray[];
ArraySetAsSeries(parray,true);
int copied=CopyRates(symbx,xtf,0,bars,parray);
return;
} //-end RefreshPrice()
bool MCEA::RefreshTick(const string symbx) {
mc_symbol.Name(symbx);
if(mc_symbol.RefreshRates()) return(true);
return(false);
} //-end RefreshTick()
void MCEA::CurrentSymbolSet(const string symbol) {
mc_symbol.Name(symbol);
mc_symbol.CheckMarketWatch();
mc_symbol.IsSynchronized();
mc_trade.SetTypeFillingBySymbol(symbol);
mc_symbol.Refresh();
mc_symbol.RefreshRates();
return;
} //-end CurrentSymbolSet()
void MCEA::Pips(const string symbol) {
CurrentSymbolSet(symbol);
double point=mc_symbol.Point();
dgts=(int)mc_symbol.Digits();
xpip=10.0;
pip=point*xpip;
return;
} //-end Pips()
// Bar Price Direction
int MCEA::DirectionMove(const string symbol) {
int ret=0;
int rise=1,
down=-1;
Pips(symbol);
double difud=mc_symbol.NormalizePrice(1.5*pip);
UpdatePrice(symbol,TFt);
if(CLOSE[0]>OPEN[0]+difud) ret=rise;
if(CLOSE[0]<OPEN[0]-difud) ret=down;
return(ret);
} //-end DirectionMove()
//ADX indicator function - input index of bar.
int MCEA::iADXpct(const string symbol,const int index) {
double answer1=0,
answer2=0,
pdi_now=0,
mdi_now=0,
pdi_prv=0,
mdi_prv=0;
int rise=1,
down=-1;
int mv=0;
int x=PairsIdxArray(symbol);
UpdatePrice(symbol,TFt);
CopyBuffer(handADX[x],1,0,3,ADXDIp);
CopyBuffer(handADX[x],2,0,3,ADXDIm);
pdi_now=ADXDIp[index];
mdi_now=ADXDIm[index];
pdi_prv=ADXDIp[index+1];
mdi_prv=ADXDIm[index+1];
if((pdi_now==0 || pdi_now==EMPTY_VALUE) || (mdi_now==0 || mdi_now==EMPTY_VALUE)) {
answer1=0.0;
} else {
answer1 = NormalizeDouble((pdi_now / mdi_now * 100) - 100,3);
}
if((pdi_prv==0 || pdi_prv==EMPTY_VALUE) || (mdi_prv==0 || mdi_prv==EMPTY_VALUE)) {
answer2=0.0;
} else {
answer2 = NormalizeDouble((pdi_prv / mdi_prv * 100) - 100,3);
}
if(answer1>answer2) mv=rise;
if(answer1<answer2) mv=down;
return(mv);
} //-end iADXpct()
int MCEA::iADXCross(const string symbol) {
int mv=0,
rise=1,
down=-1,
x=PairsIdxArray(symbol);
UpdatePrice(symbol,TFt);
int GiADXc=iADXpct(symbol,0);
CopyBuffer(handADX[x],1,0,3,ADXDIp);
CopyBuffer(handADX[x],2,0,3,ADXDIm);
bool gadxrise=(ADXDIp[2]<=ADXDIm[2] && ADXDIp[1]>ADXDIm[1]+difDi && ADXDIp[0]>ADXDIp[1] && GiADXc==rise);
bool gadxdown=(ADXDIp[2]>=ADXDIm[2] && ADXDIp[1]<ADXDIm[1]-difDi && ADXDIp[0]<ADXDIp[1] && GiADXc==down);
if(gadxrise) mv=rise;
if(gadxdown) mv=down;
return(mv);
} //- end iADXCross()
// Signal Open Position
int MCEA::GetOpenPosition(const string symbol) {
int ret=0,
rise=1,
down=-1,
dirmov=DirectionMove(symbol),
pars15=PARSAR15(symbol),
parsOp=PARSAROp(symbol),
sigADX=iADXCross(symbol);
if(sigADX==rise && parsOp==rise && dirmov==rise && pars15==rise) ret=rise;
if(sigADX==down && parsOp==down && dirmov==down && pars15==down) ret=down;
return(ret);
} //-end GetOpenPosition()
// Signal Indicator Position Close in profit
int MCEA::GetCloseInWeakSignal(const string symbol,int exis) {
int ret=0,
rise=1,
down=-1,
x=PairsIdxArray(symbol);
UpdatePrice(symbol,TFt);
CopyBuffer(handADX[x],1,0,3,ADXDIp);
CopyBuffer(handADX[x],2,0,3,ADXDIm);
int GiADXp=iADXpct(symbol,0);
bool gadxriseD=(ADXDIp[0]>ADXDIm[0] && GiADXp==down);
bool gadxdownR=(ADXDIp[0]<ADXDIm[0] && GiADXp==rise);
if(exis==down && gadxdownR) ret=rise;
if(exis==rise && gadxriseD) ret=down;
return(ret);
} //-end GetCloseInWeakSignal()
// Signal Indicator Position Close
int MCEA::CheckToCloseInWeakSignal(const string symbol,int exis) {
int ret=0,
rise=1,
down=-1,
xi=PairsIdxArray(symbol),
dirmov=DirectionMove(symbol),
pars15=PARSAR15(symbol),
parsop=PARSAROp(symbol);
if(exis==down && parsop==rise && pars15==rise && dirmov==rise) ret=rise;
if(exis==rise && parsop==down && pars15==down && dirmov==down) ret=down;
return(ret);
} //-end CheckToCloseInWeakSignal()
// formula Parabolic SAR in set timeframe
int MCEA::PARSAROp(const string symbol) {
int ret=0,
rise=1,
down=-1,
br=2;
double PSAR[];
ArrayResize(PSAR,br,br);
ArraySetAsSeries(PSAR,true);
int xx=PairsIdxArray(symbol);
CopyBuffer(hParOp[xx],0,0,br,PSAR);
RefreshPrice(symbol,TFt,br);
double HIG0=iHigh(symbol,TFt,0);
double LOW0=iLow(symbol,TFt,0);
if(PSAR[0]<LOW0) ret=rise;
if(PSAR[0]>HIG0) ret=down;
return(ret);
} //-end PARSAROp()
// formula Parabolic SAR M5
int MCEA::PARSAR05(const string symbol) {
int ret=0,
rise=1,
down=-1,
br=2;
double PSAR[];
ArrayResize(PSAR,br,br);
ArraySetAsSeries(PSAR,true);
int xx=PairsIdxArray(symbol);
CopyBuffer(hPar05[xx],0,0,br,PSAR);
RefreshPrice(symbol,TFT05,br);
double HIG0=iHigh(symbol,TFT05,0);
double LOW0=iLow(symbol,TFT05,0);
if(PSAR[0]<LOW0) ret=rise;
if(PSAR[0]>HIG0) ret=down;
return(ret);
} //-end PARSAR05()
// formula Parabolic SAR M15
int MCEA::PARSAR15(const string symbol) {
int ret=0,
rise=1,
down=-1,
br=2;
double PSAR[];
ArrayResize(PSAR,br,br);
ArraySetAsSeries(PSAR,true);
int xx=PairsIdxArray(symbol);
CopyBuffer(hPar15[xx],0,0,br,PSAR);
RefreshPrice(symbol,TFT15,br);
double HIG0=iHigh(symbol,TFT15,0);
double LOW0=iLow(symbol,TFT15,0);
if(PSAR[0]<LOW0) ret=rise;
if(PSAR[0]>HIG0) ret=down;
return(ret);
} //-end PARSAR15()
bool MCEA::OpenBuy(const string symbol) {
ResetLastError();
bool buyopen = false;
string ldComm = GetCommentForOrder()+"_Buy";
double ldLot = MLots(symbol);
ENUM_ORDER_TYPE type_req = ORDER_TYPE_BUY;
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
ZeroMemory(req);
ZeroMemory(res);
ZeroMemory(check);
CurrentSymbolSet(symbol);
double SL=OrderSLSet(symbol,type_req,mc_symbol.Bid());
double TP=OrderTPSet(symbol,type_req,mc_symbol.Ask());
if(RefreshTick(symbol)) buyopen=mc_trade.Buy(ldLot,symbol,mc_symbol.Ask(),SL,TP,ldComm);
int error=GetLastError();
if(buyopen||error==0) {
string bsopen="Open BUY Order for "+symbol+" ~ Ticket= ["+(string)mc_trade.ResultOrder()+"] successfully..!";
Do_Alerts(symbol,bsopen);
} else {
mc_trade.CheckResult(check);
Do_Alerts(Symbol(),"Open BUY order for "+symbol+" FAILED!!. Return code= "+
(string)mc_trade.ResultRetcode()+". Code description: ["+mc_trade.ResultRetcodeDescription()+"]");
return(false);
}
return(buyopen);
} //-end OpenBuy
bool MCEA::OpenSell(const string symbol) {
ResetLastError();
bool selopen = false;
string sdComm = GetCommentForOrder()+"_Sell";
double sdLot = MLots(symbol);
ENUM_ORDER_TYPE type_req = ORDER_TYPE_SELL;
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
ZeroMemory(req);
ZeroMemory(res);
ZeroMemory(check);
CurrentSymbolSet(symbol);
double SL=OrderSLSet(symbol,type_req,mc_symbol.Ask());
double TP=OrderTPSet(symbol,type_req,mc_symbol.Bid());
if(RefreshTick(symbol)) selopen=mc_trade.Sell(sdLot,symbol,mc_symbol.Bid(),SL,TP,sdComm);
int error=GetLastError();
if(selopen||error==0) {
string bsopen="Open SELL Order for "+symbol+" ~ Ticket= ["+(string)mc_trade.ResultOrder()+"] successfully..!";
Do_Alerts(symbol,bsopen);
} else {
mc_trade.CheckResult(check);
Do_Alerts(Symbol(),"Open SELL order for "+symbol+" FAILED!!. Return code= "+
(string)mc_trade.ResultRetcode()+". Code description: ["+mc_trade.ResultRetcodeDescription()+"]");
return(false);
}
return(selopen);
} //-end OpenSell
double MCEA::OrderSLSet(const string xsymb,ENUM_ORDER_TYPE type,double atprice) {
slv=0.0;
int x=PairsIdxArray(xsymb);
Pips(xsymb);
RefreshTick(xsymb);
switch(type) {
case (ORDER_TYPE_BUY): {
if(use_sl==Yes && autosl==Yes) slv=mc_symbol.NormalizePrice(atprice-38*pip);
else
if(use_sl==Yes && autosl==No) slv=mc_symbol.NormalizePrice(atprice-SLval*pip);
else slv=0.0;
break;
}
case (ORDER_TYPE_SELL): {
if(use_sl==Yes && autosl==Yes) slv=mc_symbol.NormalizePrice(atprice+38*pip);
else
if(use_sl==Yes && autosl==No) slv=mc_symbol.NormalizePrice(atprice+SLval*pip);
else slv=0.0;
}
}
return(slv);
} //-end OrderSLSet()
double MCEA::OrderTPSet(const string xsymb,ENUM_ORDER_TYPE type,double atprice) {
tpv=0.0;
int x=PairsIdxArray(xsymb);
Pips(xsymb);
RefreshTick(xsymb);
switch(type) {
case (ORDER_TYPE_BUY):
{
if(use_tp==Yes && autotp==Yes) tpv=mc_symbol.NormalizePrice(atprice+50*pip);
else
if(use_tp==Yes && autotp==No) tpv=mc_symbol.NormalizePrice(atprice+TPval*pip);
else tpv=0.0;
//--
break;
}
case (ORDER_TYPE_SELL):
{
if(use_tp==Yes && autotp==Yes) tpv=mc_symbol.NormalizePrice(atprice-50*pip);
else
if(use_tp==Yes && autotp==No) tpv=mc_symbol.NormalizePrice(atprice-TPval*pip);
else tpv=0.0;
}
}
return(tpv);
} //-end OrderTPSet()
//-- function: CheckOpenTrade
void MCEA::CheckOpenPMx(const string symbx) {
int totalorder=PositionsTotal(),
xi=PairsIdxArray(symbx);
xtto=totalorder;
xob[xi]=0;
xos[xi]=0;
profitb[xi]=0;
profits[xi]=0;
double pos_profit = 0.0,
pos_swap = 0.0,
pos_comm = 0.0;
for(int i=0; i<totalorder && !IsStopped(); i++) {
string position_symbol=PositionGetSymbol(i);
long magic = mc_position.Magic();
if(position_symbol==symbx && magic==magicEA) {
ENUM_POSITION_TYPE opstype = mc_position.PositionType();
if(opstype == POSITION_TYPE_BUY) {
xob[xi]++;
pos_profit = mc_position.Profit();
pos_swap = mc_position.Swap();
pos_comm = mc_position.Commission();
profitb[xi] += NormalizeDouble(pos_profit+pos_swap+pos_comm,2);
}
if(opstype == POSITION_TYPE_SELL) {
xos[xi]++;
pos_profit = mc_position.Profit();
pos_swap = mc_position.Swap();
pos_comm = mc_position.Commission();
profits[xi] += NormalizeDouble(pos_profit+pos_swap+pos_comm,2);
}
}
}
return;
} //-end CheckOpenPMx()
double MCEA::TSPrice(const string xsymb,ENUM_POSITION_TYPE ptype,int TS_type) {
int br=2;
double pval=0.0;
int x=PairsIdxArray(xsymb);
Pips(xsymb);
switch(TS_type) {
case 0:
{
RefreshTick(xsymb);
if(ptype==POSITION_TYPE_BUY) pval=mc_symbol.NormalizePrice(mc_symbol.Bid()-TSval*pip);
if(ptype==POSITION_TYPE_SELL) pval=mc_symbol.NormalizePrice(mc_symbol.Ask()+TSval*pip);
break;
}
case 1:
{
double PSAR[];
ArrayResize(PSAR,br,br);
ArraySetAsSeries(PSAR,true);
CopyBuffer(hParOp[x],0,0,br,PSAR);
RefreshPrice(xsymb,TFt,br);
//--
if(ptype==POSITION_TYPE_BUY && (PSAR[0]<iLow(xsymb,TFt,0))) pval=PSAR[0];
if(ptype==POSITION_TYPE_SELL && (PSAR[0]>iHigh(xsymb,TFt,0))) pval=PSAR[0];
break;
}
}
return(pval);
} //-end TSPrice()
bool MCEA::ModifySLTP(const string symbx,int TS_type) {
ResetLastError();
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
int TRSP=TS_type;
bool modist=false;
int x=PairsIdxArray(symbx);
Pips(symbx);
int total=PositionsTotal();
for(int i=total-1; i>=0; i--) {
string symbol=PositionGetSymbol(i);
if(symbol==symbx && mc_position.Magic()==magicEA) {
ENUM_POSITION_TYPE opstype = mc_position.PositionType();
if(opstype==POSITION_TYPE_BUY) {
RefreshTick(symbol);
double price = mc_position.PriceCurrent(),
vtrsb = mc_symbol.NormalizePrice(TSPrice(symbx,opstype,TRSP)),
pos_open = mc_position.PriceOpen(),
pos_stop = mc_position.StopLoss(),
pos_profit = mc_position.Profit(),
pos_swap = mc_position.Swap(),
pos_comm = mc_position.Commission(),
netp=pos_profit+pos_swap+pos_comm,
modstart=mc_symbol.NormalizePrice(pos_open+TSmin*pip),
modminsl=mc_symbol.NormalizePrice(vtrsb+TSmin*pip),
modbuysl=vtrsb,
modbuytp=mc_symbol.NormalizePrice(price+TPval*pip);
bool modbuy = (price>modminsl && modbuysl>modstart && (pos_stop==0.0||modbuysl>pos_stop));
if(modbuy && netp > 0.05) {
modist=mc_trade.PositionModify(symbol,modbuysl,modbuytp);
}
}
if(opstype==POSITION_TYPE_SELL) {
RefreshTick(symbol);
double price = mc_position.PriceCurrent(),
vtrss = mc_symbol.NormalizePrice(TSPrice(symbx,opstype,TRSP)),
pos_open = mc_position.PriceOpen(),
pos_stop = mc_position.StopLoss(),
pos_profit = mc_position.Profit(),
pos_swap = mc_position.Swap(),
pos_comm = mc_position.Commission(),
netp=pos_profit+pos_swap+pos_comm,
modstart=mc_symbol.NormalizePrice(pos_open-TSmin*pip),
modminsl=mc_symbol.NormalizePrice(vtrss-TSmin*pip),
modselsl=vtrss,
modseltp=mc_symbol.NormalizePrice(price-TPval*pip);
bool modsel = (price<modminsl && modselsl<modstart && (pos_stop==0.0||modselsl<pos_stop));
if(modsel && netp>0.05) {
modist=mc_trade.PositionModify(symbol,modselsl,modseltp);
}
}
}
}
return(modist);
} //-end ModifySLTP()
void MCEA::SetSLTPOrders(void) {
ResetLastError();
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
double modbuysl=0;
double modselsl=0;
double modbuytp=0;
double modseltp=0;
string position_symbol;
int totalorder=PositionsTotal();
for(int i=totalorder-1; i>=0; i--) {
string symbol=PositionGetSymbol(i);
position_symbol=symbol;
if(mc_position.Magic()==magicEA) {
ENUM_POSITION_TYPE opstype = mc_position.PositionType();
if(opstype==POSITION_TYPE_BUY) {
Pips(symbol);
RefreshTick(symbol);
double price = mc_position.PriceCurrent(),
pos_open = mc_position.PriceOpen(),
pos_stop = mc_position.StopLoss(),
pos_take = mc_position.TakeProfit();
modbuysl=SetOrderSL(symbol,opstype,pos_open);
if(price<modbuysl) modbuysl=mc_symbol.NormalizePrice(price-slip*pip);
modbuytp=SetOrderTP(symbol,opstype,pos_open);
if(price>modbuytp) modbuytp=mc_symbol.NormalizePrice(price+slip*pip);
if(pos_stop==0.0 || pos_take==0.0) {
if(!mc_trade.PositionModify(position_symbol,modbuysl,modbuytp)) {
mc_trade.CheckResult(check);
Do_Alerts(symbol,"Set SL and TP for "+EnumToString(opstype)+" on "+symbol+" FAILED!!. Return code= "+
(string)mc_trade.ResultRetcode()+". Code description: ["+mc_trade.ResultRetcodeDescription()+"]");
}
}
}
if(opstype==POSITION_TYPE_SELL) {
Pips(symbol);
RefreshTick(symbol);
double price = mc_position.PriceCurrent(),
pos_open = mc_position.PriceOpen(),
pos_stop = mc_position.StopLoss(),
pos_take = mc_position.TakeProfit();
modselsl=SetOrderSL(symbol,opstype,pos_open);
if(price>modselsl) modselsl=mc_symbol.NormalizePrice(price+slip*pip);
modseltp=SetOrderTP(symbol,opstype,pos_open);
if(price<modseltp) modseltp=mc_symbol.NormalizePrice(price-slip*pip);
if(pos_stop==0.0 || pos_take==0.0) {
if(!mc_trade.PositionModify(position_symbol,modselsl,modseltp)) {
mc_trade.CheckResult(check);
Do_Alerts(symbol,"Set SL and TP for "+EnumToString(opstype)+" on "+symbol+" FAILED!!. Return code= "+
(string)mc_trade.ResultRetcode()+". Code description: ["+mc_trade.ResultRetcodeDescription()+"]");
}
}
}
}
}
return;
} //-end SetSLTPOrders
double MCEA::SetOrderSL(const string xsymb,ENUM_POSITION_TYPE type,double atprice) {
slv=0.0;
int x=PairsIdxArray(xsymb);
Pips(xsymb);
RefreshTick(xsymb);
switch(type) {
case (POSITION_TYPE_BUY):
{
slv=mc_symbol.NormalizePrice(atprice-SLval*pip);
break;
}
case (POSITION_TYPE_SELL):
{
slv=mc_symbol.NormalizePrice(atprice+SLval*pip);
break;
}
}
return(slv);
} //-end SetOrderSL()
double MCEA::SetOrderTP(const string xsymb,ENUM_POSITION_TYPE type,double atprice) {
tpv=0.0;
int x=PairsIdxArray(xsymb);
Pips(xsymb);
RefreshTick(xsymb);
switch(type) {
case (POSITION_TYPE_BUY):
{
tpv=mc_symbol.NormalizePrice(atprice+TPval*pip);
break;
}
case (POSITION_TYPE_SELL):
{
tpv=mc_symbol.NormalizePrice(atprice-TPval*pip);
}
}
return(tpv);
} //-end SetOrderTP()
void MCEA::CloseBuyPositions(const string symbol) {
ResetLastError();
int total=PositionsTotal(); // number of open positions
ENUM_POSITION_TYPE closetype = POSITION_TYPE_BUY;
ENUM_ORDER_TYPE type_req = ORDER_TYPE_SELL;
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
//--- iterate over all open positions
for(int i=total-1; i>=0; i--) {
if(mc_position.SelectByIndex(i)) {
//--- Parameters of the order
string position_Symbol = PositionGetSymbol(i);
ulong position_ticket = PositionGetTicket(i);
ENUM_POSITION_TYPE type = mc_position.PositionType();
//--- if the MagicNumber matches
if((position_Symbol==symbol) && (mc_position.Magic()==magicEA)) {
if(type==closetype) {
RefreshTick(position_Symbol);
bool buyclose=mc_trade.PositionClose(position_Symbol,slip);
//--- output information about the closure
PrintFormat("Close Buy #%I64d %s %s",position_ticket,position_Symbol,EnumToString(type));
}
}
}
}
return;
} //-end CloseBuyPositions()
void MCEA::CloseSellPositions(const string symbol) {
ResetLastError();
int total=PositionsTotal(); // number of open positions
ENUM_POSITION_TYPE closetype = POSITION_TYPE_SELL;
ENUM_ORDER_TYPE type_req = ORDER_TYPE_BUY;
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
//--- iterate over all open positions
for(int i=total-1; i>=0; i--) {
if(mc_position.SelectByIndex(i)) {
//--- Parameters of the order
string position_Symbol = PositionGetSymbol(i);
ulong position_ticket = PositionGetTicket(i);
ENUM_POSITION_TYPE type = mc_position.PositionType();
//--- if the MagicNumber matches
if((position_Symbol==symbol) && (mc_position.Magic()==magicEA)) {
if(type==closetype) {
RefreshTick(position_Symbol);
bool sellclose=mc_trade.PositionClose(position_Symbol,slip);
//--- output information about the closure
PrintFormat("Close Sell #%I64d %s %s",position_ticket,position_Symbol,EnumToString(type));
}
}
}
}
return;
} //-end CloseSellPositions()
bool MCEA::CloseAllProfit(void) {
ResetLastError();
int up=1,
dw=-1;
bool orclose=false;
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
int ttlorder=PositionsTotal(); // number of open positions
for(int x=0; x<arrsymbx; x++) {
string symbol=DIRI[x];
int hps=PARSAR05(symbol);
orclose=false;
for(int i=ttlorder-1; i>=0; i--) {
string position_Symbol = PositionGetSymbol(i);
ENUM_POSITION_TYPE type = mc_position.PositionType();
if((position_Symbol==symbol) && (mc_position.Magic()==magicEA)) {
double pos_profit = mc_position.Profit();
double pos_swap = mc_position.Swap();
double pos_comm = mc_position.Commission();
double cur_profit = NormalizeDouble(pos_profit+pos_swap+pos_comm,2);
ulong position_ticket = PositionGetTicket(i);
if(type==POSITION_TYPE_BUY && cur_profit>0.02 && hps==dw) {
RefreshTick(position_Symbol);
orclose = mc_trade.PositionClose(position_Symbol,slip);
//--- output information about the closure
PrintFormat("Close #%I64d %s %s",position_ticket,position_Symbol,EnumToString(type));
} else if(hps==up) {
PrintFormat("Close #%I64d %s %s",position_ticket,"trend is still good");
}
if(type==POSITION_TYPE_SELL && cur_profit>0.02 && hps==up) {
RefreshTick(position_Symbol);
orclose = mc_trade.PositionClose(position_Symbol,slip);
//--- output information about the closure
PrintFormat("Close #%I64d %s %s",position_ticket,position_Symbol,EnumToString(type));
} else if(hps==dw) {
PrintFormat("Close #%I64d %s %s",position_ticket,"trend is still good");
}
}
}
}
return(orclose);
} //-end CloseAllProfit()
bool MCEA::ManualCloseAllProfit(void) {
ResetLastError();
bool orclose=false;
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
int ttlorder=PositionsTotal(); // number of open positions
for(int x=0; x<arrsymbx; x++) {
string symbol=DIRI[x];
orclose=false;
for(int i=ttlorder-1; i>=0; i--) {
string position_Symbol = PositionGetSymbol(i);
ENUM_POSITION_TYPE type = mc_position.PositionType();
if((position_Symbol==symbol) && (mc_position.Magic()==magicEA)) {
double pos_profit = mc_position.Profit(),
pos_swap = mc_position.Swap(),
pos_comm = mc_position.Commission(),
cur_profit = NormalizeDouble(pos_profit+pos_swap+pos_comm,2);
ulong position_ticket = PositionGetTicket(i);
if(type==POSITION_TYPE_BUY && cur_profit>0.02) {
RefreshTick(position_Symbol);
orclose = mc_trade.PositionClose(position_Symbol,slip);
//--- output information about the closure
PrintFormat("Close #%I64d %s %s",position_ticket,position_Symbol,EnumToString(type));
}
if(type==POSITION_TYPE_SELL && cur_profit>0.02) {
RefreshTick(position_Symbol);
orclose = mc_trade.PositionClose(position_Symbol,slip);
//--- output information about the closure
PrintFormat("Close #%I64d %s %s",position_ticket,position_Symbol,EnumToString(type));
}
}
}
}
return(orclose);
} //-end ManualCloseAllProfit()
//-- function: close all order
void MCEA::CloseAllOrders(void) {
ResetLastError();
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
int total=PositionsTotal(); // number of open positions
//--- iterate over all open positions
for(int i=total-1; i>=0; i--) {
//--- if the MagicNumber matches
if(mc_position.Magic()==magicEA) {
string position_Symbol = PositionGetSymbol(i); // symbol of the position
ulong position_ticket = PositionGetTicket(i); // ticket of the the opposite position
ENUM_POSITION_TYPE type = mc_position.PositionType();
RefreshTick(position_Symbol);
bool closepos = mc_trade.PositionClose(position_Symbol,slip);
//--- output information about the closure
PrintFormat("Close #%I64d %s %s",position_ticket,position_Symbol,EnumToString(type));
}
}
return;
} //-end CloseAllOrders()
void MCEA::CheckClose(const string symbx) {
ResetLastError();
Pips(symbx);
datetime to=TimeCurrent(),
from=to-(60),
deal_time =0; // time of a deal execution
int deals=0; //--- total number in the list of deals
double profit_loss =0.0, // Order profit or loss
deal_price =0.0, // deal/order CLOSE price
deal_profit =0.0, // deal profit
deal_swap =0.0, // position swap
deal_comm =0.0; // position commission
long deal_magic =0, // deal magic number
deal_type =0; // Order Type
ulong deal_ticket =0; // deal ticket
string deal_symbol =""; // symbol of the deal
ENUM_DEAL_ENTRY deal_entry =0; // enum deal entry
closetime=TimeCurrent()-(6); // 6 seconds ago
//--- request the entire history
HistorySelect(from,to);
deals=HistoryDealsTotal(); //--- total number in the list of deals
//--- go through deals in a loop
for(int z=deals-1; z>=0 && !IsStopped(); z--) {
deal_ticket = HistoryDealGetTicket(z);
deal_symbol = HistoryDealGetString(deal_ticket,DEAL_SYMBOL);
deal_magic = HistoryDealGetInteger(deal_ticket,DEAL_MAGIC);
deal_entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(deal_ticket,DEAL_ENTRY);
deal_type = (ENUM_DEAL_TYPE)HistoryDealGetInteger(deal_ticket,DEAL_TYPE);
if(deal_symbol==symbx && deal_magic==magicEA) {
if((deal_entry==DEAL_ENTRY_OUT)||(deal_entry==DEAL_ENTRY_OUT_BY)) {
deal_time = (datetime)HistoryDealGetInteger(deal_ticket,DEAL_TIME);
if((deal_time>0) && (deal_time>=closetime)) {
deal_price = HistoryDealGetDouble(deal_ticket,DEAL_PRICE);
deal_profit = HistoryDealGetDouble(deal_ticket,DEAL_PROFIT);
deal_swap = HistoryDealGetDouble(deal_ticket,DEAL_SWAP);
deal_comm = HistoryDealGetDouble(deal_ticket,DEAL_COMMISSION);
profit_loss = NormalizeDouble(deal_profit+deal_swap+deal_comm,2);
string xtype = deal_type==DEAL_TYPE_BUY ? "SELL" : deal_type==DEAL_TYPE_SELL ? "BUY": "";
if(profit_loss>0) {
string ckclose="Close "+xtype+" Position on "+symbx+" at price : "+DoubleToString(deal_price,dgts)+
" OrderCloseTime(): "+TimeToString(deal_time,TIME_DATE|TIME_MINUTES)+
" in profit : "+DoubleToString(profit_loss,2);
Do_Alerts(symbx,ckclose);
}
if(profit_loss<=0) {
string ckclose="Close "+xtype+" Position on "+symbx+" at price : "+DoubleToString(deal_price,dgts)+
" OrderCloseTime(): "+TimeToString(deal_time,TIME_DATE|TIME_MINUTES)+
" in loss : "+DoubleToString(profit_loss,2);
Do_Alerts(symbx,ckclose);
}
break;
}
}
}
}
return;
} //-end CheckClose()
void MCEA::TodayOrders(void) {
ResetLastError();
datetime from=StringToTime(ReqDate(ThisTime(day),0,0));
datetime to=TimeCurrent();
//--- request the entire history
HistorySelect(from,to);
//--- total number in the list of deals
int deals=HistoryDealsTotal();
datetime deal_time =0; // time of a deal execution
ulong deal_ticket =0; // deal ticket
long deal_magic =0, // deal magic number
deal_type =0; // Order Type
double deal_price =0.0, // deal/order CLOSE price
deal_profit =0.0, // deal profit
deal_swap =0.0, // position swap
deal_comm =0.0; // position commission
ENUM_DEAL_ENTRY deal_entry =0; // enum deal entry
string pos_symbol =""; // Position symbol
fixclprofit =0.0; // Order Close profit
floatprofit =0.0; // float position profit
oBm=0; // Order buy
oSm=0; // Order sell
int totalorder=PositionsTotal();
for(int i=0; i<totalorder && !IsStopped(); i++) {
pos_symbol = PositionGetSymbol(i);
long magic = mc_position.Magic();
if(mc_position.Symbol() == pos_symbol && magic==magicEA) {
ENUM_POSITION_TYPE opstype = mc_position.PositionType();
if(opstype == POSITION_TYPE_BUY) {oBm++; floatprofit += mc_position.Profit();}
if(opstype == POSITION_TYPE_SELL) {oSm++; floatprofit += mc_position.Profit();}
}
}
xtto=oBm+oSm;
//--- go through deals in a loop
for(int z=0; z<deals && !IsStopped(); z++) {
deal_ticket = HistoryDealGetTicket(z);
deal_magic = HistoryDealGetInteger(deal_ticket,DEAL_MAGIC);
deal_entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(deal_ticket,DEAL_ENTRY);
deal_type = (ENUM_DEAL_TYPE)HistoryDealGetInteger(deal_ticket,DEAL_TYPE);
if(deal_magic==magicEA) {
if((deal_entry==DEAL_ENTRY_OUT)||(deal_entry==DEAL_ENTRY_OUT_BY)) {
deal_time = (datetime)HistoryDealGetInteger(deal_ticket,DEAL_TIME);
if((deal_time>0) && (deal_time>=from)) {
deal_profit = HistoryDealGetDouble(deal_ticket,DEAL_PROFIT);
deal_swap = HistoryDealGetDouble(deal_ticket,DEAL_SWAP);
deal_comm = HistoryDealGetDouble(deal_ticket,DEAL_COMMISSION);
fixclprofit += NormalizeDouble(deal_profit+deal_swap+deal_comm,2);
}
}
}
}
return;
} //-end TodayOrders()
// function: calculation lots size
double MCEA::MLots(const string symbx) {
int pil,
Lpair,
xsym=-1;
double Lsize=0.0,
sym_Lm=0.0;
string sym_use ="",
sCur1=StringSubstr(symbx,posCur1,3),
sCur2=StringSubstr(symbx,posCur2,3);
if(sCur1=="EUR"||sCur1=="GBP"||sCur1=="AUD"||sCur1=="NZD") pil=0;
if(sCur1=="CAD"||sCur1=="CHF") pil=1;
if(sCur1=="XAU"||sCur1=="XAG") pil=2;
if(sCur1=="USD") pil=3;
switch(pil) {
case 0: sym_use=sCur1+"USD"; break;
case 1: sym_use="USD"+sCur1; break;
case 2: sym_use=symbx; break;
case 3: sym_use=symbx; break;
}
xsym=PairsIdxArray(sym_use);
if(xsym!=-1) sym_use=DIRI[xsym];
Lpair = StringFind(sym_use,"USD",0);
CurrentSymbolSet(sym_use);
double csize = mc_symbol.ContractSize(),
AFMar = mc_account.FreeMargin(),
AFLev = (double)mc_account.Leverage(),
symbid = mc_symbol.Bid(),
Lmaxs = SymbolInfoDouble(symbx,SYMBOL_VOLUME_MAX),
Lmins = SymbolInfoDouble(symbx,SYMBOL_VOLUME_MIN),
useRisk = (Risk/100.0),
PctUse = ((100.0-Risk)/100.0),
NZ1=NonZeroDiv(AFMar*AFLev,csize),
NZ2=NonZeroDiv(AFMar*AFLev,symbid);
if(Lpair>=0 && Lpair<posCur2) {sym_Lm = fmin(Lmaxs,NZ1);}
else {sym_Lm = fmin(Lmaxs,NonZeroDiv(NZ2,csize));}
double sym_Lc = NormalizeDouble(sym_Lm*useRisk,LotDig(symbx)),
asize = NormalizeDouble(sym_Lc/(double)LotPS,LotDig(symbx));
if(mmlot==DynamLot) {
Lsize = NormalizeDouble(asize*PctUse,LotDig(symbx));
} else {
Lsize = Lots;
}
if(Lsize < Lmins) Lsize = Lmins;
if(Lsize > Lmaxs) Lsize = Lmaxs;
double lotsize=NormalizeDouble(Lsize,LotDig(symbx));
return(lotsize);
} //-end MLots()
int MCEA::LotDig(const string symbx) {
double lots_step=SymbolInfoDouble(symbx,SYMBOL_VOLUME_STEP);
if(lots_step==0.01) ldig=2;if(lots_step==0.1) ldig=1;if(lots_step==1.0) ldig=0;
return(ldig);
} //-end LotDig()
double MCEA::NonZeroDiv(double val1,double val2) {
return ((val1==0 || val2==0) ? (0.00) : (val1/val2));
} //-end NonZeroDiv()
// function: write comments on the chart
void MCEA::TradeInfo(void) {
Pips(Symbol());
double spread=SymbolInfoInteger(Symbol(),SYMBOL_SPREAD)/xpip;
string comm="";
TodayOrders();
comm="\n :: Server Date Time : "+string(ThisTime(year))+"."+string(ThisTime(mon))+"."+string(ThisTime(day))+ " "+TimeToString(TimeCurrent(),TIME_SECONDS)+
"\n ------------------------------------------------------------"+
"\n :: robo adxpsar-v4 : debugger e refatoracao para execucao no ativo forex AUD/USD "
"\n :: Broker : "+ TerminalInfoString(TERMINAL_COMPANY)+
"\n :: Expert Name : "+ expname+
"\n :: Acc. Name : "+ mc_account.Name()+
"\n :: Acc. Number : "+ (string)mc_account.Login()+
"\n :: Acc. TradeMode : "+ AccountMode()+
"\n :: Acc. Leverage : 1 : "+ (string)mc_account.Leverage()+
"\n :: Acc. Equity : "+ DoubleToString(mc_account.Equity(),2)+
"\n :: Margin Mode : "+ (string)mc_account.MarginModeDescription()+
"\n :: Magic Number : "+ string(magicEA)+
"\n :: Trade on TF : "+ EnumToString(TFt)+
"\n :: Today Trading : "+ TradingDay()+" : "+hariini+
"\n ------------------------------------------------------------"+
"\n :: Trading Pairs : "+pairs+
"\n :: BUY Market : "+string(oBm)+
"\n :: SELL Market : "+string(oSm)+
"\n :: Total Order : "+string(oBm+oSm)+
"\n :: Order Profit : "+DoubleToString(floatprofit,2)+
"\n :: Fixed Profit : "+DoubleToString(fixclprofit,2)+
"\n :: Float Money : "+DoubleToString(floatprofit,2)+
"\n :: Nett Profit : "+DoubleToString(floatprofit+fixclprofit,2);
Comment(comm);
ChartRedraw(0);
return;
} //-end TradeInfo()
string MCEA::TradingDay(void) {
int trdday=ThisTime(dow);
switch(trdday) {
case 0: daytrade="Sunday"; break;
case 1: daytrade="Monday"; break;
case 2: daytrade="Tuesday"; break;
case 3: daytrade="Wednesday"; break;
case 4: daytrade="Thursday"; break;
case 5: daytrade="Friday"; break;
case 6: daytrade="Saturday"; break;
}
return(daytrade);
} //-end TradingDay()
string MCEA::timehr(int hr,int mn) {
string scon="";
string men=mn==0 ? "00" : string(mn);
int shr=hr==24 ? 0 : hr;
if(shr<10) scon="0"+string(shr)+":"+men;
else scon=string(shr)+":"+men;
return(scon);
} //-end timehr()
bool MCEA::TradingToday(void) {
bool tradetoday=false;
int trdday=ThisTime(dow);
hariini="No";
int ttd[];
ArrayResize(ttd,7);
ttd[0]=ttd0;
ttd[1]=ttd1;
ttd[2]=ttd2;
ttd[3]=ttd3;
ttd[4]=ttd4;
ttd[5]=ttd5;
ttd[6]=ttd6;
if(ttd[trdday]==Yes) {tradetoday=true; hariini="Yes";}
return(tradetoday);
} //-end TradingToday()
string MCEA::ReqDate(int d,int h,int m) {
MqlDateTime mdt;
datetime t=TimeCurrent(mdt);
x_year=mdt.year;
x_mon=mdt.mon;
x_day=d;
x_hour=h;
x_min=m;
x_sec=mdt.sec;
string mdr=string(x_year)+"."+string(x_mon)+"."+string(x_day)+" "+timehr(x_hour,x_min);
return(mdr);
} //-end ReqDate()
int MCEA::ThisTime(const int reqmode) {
MqlDateTime tm;
TimeCurrent(tm);
int valtm=0;
switch(reqmode) {
case 0: valtm=tm.year; break; // Return Year
case 1: valtm=tm.mon; break; // Return Month
case 2: valtm=tm.day; break; // Return Day
case 3: valtm=tm.hour; break; // Return Hour
case 4: valtm=tm.min; break; // Return Minutes
case 5: valtm=tm.sec; break; // Return Seconds
case 6: valtm=tm.day_of_week; break; // Return Day of week (0-Sunday, 1-Monday, ... ,6-Saturday)
case 7: valtm=tm.day_of_year; break; // Return Day number of the year (January 1st is assigned the number value of zero)
}
return(valtm);
} //-end ThisTime()
// function: to known account trade mode
string MCEA::AccountMode() {
//--- Demo, Contest or Real account
ENUM_ACCOUNT_TRADE_MODE account_type=(ENUM_ACCOUNT_TRADE_MODE)AccountInfoInteger(ACCOUNT_TRADE_MODE);
trade_mode="";
switch(account_type) {
case ACCOUNT_TRADE_MODE_DEMO:
trade_mode="Demo";
break;
case ACCOUNT_TRADE_MODE_CONTEST:
trade_mode="Contest";
break;
default:
trade_mode="Real";
break;
}
return(trade_mode);
} //-end AccountMode()
void MCEA::Do_Alerts(const string symbol,string msgText) {
Print("--- "+symbol+": "+msgText+ "\n--- at: ",TimeToString(TimeCurrent(),TIME_DATE|TIME_MINUTES));
if(alerts==Yes) Alert("--- "+symbol+": "+msgText+ "--- at: ",TimeToString(TimeCurrent(),TIME_DATE|TIME_MINUTES));
if(UseEmailAlert==Yes) SendMail(expname,"--- "+symbol+" "+TF2Str(PERIOD_CURRENT)+": "+msgText+ "\n--- at: "+TimeToString(TimeCurrent(),TIME_DATE|TIME_MINUTES));
if(UseSendnotify==Yes) SendNotification(expname+"--- "+symbol+" "+TF2Str(PERIOD_CURRENT)+": "+msgText+ "\n--- at: "+TimeToString(iTime(symbol,0,0),TIME_DATE|TIME_MINUTES));
return;
} //-end Do_Alerts()
string MCEA::TF2Str(ENUM_TIMEFRAMES period) {
switch(period) {
case PERIOD_M1: return("M1");
case PERIOD_M2: return("M2");
case PERIOD_M3: return("M3");
case PERIOD_M4: return("M4");
case PERIOD_M5: return("M5");
case PERIOD_M6: return("M6");
case PERIOD_M10: return("M10");
case PERIOD_M12: return("M12");
case PERIOD_M15: return("M15");
case PERIOD_M20: return("M20");
case PERIOD_M30: return("M30");
case PERIOD_H1: return("H1");
case PERIOD_H2: return("H2");
case PERIOD_H3: return("H3");
case PERIOD_H4: return("H4");
case PERIOD_H6: return("H6");
case PERIOD_H8: return("H8");
case PERIOD_H12: return("H12");
case PERIOD_D1: return("D1");
case PERIOD_W1: return("W1");
case PERIOD_MN1: return("MN1");
}
return(string(period));
} //-end TF2Str()
string MCEA::getUninitReasonText(int reasonCode) {
string text="";
switch(reasonCode) {
case REASON_PROGRAM:
text="The EA has stopped working calling by remove function."; break;
case REASON_REMOVE:
text="Program "+__FILE__+" was removed from chart"; break;
case REASON_RECOMPILE:
text="Program recompiled."; break;
case REASON_CHARTCHANGE:
text="Symbol or timeframe was changed"; break;
case REASON_CHARTCLOSE:
text="Chart was closed"; break;
case REASON_PARAMETERS:
text="Input-parameter was changed"; break;
case REASON_ACCOUNT:
text="Account was changed"; break;
case REASON_TEMPLATE:
text="New template was applied to chart"; break;
case REASON_INITFAILED:
text="The OnInit() handler returned a non-zero value."; break;
case REASON_CLOSE:
text="Terminal closed."; break;
default: text="Another reason"; break;
}
return text;
} //-end getUninitReasonText()
//+------------------------------------------------------------------+
//| ChartEvent function |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
const long &lparam,
const double &dparam,
const string &sparam) {
//--- handling CHARTEVENT_CLICK event ("Clicking the chart")
ResetLastError();
ENUM_TIMEFRAMES CCS=mc.TFt;
if(id==CHARTEVENT_OBJECT_CLICK) {
int lensymbol=StringLen(Symbol());
int lensparam=StringLen(sparam);
//--- if "Set SL All Orders" button is click
if(sparam=="Set SL/TP All Orders") {
mc.SetSLTPOrders();
Alert("-- "+mc.expname+" -- ",Symbol()," -- Set SL/TP All Orders");
//--- unpress the button
ObjectSetInteger(0,"Set SL/TP All Orders",OBJPROP_STATE,false);
ObjectSetInteger(0,"Set SL/TP All Orders",OBJPROP_ZORDER,0);
CreateManualPanel();
}
//--- if "Close All Order" button is click
if(sparam=="Close All Order") {
mc.CloseAllOrders();
Alert("-- "+mc.expname+" -- ",Symbol()," -- Close All Orders");
//--- unpress the button
ObjectSetInteger(0,"Close All Order",OBJPROP_STATE,false);
ObjectSetInteger(0,"Close All Order",OBJPROP_ZORDER,0);
CreateManualPanel();
}
//--- if "Close All Profit" button is click
if(sparam=="Close All Profit") {
mc.ManualCloseAllProfit();
Alert("-- "+mc.expname+" -- ",Symbol()," -- Close All Profit");
//--- unpress the button
ObjectSetInteger(0,"Close All Profit",OBJPROP_STATE,false);
ObjectSetInteger(0,"Close All Profit",OBJPROP_ZORDER,0);
CreateManualPanel();
}
//--- if "X" button is click
if(sparam=="X") {
ObjectsDeleteAll(0,0,OBJ_BUTTON);
ObjectsDeleteAll(0,0,OBJ_LABEL);
ObjectsDeleteAll(0,0,OBJ_RECTANGLE_LABEL);
//--- unpress the button
ObjectSetInteger(0,"X",OBJPROP_STATE,false);
ObjectSetInteger(0,"X",OBJPROP_ZORDER,0);
//--
DeleteButtonX();
mc.PanelExtra=false;
DisplayManualButton();
}
//--- if "M" button is click
if(sparam=="M") {
//--- unpress the button
ObjectSetInteger(0,"M",OBJPROP_STATE,false);
ObjectSetInteger(0,"M",OBJPROP_ZORDER,0);
mc.PanelExtra=true;
CreateManualPanel();
}
//--- if "C" button is click
if(sparam=="C") {
//--- unpress the button
ObjectSetInteger(0,"C",OBJPROP_STATE,false);
ObjectSetInteger(0,"C",OBJPROP_ZORDER,0);
mc.PanelExtra=true;
CreateSymbolPanel();
}
//--- if "R" button is click
if(sparam=="R") {
Alert("-- "+mc.expname+" -- ",Symbol()," -- expert advisor will be Remove from the chart.");
ExpertRemove();
//--- unpress the button
ObjectSetInteger(0,"R",OBJPROP_STATE,false);
ObjectSetInteger(0,"R",OBJPROP_ZORDER,0);
if(!ChartSetSymbolPeriod(0,Symbol(),Period()))
ChartSetSymbolPeriod(0,Symbol(),Period());
DeletePanelButton();
ChartRedraw(0);
}
//--- if Symbol button is click
if(lensparam==lensymbol) {
int sx=mc.PairsIdxArray(sparam);
ChangeChartSymbol(mc.AS30[sx],CCS);
mc.PanelExtra=false;
}
}
return;
} //-end OnChartEvent()
void ChangeChartSymbol(string c_symbol,ENUM_TIMEFRAMES cstf) {
//--- unpress the button
ObjectSetInteger(0,c_symbol,OBJPROP_STATE,false);
ObjectSetInteger(0,c_symbol,OBJPROP_ZORDER,0);
ObjectsDeleteAll(0,0,OBJ_BUTTON);
ObjectsDeleteAll(0,0,OBJ_LABEL);
ObjectsDeleteAll(0,0,OBJ_RECTANGLE_LABEL);
ChartSetSymbolPeriod(0,c_symbol,cstf);
ChartRedraw(0);
return;
} //-end ChangeChartSymbol()
// Width Scaling factor wide button
int WS(int width) {
int res=0,
reswidth=0,
//--- Calculating the scaling factor wide button on a screen
scale_factor=(TerminalInfoInteger(TERMINAL_SCREEN_DPI));
//--- Use of the scaling factor
reswidth=(width * scale_factor) / 96;
double res1=NormalizeDouble(reswidth*1.25,0);
res=int(res1);
return(res);
} //-end WS()
void CreateManualPanel() {
CreateButtonTemplate(0,"TemplateSL",160,35,STYLE_SOLID,5,BORDER_RAISED,clrNONE,clrBurlyWood,clrWhite,CORNER_RIGHT_UPPER,170,45,true);
CreateButtonTemplate(0,"TempStatSL",154,30,STYLE_SOLID,3,BORDER_RAISED,clrNONE,clrGreen,clrWhite,CORNER_RIGHT_UPPER,167,48,true);
CreateButtonClick(0,"Set SL/TP All Orders",143,21,"Bodoni MT Black",10,BORDER_RAISED,"Set SL/TP All Orders",clrNONE,clrRed,clrWhite,ANCHOR_CENTER,CORNER_RIGHT_UPPER,162,56,true,"Set SL/TP All Orders");
CreateButtonTemplate(0,"TemplateS",160,35,STYLE_SOLID,5,BORDER_RAISED,clrNONE,clrBurlyWood,clrWhite,CORNER_RIGHT_UPPER,170,77,true);
CreateButtonTemplate(0,"TempStats",154,30,STYLE_SOLID,3,BORDER_RAISED,clrNONE,clrGreen,clrWhite,CORNER_RIGHT_UPPER,167,79,true);
CreateButtonClick(0,"Close All Order",143,21,"Bodoni MT Black",10,BORDER_RAISED,"Close All Order",clrNONE,clrRed,clrWhite,ANCHOR_CENTER,CORNER_RIGHT_UPPER,162,88,true,"Close All Order");
CreateButtonTemplate(0,"TemplateC",160,35,STYLE_SOLID,5,BORDER_RAISED,clrNONE,clrBurlyWood,clrWhite,CORNER_RIGHT_UPPER,170,109,true);
CreateButtonTemplate(0,"TempStatC",154,30,STYLE_SOLID,3,BORDER_RAISED,clrNONE,clrGreen,clrWhite,CORNER_RIGHT_UPPER,167,111,true);
CreateButtonClick(0,"Close All Profit",143,21,"Bodoni MT Black",10,BORDER_RAISED,"Close All Profit",clrNONE,clrRed,clrWhite,ANCHOR_CENTER,CORNER_RIGHT_UPPER,162,120,true,"Close All Profit");
DeletePanelButton();
CreateButtonClick(0,"X",17,15,"Arial Black",12,BORDER_RAISED,"X",clrNONE,clrWhite,clrRed,ANCHOR_CENTER,CORNER_RIGHT_UPPER,27,31,true,"Close panel");
ChartRedraw(0);
return;
} //-end CreateManualPanel()
void DisplayManualButton(void) {
DeleteButtonX();
CreateButtonClick(0,"M",17,16,"Arial Black",11,BORDER_FLAT,"M",clrWhite,clrWhite,clrRed,ANCHOR_CENTER,CORNER_RIGHT_UPPER,61,21,true,"Open Manual Panel");
CreateButtonClick(0,"C",17,16,"Arial Black",11,BORDER_FLAT,"C",clrWhite,clrWhite,clrRed,ANCHOR_CENTER,CORNER_RIGHT_UPPER,41,21,true,"Change Chart Symbol");
CreateButtonClick(0,"R",17,16,"Arial Black",11,BORDER_FLAT,"R",clrWhite,clrWhite,clrRed,ANCHOR_CENTER,CORNER_RIGHT_UPPER,21,21,true,"Expert Remove");
ChartRedraw(0);
return;
} //-end DisplayManualButton()
bool DisplayManualButton(string a,string b,string c) {
if(ObjectFind(0,a)<0 && ObjectFind(0,b)<0 && ObjectFind(0,c)<0 && !mc.PanelExtra)
return(false);
return(true);
} //-end DisplayManualButton()
void DeleteButtonX(void) {
ObjectDelete(0,"X");
ChartRedraw(0);
return;
} //-end DeleteButtonX()
void DeletePanelButton(void) {
ObjectDelete(0,"M");
ObjectDelete(0,"C");
ObjectDelete(0,"R");
return;
} //-end DeletePanelButton()
void CreateSymbolPanel() {
ResetLastError();
DeletePanelButton();
int sydis=83;
int tsatu=int(mc.sall/2);
CreateButtonTemplate(0,"Template",180,367,STYLE_SOLID,5,BORDER_RAISED,clrYellow,clrBurlyWood,clrWhite,CORNER_RIGHT_UPPER,187,45,true);
CreateButtonTemplate(0,"TempCCS",167,25,STYLE_SOLID,5,BORDER_RAISED,clrYellow,clrBlue,clrWhite,CORNER_RIGHT_UPPER,181,50,true);
CreateButtonClick(0,"X",14,14,"Arial Black",10,BORDER_FLAT,"X",clrWhite,clrWhite,clrRed,ANCHOR_CENTER,CORNER_RIGHT_UPPER,22,48,true,"Close Symbol Panel");
string chsym="Change SYMBOL";
int cspos=int(181/2)+int(StringLen(chsym)/2);
CreateButtontLable(0,"CCS","Bodoni MT Black",chsym,11,clrWhite,ANCHOR_CENTER,CORNER_RIGHT_UPPER,cspos,62,true,"Change Chart Symbol");
for(int i=0; i<tsatu; i++) CreateButtonClick(0,mc.AS30[i],80,17,"Bodoni MT Black",8,BORDER_RAISED,mc.AS30[i],clrYellow,clrBlue,clrWhite,ANCHOR_CENTER,CORNER_RIGHT_UPPER,180,sydis+(i*22),true,"Change to "+mc.AS30[i]);
for(int i=tsatu; i<mc.sall; i++) CreateButtonClick(0,mc.AS30[i],80,17,"Bodoni MT Black",8,BORDER_RAISED,mc.AS30[i],clrYellow,clrBlue,clrWhite,ANCHOR_CENTER,CORNER_RIGHT_UPPER,94,sydis+((i-15)*22),true,"Change to "+mc.AS30[i]);
ChartRedraw(0);
return;
} //-end CreateSymbolPanel()
void CreateButtonClick(long chartid,
string button_name,
int button_x_size,
int button_y_size,
string button_font_model,
int button_font_size,
int button_border,
string button_name_text,
color button_bord_color,
color button_bg_color,
color button_color,
int button_anchor,
int button_corner,
int button_xdist,
int button_ydist,
bool button_hidden,
string tooltip) {
ObjectCreate(chartid,button_name,OBJ_BUTTON,0,0,0); // create button
ObjectSetInteger(chartid,button_name,OBJPROP_XSIZE,WS(button_x_size));
ObjectSetInteger(chartid,button_name,OBJPROP_YSIZE,button_y_size);
ObjectSetString(chartid,button_name,OBJPROP_TEXT,button_name_text);
ObjectSetString(chartid,button_name,OBJPROP_FONT,button_font_model);
ObjectSetInteger(chartid,button_name,OBJPROP_FONTSIZE,button_font_size);
ObjectSetInteger(chartid,button_name,OBJPROP_BORDER_TYPE,button_border);
ObjectSetInteger(chartid,button_name,OBJPROP_BORDER_COLOR,button_bord_color);
ObjectSetInteger(chartid,button_name,OBJPROP_BGCOLOR,button_bg_color);
ObjectSetInteger(chartid,button_name,OBJPROP_COLOR,button_color);
ObjectSetInteger(chartid,button_name,OBJPROP_ANCHOR,button_anchor);
ObjectSetInteger(chartid,button_name,OBJPROP_CORNER,button_corner);
ObjectSetInteger(chartid,button_name,OBJPROP_XDISTANCE,WS(button_xdist));
ObjectSetInteger(chartid,button_name,OBJPROP_YDISTANCE,button_ydist);
ObjectSetInteger(chartid,button_name,OBJPROP_HIDDEN,button_hidden);
ObjectSetString(chartid,button_name,OBJPROP_TOOLTIP,tooltip);
ChartRedraw(0);
return;
} //-end CreateButtonClick()
void CreateButtonTemplate(long chartid,
string obj_name,
int x_size,
int y_size,
int style,
int width,
int border,
color bordcolor,
color bgcolor,
color objcolor,
int corner,
int x_dist,
int y_dist,
bool hidden) {
ObjectCreate(chartid,obj_name,OBJ_RECTANGLE_LABEL,0,0,0); // create Rectangle Label
ObjectSetInteger(chartid,obj_name,OBJPROP_XSIZE,WS(x_size));
ObjectSetInteger(chartid,obj_name,OBJPROP_YSIZE,y_size);
ObjectSetInteger(chartid,obj_name,OBJPROP_STYLE,style);
ObjectSetInteger(chartid,obj_name,OBJPROP_WIDTH,width);
ObjectSetInteger(chartid,obj_name,OBJPROP_BORDER_TYPE,border);
ObjectSetInteger(chartid,obj_name,OBJPROP_BORDER_COLOR,bordcolor);
ObjectSetInteger(chartid,obj_name,OBJPROP_BGCOLOR,bgcolor);
ObjectSetInteger(chartid,obj_name,OBJPROP_COLOR,objcolor);
ObjectSetInteger(chartid,obj_name,OBJPROP_CORNER,corner);
ObjectSetInteger(chartid,obj_name,OBJPROP_XDISTANCE,WS(x_dist));
ObjectSetInteger(chartid,obj_name,OBJPROP_YDISTANCE,y_dist);
ObjectSetInteger(chartid,obj_name,OBJPROP_HIDDEN,hidden);
ChartRedraw(0);
return;
} //-end CreateButtonTemplate()
void CreateButtontLable(long chartid,
string lable_name,
string lable_font_model,
string lable_obj_text,
int lable_font_size,
color lable_color,
int lable_anchor,
int lable_corner,
int lable_xdist,
int lable_ydist,
bool lable_hidden,
string tooltip) {
ObjectDelete(chartid,lable_name);
ObjectCreate(chartid,lable_name,OBJ_LABEL,0,0,0,0,0); // create Lable
ObjectSetInteger(chartid,lable_name,OBJPROP_FONTSIZE,lable_font_size);
ObjectSetString(chartid,lable_name,OBJPROP_FONT,lable_font_model);
ObjectSetString(chartid,lable_name,OBJPROP_TEXT,lable_obj_text);
ObjectSetInteger(chartid,lable_name,OBJPROP_COLOR,lable_color);
ObjectSetInteger(chartid,lable_name,OBJPROP_ANCHOR,lable_anchor);
ObjectSetInteger(chartid,lable_name,OBJPROP_CORNER,lable_corner);
ObjectSetInteger(chartid,lable_name,OBJPROP_XDISTANCE,WS(lable_xdist));
ObjectSetInteger(chartid,lable_name,OBJPROP_YDISTANCE,lable_ydist);
ObjectSetInteger(chartid,lable_name,OBJPROP_HIDDEN,lable_hidden);
ObjectSetString(chartid,lable_name,OBJPROP_TOOLTIP,tooltip);
ChartRedraw(0);
return;
} //-end CreateButtontLable()
View git blame Copy permalink