Author: Roberto Jacobs (3rjfx) | Featured on Forex Home Expert
Introduction of Multi-Currency Expert Advisor.
While this article focuses on the Three Moving Average Crossover, it is important to note that the implementation of a multi-currency expert advisor follows the same principles and templates as outlined in my previous articles. For a detailed guide on creating a multi-currency expert advisor, you can refer to the following resources:
How to create a simple Multi-Currency Expert Advisor using MQL5 with Zigzag and RSI Indicators Signal: This article provides a comprehensive guide on building a multi-currency expert advisor using MQL5, leveraging Zigzag and RSI indicators for signal generation. The step-by-step approach ensures you can easily adapt these techniques for various trading strategies.
How to create a FiboPivotCandleBar Expert Advisor that trades Multi-Currency for MT5: In this article, I explain how to create a multi-currency expert advisor using the FiboPivotCandleBar indicator. The focus is on integrating the indicator into your trading strategy and automating the process for multiple currency pairs.
A Comprehensive Guide to FiboPivotCandleBar: Functions and Performance of the Expert Advisor for MT5: This comprehensive guide dives into the functions and performance of the FiboPivotCandleBar expert advisor, offering insights into its effectiveness and how to optimize it for multi-currency trading.
By following the principles and templates provided in these articles, we can effectively create and implement a multi-currency expert advisor that incorporates the Three Moving Average Crossover strategy.
Introduction the Three Moving Average Crossover Strategy in Forex Trading
What is a moving average?
- "A moving average is a simple technical analysis tool that helps smooth out pricedata by creating a constantly updated average price. It is calculated by adding up a certain number of closing prices and then dividing this total by that number."
- Moving averages are a type of technical analysis tool that smooths out price data to create a trend-following indicator. There are four main types of moving averages:
- 1. Simple Moving Average (SMA)
- The Simple Moving Average (SMA) is the most basic type of moving average. It is calculated by adding up the closing prices of an asset over a specific number of periods and then dividing the total by that number of periods. The SMA gives equal weight to each price point within the chosen period.
- Formula: SMA = (P1 + P2 + ... + Pn) / n. Where P represents the closing prices and n is the number of periods. Where 𝑃 represents the closing prices and 𝑛 is the number of periods.
- Usage: The SMA is commonly used to identify trend directions and potential support and resistance levels. It is straightforward and easy to understand, making it popular among traders.
- 2. Exponential Moving Average (EMA)
- The Exponential Moving Average (EMA) gives more weight to recent prices, making it more responsive to new information. Unlike the SMA, the EMA reacts more quickly to price changes because it applies a smoothing factor to give more importance to recent data points.
- Formula: EMA = [(Pt - EMAy) / (k + 1)] + EMAy. Where Pt is the current price, EMAy is the previous EMA value, and k is the smoothing factor which depends on the number of periods.
- Usage: The EMA is preferred by traders who want to capture trends faster and more accurately. It is useful for identifying short-term trading opportunities and trend reversals.
- 3. Smoothed Moving Average (SMMA)
- The Smoothed Moving Average (SMMA) is a combination of the SMA and the EMA. It provides a smoother line by reducing the noise from random price fluctuations. The SMMA calculates an average similar to the SMA but applies a smoothing factor, which decreases the influence of past prices gradually.
- Formula: SMMA = [(SMMAprevious * (n - 1)) + Pt] / n. Where SMMAprevious is the previous smoothed average, Pt is the current price, and n is the number of periods.
- Usage: The SMMA is ideal for traders looking for a smoother trend line that filters out volatility. It is often used in longer-term trend analysis.
- 4. Linear Weighted Moving Average (LWMA)
- The Linear Weighted Moving Average (LWMA) assigns more weight to recent prices while giving progressively less weight to older prices. This is achieved by multiplying each price point by a weight that decreases linearly from the most recent price to the oldest within the selected period.
- Formula: LWMA = [Σ(Pi * i)] / [Σi]. Where Pi is the price at period i and n is the number of periods.
- Usage: The LWMA is used by traders who want to place a stronger emphasis on recent price actions. It is useful for detecting short-term price movements and trends.
Why moving average crossovers are popular?
- Moving average crossovers are a popular trading strategy because they provide clear signals to buy or sell an asset. When a short-term moving average crosses above a long-term moving average, it often signals a bullish trend, and viceversa.
- In the world of forex trading, the Moving Average Crossover strategy is a popular and effective tool used by both beginners and experienced traders. This strategy involves the use of two or more different moving averages to identify potential buying and selling opportunities in the market. In this article, we will explore the basics of the Moving Average Crossover strategy, how it works, and tips for maximizing its effectiveness.
Introduction:
The Triple Moving Average Crossover strategy is a powerful tool used by forex traders to identify potential trading opportunities. By employing three moving averages with different periods, this strategy aims to increase the accuracy of signals and minimize the chances of false breakouts. In this article, we will delve into the details of this strategy, explaining how it works and how traders can use it to enhance their trading decisions.
Moving Averages Used
In the Triple Moving Average Crossover strategy, three moving averages are utilized:
- Slow MA: 30-period Smoothed Moving Average (SMMA) using the median price. This moving average helps to identify the overall long-term trend.
- Middle MA: 20-period Simple Moving Average (SMA) using the median price. This moving average acts as a filter to smooth out price fluctuations.
- Fast MA: 2-period Simple Moving Average (SMA) using the typical price. This moving average responds quickly to price changes, providing early signals for potential trades.
Buy Signals
The strategy generates buy signals based on the interaction of the three moving averages:
- 1. Signal Up 1: A buy signal is generated when the Fast MA (2-period) crosses above the Slow MA (30-period), and the Middle MA (20-period) is below the Slow MA. This indicates the potential start of an uptrend.
Example: If the Fast MA (2) moves from below to above the Slow MA (30), and the Middle MA (20) remains below the Slow MA, it suggests a bullish signal. - 2. Signal Up 2: Another buy signal occurs when the Middle MA (20-period) crosses above the Slow MA (30-period), and the Fast MA (2-period) subsequently crosses above the Middle MA. This confirms the continuation of the uptrend.
Example: If the Middle MA (20) is above the Slow MA (30) and the Fast MA (2) crosses from below to above the Middle MA (20), it indicates a strong bullish signal.
Sell Signals
Similarly, the strategy generates sell signals when the moving averages align in the opposite direction:
- 1. Signal Down 1: A sell signal is generated when the Fast MA (2-period) crosses below the Slow MA (30-period), and the Middle MA (20-period) is above the Slow MA. This suggests the potential start of a downtrend.
Example: If the Fast MA (2) moves from above to below the Slow MA (30), and the Middle MA (20) remains above the Slow MA, it signals a bearish trend. - 2. Signal Down 2: Another sell signal occurs when the Middle MA (20-period) crosses below the Slow MA (30-period), and the Fast MA (2-period) subsequently crosses below the Middle MA. This confirms the continuation of the downtrend.
Example: If the Middle MA (20) is below the Slow MA (30) and the Fast MA (2) crosses from above to below the Middle MA (20), it indicates a strong bearish signal.
Let's break down the ExpMACross1_MCEA_Config function of ExpMACross1_MCEA Expert Advisor for MT5.
void MCEA::ExpMACross1_MCEA_Config(void)
This function configures the Moving Average Crossover strategy and configures various elements. It sets up the timeframes, moving averages, and various parameters for the trading strategy, such as handling symbol arrays, setting up the moving averages for different timeframes, and configuring risk management settings like stop-loss and take-profit levels.
//+------------------------------------------------------------------+
//| Expert Configuration |
//+------------------------------------------------------------------+
void MCEA::ExpMACross1_MCEA_Config(void)
{
//---
//--
HandlingSymbolArrays(); // With this function we will handle all pairs that will be traded
//--
TFT05=PERIOD_M5;
ENUM_TIMEFRAMES TFs[]={PERIOD_M5,PERIOD_M15,PERIOD_M30,PERIOD_H1,PERIOD_H2,PERIOD_H3,PERIOD_H4,PERIOD_H6,PERIOD_H8,PERIOD_H12,PERIOD_D1};
int arTFs=ArraySize(TFs);
//--
for(int x=0; x<arTFs; x++) if(tfinuse==x) TFt=TFs[x]; // TF for calculation signal
//--
int SMMAL=30;
int SMAMi=20;
int SMAKc=2;
//-- Indicators handle for all symbol
//TesterHideIndicators(true);
//--
for(int x=0; x<arrsymbx; x++)
{
hSMMAL[x]=iMA(DIRI[x],TFt,SMMAL,0,MODE_SMMA,PRICE_MEDIAN); //-- Handle for the Slow MA indicator
hSMAMi[x]=iMA(DIRI[x],TFt,SMAMi,0,MODE_SMA,PRICE_MEDIAN); //-- Handle for the Middle MA indicator
hSMAKc[x]=iMA(DIRI[x],TFt,SMAKc,0,MODE_SMA,PRICE_TYPICAL); //-- Handle for the Fast MA indicator
hPar05[x]=iSAR(DIRI[x],TFT05,SARstep,SARmaxi); //-- Handle for the iSAR indicator for M5 Timeframe
//--
}
//--
minprofit=NormalizeDouble(TSmin/100.0,2);
//--
ALO=(int)mc_account.LimitOrders()>sall ? sall : (int)mc_account.LimitOrders();
if(Close_by_Opps==No)
{
if((int)mc_account.LimitOrders()>=(sall*2)) ALO=sall*2;
else
ALO=(int)(mc_account.LimitOrders()/2);
}
//--
LotPS=(double)ALO;
maxSpread=maxsprd;
if(MQLInfoInteger(MQL_TESTER))
maxSpread=(int)SymbolInfoInteger(Symbol(),SYMBOL_SPREAD);
//--
valSL=TSval==0.0 ? 38.0 : TSval;
valTP=TPval==0.0 ? 35.0 : TPval;
minSL=TSmin==0.0 ? 5.0 : TSmin;
minTP=TPmin==0.0 ? 25.0 : TPmin;
//--
mc_trade.SetExpertMagicNumber(magicEA);
mc_trade.SetDeviationInPoints(slip);
mc_trade.SetMarginMode();
Set_Time_Zone();
//--
return;
//---
} //-end ExpMACross1_MCEA_Config()
//---------//
- Indicator Handles for Each Pair
- In this EA, indicator handles are created for each symbol (pair) that intend to trade. This setup allows the EA to calculate and use indicators specifically for each pair. Let's go through the setup step-by-step:
- 1. Handling Symbol Arrays: This function initializes and handles all the symbols that will be traded. It ensures the EA has access to the required symbols.
- 2. Indicator Handles Setup: For each symbol, the EA creates handles for the moving averages (Slow, Middle, Fast) and the SAR indicator. Here's how it's done:
//-- for(int x=0; x<arrsymbx; x++) { //-- Handle for the Slow MA indicator hSMMAL[x]=iMA(DIRI[x],TFt,SMMAL,0,MODE_SMMA,PRICE_MEDIAN); //-- Handle for the Middle MA indicator hSMAMi[x]=iMA(DIRI[x],TFt,SMAMi,0,MODE_SMA,PRICE_MEDIAN); //-- Handle for the Fast MA indicator hSMAKc[x]=iMA(DIRI[x],TFt,SMAKc,0,MODE_SMA,PRICE_TYPICAL); //-- Handle for the iSAR indicator for M5 Timeframe hPar05[x]=iSAR(DIRI[x],TFT05,SARstep,SARmaxi); //-- } //-- - 3. Explanation of Each Handle:
- hSMMAL[x]: This handle is used to calculate the Slow Moving Average (SMMA) for each symbol. It uses a 30-period setting with the median price (PRICE_MEDIAN).
- hSMAMi[x]: This handle calculates the Middle Moving Average (SMA) for each symbol. It uses a 20-period setting with the median price (PRICE_MEDIAN).
- hSMAKc[x]: This handle calculates the Fast Moving Average (SMA) for each symbol. It uses a 2-period setting with the typical price (PRICE_TYPICAL).
- hPar05[x]: This handle calculates the Parabolic SAR indicator for each symbol. It uses specific SAR step and maximum values and is set for the M5 timeframe.
- 4. Using the Handles in the EA: These handles are used within the EA to perform calculations and make trading decisions based on the Moving Average Crossover strategy. The EA monitors the crossovers of these moving averages to generate buy or sell signals for each symbol.
By setting up these indicator handles for each pair, the EA can accurately calculate the necessary values and generate trading signals for all the symbols in the multi-currency strategy, including XAUUSD and XAGUSD.
Let's break down the ExpertActionTrade function to understand its various components and their purposes.
void MCEA::ExpertActionTrade(void)
{
//---
//--Check Trading Terminal
ResetLastError();
//--
if(!DisplayManualButton("M","C","R")) DisplayManualButton(); //-- Show the expert manual button panel
//--
if(trade_info_display==Yes) mc.TradeInfo(); //-- Displayed Trading Info on Chart
//---
if(!MQLInfoInteger(MQL_TRADE_ALLOWED) && mc.checktml==0) //-- Check whether MT5 Algorithmic trading is Allow or Prohibit
{
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;
}
//--
//---
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++)
{
//--
switch(trademode)
{
case SP:
{
if(mc.DIRI[x]!=Symbol()) continue;
symbol=Symbol();
break;
}
case MP:
{
if(mc.DIRI[x]==Symbol()) symbol=Symbol();
else symbol=mc.DIRI[x];
break;
}
}
//--
mc.CurrentSymbolSet(symbol);
//--
if(mc.TradingToday() && mc.Trade_session())
{
//--
mc.OpOr[x]=mc.GetOpenPosition(symbol); //-- Get trading signals to open positions
//-- //-- and store in the variable OpOr[x]
if(mc.OpOr[x]==mc.Buy) //-- If variable OpOr[x] get result of GetOpenPosition(symbol) as "Buy" (value=1)
{
//--
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.IFNewBarsB(symbol)) {mc.OpenBuy(symbol); mc.PbarB[x]=mc.TbarB[x];}
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
mc.CloseAllProfit();
}
}
if(mc.OpOr[x]==mc.Sell) //-- If variable OpOr[x] get result of GetOpenPosition(symbol) as "Sell" (value=-1)
{
//--
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.IFNewBarsS(symbol)) {mc.OpenSell(symbol); mc.PbarS[x]=mc.TbarS[x];}
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
mc.CloseAllProfit();
}
}
}
//--
mc.CheckOpenPMx(symbol);
//--
if(mc.xtto>0)
{
//--
if(SaveOnRev==Yes) //-- Close Trade and Save profit due to weak signal (Yes)
{
mc.CheckOpenPMx(symbol);
if(mc.profitb[x]>mc.minprofit && 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]>mc.minprofit && 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(UseTCP==Yes) mc.CheckTargetCloseProfit();
//--
if(TrailingSL==Yes) mc.ModifyOrdersSL(symbol,trlby); //-- Use Trailing Stop Loss (Yes)
if(TrailingTP==Yes) mc.ModifyOrdersTP(symbol); //-- Use Trailing Take Profit (Yes)
//--
}
//--
mc.CheckOpenPMx(symbol);
if(Close_by_Opps==No && (mc.xob[x]+mc.xos[x]>1))
{
mc.CheckProfitLoss(symbol);
mc.Do_Alerts(symbol,"Close order due stop in loss.");
}
//--
mc.CheckClose(symbol);
}
//--
mc.psec=mc.ccur;
}
//--
return;
//---
} //-end ExpertActionTrade()
//---------//
ExpertActionTrade Function Explanation.
1. Check Trading Terminal:
- Resets any previous errors to ensure fresh error checking.
- Displays manual button panel for user interaction.
- Displays trading info on the chart if enabled.
2. Check MT5 Algorithmic Trading Status:
- Checks if algorithmic trading is allowed. If not, alerts the user and stops further execution.
3. Time Management:
- Manages the timing of the function to ensure it runs at the correct intervals.
4. Symbol Rotation:
- Rotates through all symbols (pairs) that will be traded. Handles single pair (SP) and multi-pair (MP) trading modes.
5. Trading Logic:
- Checks if trading is allowed today and if the trading session is active.
- Gets trading signals to open positions and executes buy/sell orders based on the signals.
- Manages open positions, ensures that the maximum allowed positions are not exceeded, and handles closing positions based on profit or weak signals.
6. Risk and Trade Management:
- Manages trailing stop loss and trailing take profit.
- Ensures that weak signal positions are closed to save profit.
- Checks and closes orders if they hit the stop-loss limit.
7. Final Checks and Cleanup:
- Ensures all checks are made and closes positions if necessary.
- Returns control back to the main program.
This function encapsulates the entire trading logic, from checking if trading is allowed, processing signals, executing trades, and managing risk. It operates on multiple symbols (pairs) and ensures that trading decisions are made based on the configured strategy and risk management rules.
Let's break down the GetOpenPosition function to understand its components and their purposes:
int MCEA::GetOpenPosition(const string symbol) // Signal Open Position
{
//---
int ret=0;
int rise=1,
down=-1;
//--
int SMAC=SignalMACross1(symbol);
int DirM=DirectionMove(symbol,TFt);
//--
if(SMAC==rise && DirM==rise) ret=rise;
if(SMAC==down && DirM==down) ret=down;
//--
return(ret);
//---
} //-end GetOpenPosition()
//---------//
GetOpenPosition Function Explanation
This function determines the signal for opening a position (buy or sell) based on the Moving Average Crossover strategy and the direction of the market.
1. Initialize Variables:
ret:This variable will store the result, indicating the type of position to open (buy or sell). It is initialized to0.riseanddown: These constants represent the direction of the trade.riseis set to1(indicating a buy signal), anddownis set to-1(indicating a sell signal).
2. Get Signals:
SMAC:This variable stores the result of theSignalMACross1function, which checks for moving average crossovers and returns a signal (riseordown).DirM:This variable stores the result of theDirectionMovefunction, which determines the overall market direction for the given timeframe (TFt).
3. Determine Open Position Signal:
- If both the moving average crossover signal (
SMAC) and the market direction (DirM) indicate a rise (both equal torise), the function setsrettorise, indicating a buy signal. - If both
SMACandDirMindicate a downtrend (both equal todown), the function setsrettodown, indicating a sell signal.
4. Return the Result:
- The function returns the value of
ret, which indicates whether to open a buy position (1), a sell position (-1), or no position (0).
Summary
The GetOpenPosition function integrates the results from the moving average crossover signal and the market direction to generate a coherent trading signal. If both indicators agree on the direction (either up or down), the function returns the corresponding signal to open a buy or sell position. Otherwise, it returns 0, indicating no position should be opened.
Let's break down the SignalMACross1 function to understand how it determines the moving average crossover signals:
nt MCEA::SignalMACross1(const string symbol)
{
//---
int ret=0;
int rise=1,
down=-1;
//--
double BMAL[],
BMAM[],
BMAK[];
//--
ArrayResize(BMAL,arper,arper);
ArrayResize(BMAM,arper,arper);
ArrayResize(BMAK,arper,arper);
//--
int xm=PairsIdxArray(symbol);
UpdatePrice(symbol,TFt);
//--
CopyBuffer(hSMMAL[xm],0,0,arper,BMAL);
CopyBuffer(hSMAMi[xm],0,0,arper,BMAM);
CopyBuffer(hSMAKc[xm],0,0,arper,BMAK);
//--
ArraySetAsSeries(BMAL,true);
ArraySetAsSeries(BMAM,true);
ArraySetAsSeries(BMAK,true);
//--
bool SigMAup1=(BMAK[1]<=BMAL[1] && BMAK[0]>BMAL[0] && BMAM[0]<BMAL[0]);
bool SigMAdw1=(BMAK[1]>=BMAL[1] && BMAK[0]<BMAL[0] && BMAM[0]>BMAL[0]);
//--
bool SigMAup2=(BMAM[0]>BMAL[0] && BMAK[1]<=BMAM[1] && BMAK[0]>BMAM[0]);
bool SigMAdw2=(BMAM[0]<BMAL[0] && BMAK[1]>=BMAM[1] && BMAK[0]<BMAM[0]);
//--
int PPMv=PricePercentMove(symbol,TFt,10.0,0);
//--
if((SigMAup1||SigMAup2) && PPMv==rise) ret=rise;
if((SigMAdw1||SigMAdw2) && PPMv==down) ret=down;
//--
return(ret);
//---
} //-end SignalMACross1()
//---------//
SignalMACross1 Function Explanation
This function checks for moving average crossovers and determines the trading signal based on these crossovers and the price movement.
- 1. Initialize Variables:
- ret: This variable will store the result, indicating the type of signal (buy or sell). It is initialized to 0.
- rise and down: These constants represent the direction of the trade. rise is set to 1 (indicating a buy signal), and down is set to -1 (indicating a sell signal).
- 2. Declare Buffers for Moving Averages:
- BMAL, BMAM, BMAK: These arrays will store the values of the Slow, Middle, and Fast moving averages, respectively.
- 3. Resize Arrays:
- Resizes the arrays to accommodate the required number of periods (arper).
- 4. Get Index and Update Prices:
- xm: Gets the index of the symbol in the pairs array.
- Updates the price data for the specified timeframe (TFt).
- 5. Copy Indicator Buffers:
- Copies the buffer values of the Slow, Middle, and Fast moving averages into the respective arrays.
- 6. Set Arrays as Series:
- Sets the arrays to work as series, where the most recent data is at index 0.
- 7. Determine Crossover Signals:
- Signal Up 1: Checks if the Fast MA crosses above the Slow MA and the Middle MA is below the Slow MA.
- Signal Down 1: Checks if the Fast MA crosses below the Slow MA and the Middle MA is above the Slow MA.
- Signal Up 2: Checks if the Middle MA is above the Slow MA and the Fast MA crosses above the Middle MA.
- Signal Down 2: Checks if the Middle MA is below the Slow MA and the Fast MA crosses below the Middle MA.
- 8. Check Price Movement:
- PPMv: Calls the PricePercentMove function to check the price movement direction.
- 9. Determine Final Signal:
- If any of the "up" signals are true and the price movement indicates a rise, set ret to rise.
- If any of the "down" signals are true and the price movement indicates a downtrend, set ret to down.
- 10. Return the Result:
- The function returns the value of ret, indicating whether to generate a buy signal (1), a sell signal (-1), or no signal (0).
Summary
The SignalMACross1 function checks for specific moving average crossovers and determines the trading signal based on these crossovers and the overall price movement. It ensures that the signals are consistent with the market direction before returning the appropriate trading signal.
Let's break down the PricePercentMove function to understand its components and their purposes:
PricePercentMove Function Explanation
- 1. Initialize Variables:
- ret: This variable will store the result, indicating the direction of the price movement. It is initialized to 0.
- rise and down: These constants represent the direction of the trade. rise is set to 1 (indicating a price rise), and down is set to -1 (indicating a price fall).
- 2. Setup for Calculation:
- br: The number of bars (periods) to be considered, set to shift + 3.
- hasil: A variable to store the calculated result of the price movement.
- move: The threshold percentage move to consider for the direction.
- 3. Update Prices:
- Updates the price data for the specified symbol and timeframe.
- 4. Declare and Resize Array for Close Prices:
- CL: An array to store the close prices.
- Resizes the array to the number of bars (br) and sets it as a series (most recent data at index 0).
- 5. Copy Close Prices:
- Copies the close prices into the array CL for the specified number of bars.
- 6. Calculate Price Movement:
- close_now: The most recent close price.
- close_prev: The previous close price.
- Calculates the percentage change in price between the two close prices. If either price is 0 or EMPTY_VALUE, sets hasil to 0.0. Otherwise, normalizes the percentage change and adjusts it to be a more readable percentage.
- 7. Determine Direction:
- If the percentage move hasil is greater than the threshold move, sets ret to rise.
- If hasil is less than the negative of move, sets ret to down.
- 8. Return the Result:
- The function returns the value of ret, indicating whether the price has risen (1), fallen (-1), or remained within the threshold (0)
Summary
The PricePercentMove function calculates the percentage change in the closing prices of a symbol over a specified period and timeframe. It then determines whether the price has risen, fallen, or remained relatively unchanged based on a specified threshold percentage (pcm). This information is used to identify the direction of the price movement and generate appropriate trading signals.
Let's break down the DirectionMove function to understand how it determines the direction of the bar price movement:
DirectionMove Function Explanation
This function calculates the direction of the price movement of a specific bar in a given timeframe, and returns whether the price is rising or falling.
- 1. Initialize Variables:
- ret: This variable will store the result, indicating the direction of the price movement. It is initialized to 0.
- rise and down: These constants represent the direction of the price movement. rise is set to 1 (indicating a price rise), and down is set to -1 (indicating a price fall).
- 2. Calculate Pips:
- Calls the Pips function to set the pip value for the symbol.
- 3. Normalize Price Difference:
- difud: Calculates the normalized price difference using mc_symbol.NormalizePrice and 1.5 * pip. This threshold is used to determine significant price movements.
- 4. Update Prices:
- Updates the price data for the specified symbol and timeframe.
- 5. Determine Price Direction:
- Checks if the closing price of the current bar (CLOSE[0]) is greater than the opening price plus the threshold (OPEN[0] + difud). If true, sets ret to rise.
- Checks if the closing price of the current bar (CLOSE[0]) is less than the opening price minus the threshold (OPEN[0] - difud). If true, sets ret to down.
- 6. Return the Result:
- The function returns the value of ret, indicating whether the price has risen (1), fallen (-1), or remained within the threshold (0).
Summary
The DirectionMove function calculates the direction of the price movement for a specific bar in a given timeframe. It does this by comparing the closing price to the opening price, with a threshold to filter out insignificant movements. The function returns whether the price is rising, falling, or remains within a negligible range.
Let's break down the GetCloseInWeakSignal function to understand its components and how it determines whether to close a position based on weak signals:
GetCloseInWeakSignal Function Explanation
This function determines if a position should be closed based on weak signals from moving averages, direction, and price percent move.
- 1. Initialize Variables:
- ret: This variable will store the result, indicating whether to close the position. It is initialized to 0.
- rise and down: These constants represent the direction. rise is set to 1, and down is set to -1.
- bar: The number of bars to consider, set to 5.
- x: The index of the symbol in the pairs array.
- 2. Declare and Resize Array for Fast MA:
- BMAK: An array to store the values of the Fast Moving Average.
- Resizes the array to bar size and copies the buffer values of the Fast MA into the array.
- 3. Set Array as Series:
- Sets the array BMAK to work as a series, where the most recent data is at index 0.
- 4. Determine Fast MA Direction:
- BMKup: Checks if the Fast MA is moving up (current value is greater than the previous value).
- BMKdw: Checks if the Fast MA is moving down (current value is less than the previous value).
- 5. Get Direction and Price Percent Move:
- DirM: Calls the DirectionMove function to get the direction of the bar price.
- PPmv: Calls the PricePercentMove function to get the price percent move.
- 6. Determine Close Signal:
- If the existing position (exis) is a sell (down), and the direction (DirM), price percent move (PPmv), and Fast MA (BMKup) all indicate a rise, sets ret to rise.
- If the existing position (exis) is a buy (rise), and the direction (DirM), price percent move (PPmv), and Fast MA (BMKdw) all indicate a fall, sets ret to down.
- 7. Return the Result:
- The function returns the value of ret, indicating whether to close the position (rise or fall) based on weak signals.
Summary
The GetCloseInWeakSignal function checks for weak signals based on the Fast Moving Average direction, bar price direction, and price percent move. If the weak signals indicate that the market is moving against the existing position, it returns a signal to close the position.
Backtesting Period: December 2, 2024 - December 20, 2024
I have backtested this strategy from December 1, 2024, to December 20, 2024. I chose this period because, typically, December experiences highly volatile and even sideways market conditions. If a strategy is not robust, it is likely to incur losses during this time. The Expert Advisor (EA) I developed is a multi-currency EA, covering 28 currency pairs and 2 metal pairs (XAUUSD and XAGUSD).
The backtesting of the Triple Moving Average Crossover strategy was conducted from December 2, 2024, to December 20, 2024, across various currency pairs and metals. The following is a summary of the key performance metrics:
Visual Analysis:
The backtesting results provide a comprehensive summary of the performance of the Triple Moving Average Crossover strategy:
- Balance and Equity Lines: The balance (in blue) and equity (in green) lines show the overall performance, with the balance line generally trending upwards with fluctuations. The equity line exhibits more volatility but also an upward trend.
- Deposit Load: The bar chart below the main graph indicates varying levels of deposit load throughout the period, reflecting the percentage of the deposit being utilized.
- Drawdown: The maximum balance drawdown was 2.15%, reflecting a relatively low risk level. The equity drawdown was slightly higher at 3.51%.
These visual elements provide a clear representation of the strategy's performance, illustrating both profit opportunities and risk levels.
Detailed Analysis:
- Strategy Performance
- The strategy yielded a total profit of $675.43 with a profit factor of 1.38, indicating that the total profits exceeded the total losses.
- Key Metrics
- Expectancy: The expectancy of 2.22 suggests that, on average, each trade generated a profit of 2.22 units.
- Maximum Drawdown: The maximum drawdown of 3.35% indicates a relatively low risk level.
- Win Rates: The win rates for both long and short positions were above 50%, suggesting effectiveness in identifying profitable opportunities.
- Breakdown of Metrics
- Profit Factor: A value of 1.38 indicates that the total profit is greater than the total loss, which is a positive indicator.
- Expectancy: A value of 2.22 indicates that on average, each trade generates a profit of 2.22, which is also a good indicator.
- Win Rate: The combination of win rates for short trades (58.74%) and long trades (67.70%) shows that this strategy is quite effective in identifying profitable opportunities.
- Largest Profit/Loss: The existence of trades with very large profits and losses indicates that this strategy has a high potential for volatility.
- Average Consecutive Wins/Losses: The average number of consecutive wins and losses provides an overview of the consistency of the strategy.
- A Closer Look at the Results
- Profitability: The strategy has demonstrated a consistent ability to generate profits, with the majority of trades resulting in positive returns.
- Potential for Large Profits: The presence of trades with exceptionally large profits indicates the strategy's potential for significant gains.
- Risk Exposure: While most losses were relatively small, the occurrence of a few large losses suggests that the strategy is not entirely risk-free.
Recommendation:
Based on the available data, this strategy has shown fairly good performance during the backtesting period. However, several points need to be considered:
- Short Backtesting Period: The backtesting period is only one month, which may not be sufficient to provide a comprehensive view of long-term performance.
- Recommendation: Extend the backtesting period to see if the results remain consistent over a longer duration.
- Market Volatility: The December 2024 period may have unique market characteristics (e.g., end-of-year, long holidays) that may not reflect general market conditions.
- Recommendation: Perform backtesting during different periods to account for varying market conditions.
- Parameter Variation: Try adjusting the indicator parameters to find the optimal combination.
- Recommendation: Experiment with different parameter settings to identify the most effective configuration.
Conclusion of Backtesting Results: The backtesting results provide a promising initial indication of the strategy'seffectiveness. However, further analysis and testing are necessary to confirm its long-termviability.
Strategy Conclusion:
The Triple Moving Average Crossover strategy is a robust method for forex traders looking to capitalize on market trends. By combining three moving averages with different periods, traders can generate more accurate signals and reduce the likelihood of false breakouts. This strategy not only helps in identifying potential entry and exit points but also provides a clearer picture of the market's overall trend. Remember to combine this strategy with proper risk management techniques to optimize trading performance.
⚠️ Important: Risk Disclaimer
- Demo Testing: You are strongly advised to test this EA on an MT5 Demo Account first to witness how it manages 30 pairs simultaneously.
- Real Account Trading: If you proceed to use this EA for automated trading on a Real Account, you do so at your own risk. Algorithmic trading involves substantial risk to your capital.
Final Words
We hope that this article and the MQL5 Multi-Currency Expert Advisor program will be useful for traders in learning and generating new ideas, which can ultimately make money from forex trading.
If you would like to receive a source program for this article, please send a request via the Contact Us form page, and I will send it to your email, source code: ExpMACross1_MCEA
If you have any ideas for developing this EA program, please leave your comments below this article.
Thanks for reading this article.
Risk Warning: Trading Forex and CFDs involves significant risk and may not be suitable for all investors. All content provided is for educational purposes only.
//+------------------------------------------------------------------+
//| ExpMACross1_MCEA.mq5 |
//| Copyright 2024, Roberto Jacobs (3rjfx) ~ Date: 2025-01-01 |
//| https://www.mql5.com/en/users/3rjfx |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Roberto Jacobs (3rjfx) ~ Date: 2025-01-01"
#property link "https://www.mql5.com/en/users/3rjfx"
#property version "1.00"
#property strict
#property description "The Expert ExpMACross1_MCEA is the Automated Trading Multi Currency Forex Expert Advisor for MetaTrader 5"
#property description "by using four Moving Average indicator signal which trade Multiple Pairs in one Chart."
#property description "version: 1.00 ~ Update number: 1 ~ Last update: 2025/01/01 @18:38 (PM) WIT (Western Indonesian Time)"
#property description "WARNING:"
#property description "In any case the author is not liable for any damage or loss whatsever."
#property description "Sometimes high profits can be disrupted by a row of losses."
#property description "In the Forex online trading, it is impossible to always profit."
//#property icon "\\Images\\ExpMACross1_MCEA.ico";
//+------------------------------------------------------------------+
//| Include |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\AccountInfo.mqh>
#include <MovingAverages.mqh>
//--
CTrade mc_trade;
CSymbolInfo mc_symbol;
CPositionInfo mc_position;
CAccountInfo mc_account;
//---
//--
enum tm_zone
{
Cus_Session, // Trading on Custom Session
New_Zealand, // Trading on New Zealand Session
Australia, // Trading on Autralia Sydney Session
Asia_Tokyo, // Trading on Asia Tokyo Session
Europe_London, // Trading on Europe London Session
US_New_York // Trading on US New York Session
};
//--
enum swhour
{
hr_00=0, // 00:00
hr_01=1, // 01:00
hr_02=2, // 02:00
hr_03=3, // 03:00
hr_04=4, // 04:00
hr_05=5, // 05:00
hr_06=6, // 06:00
hr_07=7, // 07:00
hr_08=8, // 08:00
hr_09=9, // 09:00
hr_10=10, // 10:00
hr_11=11, // 11:00
hr_12=12, // 12:00
hr_13=13, // 13:00
hr_14=14, // 14:00
hr_15=15, // 15:00
hr_16=16, // 16:00
hr_17=17, // 17:00
hr_18=18, // 18:00
hr_19=19, // 19:00
hr_20=20, // 20:00
hr_21=21, // 21:00
hr_22=22, // 22:00
hr_23=23 // 23:00
};
//--
enum inmnt
{
mn_00=0, // Minute 0
mn_05=5, // Minute 5
mn_10=10, // Minute 10
mn_15=15, // Minute 15
mn_20=20, // Minute 20
mn_25=25, // Minute 25
mn_30=30, // Minute 30
mn_35=35, // Minute 35
mn_40=40, // Minute 40
mn_45=45, // Minute 45
mn_50=50, // Minute 50
mn_55=55 // Minute 55
};
//--
enum PairsTrade
{
All30, // All Forex 30 Pairs
TrdWi, // Trader Wishes Pairs
Usds, // Forex USD Pairs
Eurs, // Forex EUR Pairs
Gbps, // Forex GBP Pairs
Auds, // Forex AUD Pairs
Nzds, // Forex NZD Pairs
Cads, // Forex CDD Pairs
Chfs, // Forex CHF Pairs
Jpys // Forex JPY Pairs
};
//--
enum YN
{
No,
Yes
};
//--
enum mmt
{
FixedLot, // Fixed Lot Size
DynamLot // Dynamic Lot Size
};
//--
enum TFUSE
{
TFM5, // PERIOD_M5
TFM15, // PERIOD_M15
TFM30, // PERIOD_M30
TFH1, // PERIOD_H1
TFH2, // PERIOD_H2
TFH3, // PERIOD_H3
TFH4, // PERIOD_H4
TFH6, // PERIOD_H6
TFH8, // PERIOD_H8
TFH12, // PERIOD_H12
TFD1 // PERIOD_D1
};
//--
enum MS
{
SP, // Single Pair
MP // Multi Pairs
};
//--
enum TrType
{
byprice, // Trailing Stop by Price
byHiLo // Trailing Stop in HIGH or LOW bar
};
//--
//---
input group "=== Global Strategy EA Parameter ==="; // Global Strategy EA Parameter
input TFUSE tfinuse = TFH1; // Select Expert TimeFrame, default PERIOD_H4
//---
input group "=== Select Pairs to Trade ==="; // Selected Pairs to trading
input MS trademode = MP; // Select Trading Pairs Mode (Multi or Single)
input PairsTrade usepairs = All30; // Select Pairs to Use
input string traderwishes = "eg. eurusd,usdchf"; // If Use Trader Wishes Pairs, input pair name here, separate by comma
//--
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
input double maxmrgn = 80.0; // Input Maximum Free Margin from Equity to Trade (in Percent)
input double maxsprd = 9.0; // Input Maximum Pair's Spread to Trade (in Pips)
//--Trade on Specific Time
input group "=== Trade on Specific Time ==="; // Trade on Specific Time
input YN trd_time_zone = Yes; // Select If You Like to Trade on Specific Time Zone
input tm_zone session = Cus_Session; // Select Trading Time Zone
input swhour stsescuh = hr_00; // Time Hour to Start Trading Custom Session (0-23)
input inmnt stsescum = mn_15; // Time Minute to Start Trading Custom Session (0-55)
input swhour clsescuh = hr_23; // Time Hour to Stop Trading Custom Session (0-23)
input inmnt clsescum = mn_55; // Time Minute to Stop Trading Custom Session (0-55)
//--Day Trading On/Off
input group "=== Day Trading On/Off ==="; // Day Trading On/Off
input YN ttd0 = No; // 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
//-- Order Stop Loss
input group "=== Order Stop Loss ==="; // Order Stop Loss
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 = 38; // If Not Use Automatic SL - Input SL value in Pips
//-- Trailing Stop Loss
input group "=== Trailing Stop Loss ==="; // Trailing Stop Loss
input YN TrailingSL = Yes; // Use Trailing Stop Loss (Yes) or (No)
input TrType trlby = byprice; // Select Trailing Stop Type
input double TSval = 10.0; // If Use Trailing Stop by Price Input value in Pips
input double TSmin = 5.0; // Minimum Pips to start Trailing Stop
//-- Order Take Profit
input group "=== Order Take Profit ==="; // Order Take Profit
input YN use_tp = Yes; // Use Order Take Profit (Yes) or (No)
input YN autotp = No; // Use Automatic Calculation Take Profit (Yes) or (No)
input double TPval = 35.0; // If Not Use Automatic TP - Input TP value in Pips
//-- Trailing Take Profit
input group "=== Trailing Take Profit ==="; // Trailing Take Profit
input YN TrailingTP = No; // Use Trailing Take Profit (Yes) or (No)
input double TPmin = 25.0; // Input Trailing Profit Value in Pips
//-- Options to Close Orders
input group "=== Options to Close Orders ==="; // Options to Close Orders
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)
input YN UseTCP = Yes; // Use target to Close Profit
input double TCPUse = 2.0; // Input Target every time to close (in percentage of Balance)
//--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 = No; // Send Notification (Yes) or (No)
input YN trade_info_display = Yes; // Select Display Trading Info on Chart (Yes) or (No)
input ulong magicEA = 20250101; // Expert ID (Magic Number)
//---
//---------//
//+------------------------------------------------------------------+
//| Class for working Expert Advisor |
//+------------------------------------------------------------------+
class MCEA
{
//---
private:
//----
int x_year; // Year
int x_mon; // Month
int x_day; // Day of the month
int x_hour; // Hour in a day
int x_min; // Minutes
int x_sec; // Seconds
//--
int oBm,
oSm,
ldig;
//--- Variables used in prefix and suffix symbols
int posCur1,
posCur2;
int inpre,
insuf;
bool symbfix;
string pre,suf;
string prefix,suffix;
//--- Variables are used in Trading Time Zone
int ishour,
onhour;
datetime rem,
znop,
zncl,
zntm;
datetime SesCuOp,
SesCuCl,
Ses01Op,
Ses01Cl,
Ses02Op,
Ses02Cl,
Ses03Op,
Ses03Cl,
Ses04Op,
Ses04Cl,
Ses05Op,
Ses05Cl,
SesNoOp,
SesNoCl;
//--
string tz_ses,
tz_opn,
tz_cls;
//--
string tmopcu,
tmclcu,
tmop01,
tmcl01,
tmop02,
tmcl02,
tmop03,
tmcl03,
tmop04,
tmcl04,
tmop05,
tmcl05,
tmopno,
tmclno;
//----------------------
//--
double LotPS;
double point;
double slv,
tpv,
pip,
xpip;
double valSL,
valTP,
minSL,
minTP;
double SARstep,
SARmaxi;
double floatprofit,
fixclprofit;
//--
string pairs,
hariini,
daytrade,
trade_mode;
//--
double OPEN[],
HIGH[],
LOW[],
CLOSE[];
datetime TIME[];
datetime closetime;
//--
//------------
//------------
void SetSymbolNamePS(void);
void HandlingSymbolArrays(void);
void Set_Time_Zone(void);
void Time_Zone(void);
bool Trade_session(void);
string PosTimeZone(void);
int ThisTime(const int reqmode);
int ReqTime(datetime reqtime,const int reqmode);
int LotDig(const string symbol);
//--
int DirectionMove(const string symbol,const ENUM_TIMEFRAMES stf);
int PARSAR05(const string symbol);
int SignalMACross1(const string symbol);
int PricePercentMove(const string symbol,const ENUM_TIMEFRAMES stf,double pcm,int shift);
//--
bool CheckProfit(const string symbol,ENUM_POSITION_TYPE intype);
bool CheckLoss(const string symbol,ENUM_POSITION_TYPE intype);
//--
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 ReturnsOrderType(ENUM_ORDER_TYPE ordtype);
string GetCommentForOrder(void) { return(expname); }
//------------
public:
//---
//-- ExpMACross1_MCEA_Config --
string DIRI[],
AS30[],
VSym[];
string SPC[];
string USD[];
string EUR[];
string GBP[];
string AUD[];
string NZD[];
string CAD[];
string CHF[];
string JPY[];
//--
string expname;
//--
int hSMMAL[],
hSMAMi[],
hSMAKc[];
int hPar05[];
int ALO,
dgts,
arrsar,
arrsymbx;
int sall,
arusd,
areur,
aretc,
arspc,
arper;
ulong slip;
//--
double profitb[],
profits[];
double minprofit;
double spreadx[];
double maxSpread;
//--
int Buy,
Sell;
int ccur,
psec,
xtto,
checktml;
int OpOr[],xob[],xos[];
//--
int 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)
//--
ENUM_TIMEFRAMES TFt,
TFT05;
//--
datetime PbarB[],
TbarB[],
PbarS[],
TbarS[];
//--
bool PanelExtra;
//------------
MCEA(void);
~MCEA(void);
//------------
//--
virtual void ExpMACross1_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 CloseAllOrders(void);
void CheckClose(const string symbx);
void TodayOrders(void);
void UpdatePrice(const string symbol,ENUM_TIMEFRAMES xtf,int bars=0);
void RefreshPrice(const string symbx,ENUM_TIMEFRAMES xtf,int bars);
void CheckTargetCloseProfit(void);
//--
bool CheckSpread(const string symbol);
bool GoodMarginTrade(const string symbol,ENUM_ORDER_TYPE _cmd,double lotsz,double atprice);
bool RefreshTick(const string symbx);
bool TradingToday(void);
bool OpenBuy(const string symbol);
bool OpenSell(const string symbol);
bool ModifyOrdersSL( const string symbol,int TS_type);
bool ModifyOrdersTP(const string symbol);
bool CloseAllProfit(void);
bool ManualCloseAllProfit(void);
bool CheckProfitLoss(const string symbol);
bool CloseBuyPositions(const string symbol);
bool CloseSellPositions(const string symbol);
bool IFNewBarsB(const string symbol);
bool IFNewBarsS(const string symbol);
//--
int PairsIdxArray(const string symbol);
int ValidatePairs(const string symbol);
int GetOpenPosition(const string symbol);
int GetCloseInWeakSignal(const string symbol,int exis);
//--
string getUninitReasonText(int reasonCode);
//--
//------------
//---
}; //-end class MCEA
//---------//
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(125),
checktml(0),
SARmaxi(0.2),
SARstep(0.02),
expname("ExpMAx1_MCEA"),
closetime(TimeCurrent())
{
}
//---------//
//+------------------------------------------------------------------+
//| Destructor |
//+------------------------------------------------------------------+
MCEA::~MCEA(void)
{
}
//---------//
//+------------------------------------------------------------------+
//| Expert Configuration |
//+------------------------------------------------------------------+
void MCEA::ExpMACross1_MCEA_Config(void)
{
//---
//--
HandlingSymbolArrays(); // With this function we will handle all pairs that will be traded
//--
TFT05=PERIOD_M5;
ENUM_TIMEFRAMES TFs[]={PERIOD_M5,PERIOD_M15,PERIOD_M30,PERIOD_H1,PERIOD_H2,PERIOD_H3,PERIOD_H4,PERIOD_H6,PERIOD_H8,PERIOD_H12,PERIOD_D1};
int arTFs=ArraySize(TFs);
//--
for(int x=0; x<arTFs; x++) if(tfinuse==x) TFt=TFs[x]; // TF for calculation signal
//--
int SMMAL=30;
int SMAMi=20;
int SMAKc=2;
//-- Indicators handle for all symbol
TesterHideIndicators(true);
//--
for(int x=0; x<arrsymbx; x++)
{
hSMMAL[x]=iMA(DIRI[x],TFt,SMMAL,0,MODE_SMMA,PRICE_MEDIAN); //-- Handle for the Slow MA indicator
hSMAMi[x]=iMA(DIRI[x],TFt,SMAMi,0,MODE_SMA,PRICE_MEDIAN); //-- Handle for the Middle MA indicator
hSMAKc[x]=iMA(DIRI[x],TFt,SMAKc,0,MODE_SMA,PRICE_TYPICAL); //-- Handle for the Fast MA indicator
hPar05[x]=iSAR(DIRI[x],TFT05,SARstep,SARmaxi); //-- Handle for the iSAR indicator for M5 Timeframe
//--
}
//--
minprofit=NormalizeDouble(TSmin/100.0,2);
//--
ALO=(int)mc_account.LimitOrders()>sall ? sall : (int)mc_account.LimitOrders();
if(Close_by_Opps==No)
{
if((int)mc_account.LimitOrders()>=(sall*2)) ALO=sall*2;
else
ALO=(int)(mc_account.LimitOrders()/2);
}
//--
LotPS=(double)ALO;
maxSpread=maxsprd;
if(MQLInfoInteger(MQL_TESTER))
maxSpread=(int)SymbolInfoInteger(Symbol(),SYMBOL_SPREAD);
//--
valSL=TSval==0.0 ? 38.0 : TSval;
valTP=TPval==0.0 ? 35.0 : TPval;
minSL=TSmin==0.0 ? 5.0 : TSmin;
minTP=TPmin==0.0 ? 25.0 : TPmin;
//--
mc_trade.SetExpertMagicNumber(magicEA);
mc_trade.SetDeviationInPoints(slip);
mc_trade.SetMarginMode();
Set_Time_Zone();
//--
return;
//---
} //-end ExpMACross1_MCEA_Config()
//---------//
void MCEA::HandlingSymbolArrays(void)
{
//---
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 USDs[]={"USDCAD","USDCHF","USDJPY","AUDUSD","EURUSD","GBPUSD","NZDUSD","XAUUSD","XAGUSD"}; // USD pairs
string EURs[]={"EURAUD","EURCAD","EURCHF","EURGBP","EURJPY","EURNZD","EURUSD"}; // EUR pairs
string GBPs[]={"GBPAUD","GBPCAD","GBPCHF","EURGBP","GBPJPY","GBPNZD","GBPUSD"}; // GBP pairs
string AUDs[]={"AUDCAD","AUDCHF","EURAUD","GBPAUD","AUDJPY","AUDNZD","AUDUSD"}; // AUD pairs
string NZDs[]={"AUDNZD","NZDCAD","NZDCHF","EURNZD","GBPNZD","NZDJPY","NZDUSD"}; // NZD pairs
string CADs[]={"AUDCAD","CADCHF","EURCAD","GBPCAD","CADJPY","NZDCAD","USDCAD"}; // CAD pairs
string CHFs[]={"AUDCHF","CADCHF","EURCHF","GBPCHF","NZDCHF","CHFJPY","USDCHF"}; // CHF pairs
string JPYs[]={"AUDJPY","CADJPY","CHFJPY","EURJPY","GBPJPY","NZDJPY","USDJPY"}; // JPY pairs
//--
sall=ArraySize(All30);
arusd=ArraySize(USDs);
areur=ArraySize(EURs);
aretc=ArraySize(JPYs);
ArrayResize(VSym,sall,sall);
ArrayCopy(VSym,All30,0,0,WHOLE_ARRAY);
//--
if(usepairs==TrdWi && StringFind(traderwishes,"eg.",0)<0)
{
string to_split=traderwishes; // A string to split into substrings pairs name
string sep=","; // A separator as a character
ushort u_sep; // The code of the separator character
//--- Get the separator code
u_sep=StringGetCharacter(sep,0);
//--- Split the string to substrings
int p=StringSplit(to_split,u_sep,SPC);
if(p>0)
{
for(int i=0; i<p; i++) StringToUpper(SPC[i]);
//--
for(int i=0; i<p; i++)
{
if(ValidatePairs(SPC[i])<0) ArrayRemove(SPC,i,1);
}
}
arspc=ArraySize(SPC);
}
//--
SetSymbolNamePS(); // With this function we will detect whether the Symbol Name has a prefix and/or suffix
//--
if(inpre>0 || insuf>0)
{
if(usepairs==TrdWi && arspc>0)
{
for(int t=0; t<arspc; t++)
{
SPC[t]=pre+SPC[t]+suf;
}
}
//--
for(int t=0; t<sall; t++)
{
All30[t]=pre+All30[t]+suf;
}
for(int t=0; t<arusd; t++)
{
USDs[t]=pre+USDs[t]+suf;
}
for(int t=0; t<areur; t++)
{
EURs[t]=pre+EURs[t]+suf;
}
for(int t=0; t<aretc; t++)
{
GBPs[t]=pre+GBPs[t]+suf;
}
for(int t=0; t<aretc; t++)
{
AUDs[t]=pre+AUDs[t]+suf;
}
for(int t=0; t<aretc; t++)
{
NZDs[t]=pre+NZDs[t]+suf;
}
for(int t=0; t<aretc; t++)
{
CADs[t]=pre+CADs[t]+suf;
}
for(int t=0; t<aretc; t++)
{
CHFs[t]=pre+CHFs[t]+suf;
}
for(int t=0; t<aretc; t++)
{
JPYs[t]=pre+JPYs[t]+suf;
}
}
//--
ArrayCopy(VSym,All30,0,0,WHOLE_ARRAY);
ArrayResize(AS30,sall,sall);
ArrayCopy(AS30,All30,0,0,WHOLE_ARRAY);
for(int x=0; x<sall; x++) {SymbolSelect(AS30[x],true);}
if(ValidatePairs(Symbol())>=0) symbfix=true;
if(!symbfix)
{
Alert("Expert Advisors will not trade on pairs "+Symbol());
Alert("-- "+expname+" -- ",Symbol()," -- expert advisor will be Remove from the chart.");
ExpertRemove();
}
//--
switch(trademode)
{
case SP: pairs="Single Currency ("+Symbol()+")"; break;
case MP: pairs="Multi Currency"; break;
}
//--
if(trademode==MP)
{
switch(usepairs)
{
case 0: // All Forex & Metal 30 Pairs
{
ArrayResize(DIRI,sall,sall);
arrsymbx=sall;
ArraySymbolResize();
ArrayCopy(DIRI,All30,0,0,WHOLE_ARRAY);
pairs="Multi Currency "+string(sall)+" Pairs";
//--
break;
}
case 1: // Trader wishes pairs
{
ArrayResize(DIRI,arspc,arspc);
arrsymbx=arspc;
ArraySymbolResize();
ArrayCopy(DIRI,SPC,0,0,WHOLE_ARRAY);
pairs="("+string(arspc)+") Trader Wishes Pairs";
//--
break;
}
case 2: // USD pairs
{
ArrayResize(DIRI,arusd,arusd);
arrsymbx=arusd;
ArraySymbolResize();
ArrayCopy(DIRI,USDs,0,0,WHOLE_ARRAY);
pairs="("+string(arusd)+") Multi Currency USD Pairs";
//--
break;
}
case 3: // EUR pairs
{
ArrayResize(DIRI,areur,areur);
arrsymbx=aretc;
ArraySymbolResize();
ArrayCopy(DIRI,EURs,0,0,WHOLE_ARRAY);
pairs="("+string(aretc)+") Forex EUR Pairs";
//--
break;
}
case 4: // GBP pairs
{
ArrayResize(DIRI,aretc,aretc);
arrsymbx=aretc;
ArraySymbolResize();
ArrayCopy(DIRI,GBPs,0,0,WHOLE_ARRAY);
pairs="("+string(aretc)+") Forex GBP Pairs";
//--
break;
}
case 5: // AUD pairs
{
ArrayResize(DIRI,aretc,aretc);
arrsymbx=aretc;
ArraySymbolResize();
ArrayCopy(DIRI,AUDs,0,0,WHOLE_ARRAY);
pairs="("+string(aretc)+") Forex AUD Pairs";
//--
break;
}
case 6: // NZD pairs
{
ArrayResize(DIRI,aretc,aretc);
arrsymbx=aretc;
ArraySymbolResize();
ArrayCopy(DIRI,NZDs,0,0,WHOLE_ARRAY);
pairs="("+string(aretc)+") Forex NZD Pairs";
//--
break;
}
case 7: // CAD pairs
{
ArrayResize(DIRI,aretc,aretc);
arrsymbx=aretc;
ArraySymbolResize();
ArrayCopy(DIRI,CADs,0,0,WHOLE_ARRAY);
pairs="("+string(aretc)+") Forex CAD Pairs";
//--
break;
}
case 8: // CHF pairs
{
ArrayResize(DIRI,aretc,aretc);
arrsymbx=aretc;
ArraySymbolResize();
ArrayCopy(DIRI,CHFs,0,0,WHOLE_ARRAY);
pairs="("+string(aretc)+") Forex CHF Pairs";
//--
break;
}
case 9: // JPY pairs
{
ArrayResize(DIRI,aretc,aretc);
arrsymbx=aretc;
ArraySymbolResize();
ArrayCopy(DIRI,JPYs,0,0,WHOLE_ARRAY);
pairs="("+string(aretc)+") Forex JPY Pairs";
//--
break;
}
}
}
//--
return;
//---
} //-end HandlingSymbolArrays()
//---------//
void MCEA::SetSymbolNamePS(void)
{
//---
int sym_Lenpre=0;
int sym_Lensuf=0;
string sym_pre="";
string sym_suf="";
SymbolSelect(Symbol(),true);
string insymbol=Symbol();
int inlen=StringLen(insymbol);
int toseek=-1;
string dep="";
string bel="";
string sym_use ="";
int pairx=-1;
string xcur[]={"EUR","GBP","AUD","NZD","USD","CAD","CHF"}; // 7 major currency
int xcar=ArraySize(xcur);
//--
for(int x=0; x<xcar; x++)
{
toseek=StringFind(insymbol,xcur[x],0);
if(toseek>=0)
{
pairx=x;
break;
}
}
if(pairx>=0)
{
int awl=toseek-3 <0 ? 0 : toseek-3;
int sd=StringFind(insymbol,"SD",0);
if(toseek==0 && sd<4)
{
dep=StringSubstr(insymbol,toseek,3);
bel=StringSubstr(insymbol,toseek+3,3);
sym_use=dep+bel;
}
else
if(toseek>0)
{
dep=StringSubstr(insymbol,toseek,3);
bel=StringSubstr(insymbol,toseek+3,3);
sym_use=dep+bel;
}
else
{
dep=StringSubstr(insymbol,awl,3);
bel=StringSubstr(insymbol,awl+3,3);
sym_use=dep+bel;
}
}
//--
string sym_nmx=sym_use;
int lensx=StringLen(sym_nmx);
//--
if(inlen>lensx && lensx==6)
{
sym_Lenpre=StringFind(insymbol,sym_nmx,0);
sym_Lensuf=inlen-lensx-sym_Lenpre;
//--
if(sym_Lenpre>0)
{
sym_pre=StringSubstr(insymbol,0,sym_Lenpre);
for(int i=0; i<xcar; i++)
if(StringFind(sym_pre,xcur[i],0)>=0) sym_pre="";
}
if(sym_Lensuf>0)
{
sym_suf=StringSubstr(insymbol,sym_Lenpre+lensx,sym_Lensuf);
for(int i=0; i<xcar; i++)
if(StringFind(sym_suf,xcur[i],0)>=0) sym_suf="";
}
}
//--
pre=sym_pre;
suf=sym_suf;
inpre=StringLen(pre);
insuf=StringLen(suf);
posCur1=inpre;
posCur2=posCur1+3;
//--
return;
//---
} //-end SetSymbolNamePS()
//---------//
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit(void)
{
//---
mc.ExpMACross1_MCEA_Config();
//--
return(INIT_SUCCEEDED);
//---
} //-end OnInit()
//---------//
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---
Comment("");
//-- Release all handle indicators for all symbols
for(int x=0; x<mc.arrsymbx; x++)
{
IndicatorRelease(mc.hSMMAL[x]);
IndicatorRelease(mc.hSMAMi[x]);
IndicatorRelease(mc.hSMAKc[x]);
IndicatorRelease(mc.hPar05[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();
//--
if(!DisplayManualButton("M","C","R")) DisplayManualButton(); //-- Show the expert manual button panel
//--
if(trade_info_display==Yes) mc.TradeInfo(); //-- Displayed Trading Info on Chart
//---
if(!MQLInfoInteger(MQL_TRADE_ALLOWED) && mc.checktml==0) //-- Check whether MT5 Algorithmic trading is Allow or Prohibit
{
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;
}
//--
//---
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++)
{
//--
switch(trademode)
{
case SP:
{
if(mc.DIRI[x]!=Symbol()) continue;
symbol=Symbol();
break;
}
case MP:
{
if(mc.DIRI[x]==Symbol()) symbol=Symbol();
else symbol=mc.DIRI[x];
break;
}
}
//--
mc.CurrentSymbolSet(symbol);
//--
if(mc.TradingToday() && mc.Trade_session())
{
//--
mc.OpOr[x]=mc.GetOpenPosition(symbol); //-- Get trading signals to open positions
//-- //-- and store in the variable OpOr[x]
if(mc.OpOr[x]==mc.Buy) //-- If variable OpOr[x] get result of GetOpenPosition(symbol) as "Buy" (value=1)
{
//--
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.IFNewBarsB(symbol)) {mc.OpenBuy(symbol); mc.PbarB[x]=mc.TbarB[x];}
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
mc.CloseAllProfit();
}
}
if(mc.OpOr[x]==mc.Sell) //-- If variable OpOr[x] get result of GetOpenPosition(symbol) as "Sell" (value=-1)
{
//--
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.IFNewBarsS(symbol)) {mc.OpenSell(symbol); mc.PbarS[x]=mc.TbarS[x];}
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
mc.CloseAllProfit();
}
}
}
//--
mc.CheckOpenPMx(symbol);
//--
if(mc.xtto>0)
{
//--
if(SaveOnRev==Yes) //-- Close Trade and Save profit due to weak signal (Yes)
{
mc.CheckOpenPMx(symbol);
if(mc.profitb[x]>mc.minprofit && 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]>mc.minprofit && 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(UseTCP==Yes) mc.CheckTargetCloseProfit();
//--
if(TrailingSL==Yes) mc.ModifyOrdersSL(symbol,trlby); //-- Use Trailing Stop Loss (Yes)
if(TrailingTP==Yes) mc.ModifyOrdersTP(symbol); //-- Use Trailing Take Profit (Yes)
//--
}
//--
mc.CheckOpenPMx(symbol);
if(Close_by_Opps==No && (mc.xob[x]+mc.xos[x]>1))
{
mc.CheckProfitLoss(symbol);
mc.Do_Alerts(symbol,"Close order due stop in loss.");
}
//--
mc.CheckClose(symbol);
}
//--
mc.psec=mc.ccur;
}
//--
return;
//---
} //-end ExpertActionTrade()
//---------//
int MCEA::PairsIdxArray(const string symbol)
{
//---
int pidx=-1;
//--
for(int x=0; x<arrsymbx; x++)
{
if(DIRI[x]==symbol)
{
pidx=x;
break;
}
}
//--
return(pidx);
//---
} //-end PairsIdxArray()
//---------//
int MCEA::ValidatePairs(const string symbol)
{
//---
int pidx=-1;
//--
for(int x=0; x<sall; x++)
{
if(VSym[x]==symbol)
{
pidx=x;
break;
}
}
//--
return(pidx);
//---
} //-end ValidatePairs()
//---------//
void MCEA::ArraySymbolResize(void)
{
//---
ArrayFree(DIRI);
ArrayFree(xob);
ArrayFree(xos);
ArrayFree(OpOr);
ArrayFree(profitb);
ArrayFree(profits);
ArrayFree(hSMMAL);
ArrayFree(hSMAMi);
ArrayFree(hSMAKc);
ArrayFree(hPar05);
ArrayFree(PbarB);
ArrayFree(TbarB);
ArrayFree(PbarS);
ArrayFree(TbarS);
ArrayFree(spreadx);
//--
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(hSMMAL,arrsymbx,arrsymbx);
ArrayResize(hSMAMi,arrsymbx,arrsymbx);
ArrayResize(hSMAKc,arrsymbx,arrsymbx);
ArrayResize(hPar05,arrsymbx,arrsymbx);
ArrayResize(PbarB,arrsymbx,arrsymbx);
ArrayResize(TbarB,arrsymbx,arrsymbx);
ArrayResize(PbarS,arrsymbx,arrsymbx);
ArrayResize(TbarS,arrsymbx,arrsymbx);
ArrayResize(spreadx,arrsymbx,arrsymbx);
//--
return;
//---
} //-end ArraySymbolResize()
//---------//
bool MCEA::CheckSpread(const string symbol)
{
//---
bool allow_spread=false;
int x=PairsIdxArray(symbol);
//--
CurrentSymbolSet(symbol);
spreadx[x]=mc_symbol.NormalizePrice(mc_symbol.Ask()-mc_symbol.Bid());
//--
allow_spread=spreadx[x] <= maxSpread*pip;
//--
if(!allow_spread)
{
string bigspread="Spread in "+symbol+" is greater than maximum spread limit.";
Do_Alerts(symbol,bigspread);
}
//--
return(allow_spread);
//---
} //- end CheckSpread()
//---------//
bool MCEA::GoodMarginTrade(const string symbol,ENUM_ORDER_TYPE _cmd,double lotsz,double atprice)
{
//---
bool goodmrgn=true;
//--
if((mc_account.FreeMarginCheck(symbol,_cmd,lotsz,atprice)<=0.0)||(mc_account.FreeMargin()<(mc_account.Equity()*maxmrgn/100))) goodmrgn=false;
//--
if(!goodmrgn)
{
string nomargn="Account Free Margin minimum has reached the specified limit, Order will not opened";
Do_Alerts(symbol,nomargn);
}
//--
return(goodmrgn);
//---
} //-end GoodMarginTrade()
//---------//
void MCEA::UpdatePrice(const string symbol,ENUM_TIMEFRAMES xtf,int bars=0)
{
//---
int xbar=bars==0 ? arper : bars;
//--
ArrayFree(OPEN);
ArrayFree(HIGH);
ArrayFree(LOW);
ArrayFree(CLOSE);
ArrayFree(TIME);
//--
ArrayResize(OPEN,xbar,xbar);
ArrayResize(HIGH,xbar,xbar);
ArrayResize(LOW,xbar,xbar);
ArrayResize(CLOSE,xbar,xbar);
ArrayResize(TIME,xbar,xbar);
//--
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);
//--
int barx=PeriodSeconds(xtf)/60*xbar;
RefreshPrice(symbol,PERIOD_M1,xbar);
RefreshPrice(symbol,xtf,barx);
//--
int co=CopyOpen(symbol,xtf,0,xbar,OPEN);
int ch=CopyHigh(symbol,xtf,0,xbar,HIGH);
int cl=CopyLow(symbol,xtf,0,xbar,LOW);
int cc=CopyClose(symbol,xtf,0,xbar,CLOSE);
int ct=CopyTime(symbol,xtf,0,xbar,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);
//--
point=mc_symbol.Point();
dgts=(int)mc_symbol.Digits();
//--
xpip=10.0;
pip=point*xpip;
//--
return;
//---
} //-end Pips()
//---------//
bool MCEA::IFNewBarsB(const string symbol) // New bar check buy order
{
//---
bool Nb=false;
int xs=PairsIdxArray(symbol);
//--
TbarB[xs]=iTime(symbol,TFt,0);
if(TbarB[xs]!=PbarB[xs]) Nb=true;
//--
return(Nb);
//---
} //-end IFNewBarsB()
//---------//
bool MCEA::IFNewBarsS(const string symbol) // New bar check sell order
{
//---
bool Nb=false;
int xs=PairsIdxArray(symbol);
//--
TbarS[xs]=iTime(symbol,TFt,0);
if(TbarS[xs]!=PbarS[xs]) Nb=true;
//--
return(Nb);
//---
} //-end IFNewBarsS()
//---------//
int MCEA::DirectionMove(const string symbol,const ENUM_TIMEFRAMES stf) // Bar Price Direction
{
//---
int ret=0;
int rise=1,
down=-1;
//--
Pips(symbol);
double difud=mc_symbol.NormalizePrice(1.5*pip);
UpdatePrice(symbol,stf);
//--
if(CLOSE[0]>OPEN[0]+difud) ret=rise;
if(CLOSE[0]<OPEN[0]-difud) ret=down;
//--
return(ret);
//---
} //-end DirectionMove()
//---------//
int MCEA::PricePercentMove(const string symbol,const ENUM_TIMEFRAMES stf,double pcm,int shift) // Price Bar Direction in percent
{
//---
int ret=0;
int rise=1,
down=-1;
//--
int br=shift+3;
double hasil=0.0;
double move=pcm;
UpdatePrice(symbol,stf);
//--
double CL[];
ArrayResize(CL,br,br);
ArraySetAsSeries(CL,true);
//--
for(int x=br-1; x>=shift; x--)
CL[x]=CLOSE[x];
//--
double close_now = CL[shift];
double close_prev = CL[shift+1];
//--
if((close_now==0 || close_now==EMPTY_VALUE) || (close_prev==0 || close_prev==EMPTY_VALUE)) hasil=0.0;
else hasil=NormalizeDouble((close_now / close_prev * 100) - 100,3);
hasil=NormalizeDouble(hasil*100,3); // because its value less than 1 then multiplied with 100.
//--
if(hasil>move) ret=rise;
if(hasil<-move) ret=down;
//--
return(ret);
//---
} //-end PricePercentMove()
//---------//
int MCEA::SignalMACross1(const string symbol)
{
//---
int ret=0;
int rise=1,
down=-1;
//--
double BMAL[],
BMAM[],
BMAK[];
//--
ArrayResize(BMAL,arper,arper);
ArrayResize(BMAM,arper,arper);
ArrayResize(BMAK,arper,arper);
//--
int xm=PairsIdxArray(symbol);
UpdatePrice(symbol,TFt);
//--
CopyBuffer(hSMMAL[xm],0,0,arper,BMAL);
CopyBuffer(hSMAMi[xm],0,0,arper,BMAM);
CopyBuffer(hSMAKc[xm],0,0,arper,BMAK);
//--
ArraySetAsSeries(BMAL,true);
ArraySetAsSeries(BMAM,true);
ArraySetAsSeries(BMAK,true);
//--
bool SigMAup1=(BMAK[1]<=BMAL[1] && BMAK[0]>BMAL[0] && BMAM[0]<BMAL[0]);
bool SigMAdw1=(BMAK[1]>=BMAL[1] && BMAK[0]<BMAL[0] && BMAM[0]>BMAL[0]);
//--
bool SigMAup2=(BMAM[0]>BMAL[0] && BMAK[1]<=BMAM[1] && BMAK[0]>BMAM[0]);
bool SigMAdw2=(BMAM[0]<BMAL[0] && BMAK[1]>=BMAM[1] && BMAK[0]<BMAM[0]);
//--
int PPMv=PricePercentMove(symbol,TFt,10.0,0);
//--
if((SigMAup1||SigMAup2) && PPMv==rise) ret=rise;
if((SigMAdw1||SigMAdw2) && PPMv==down) ret=down;
//--
return(ret);
//---
} //-end SignalMACross1()
//---------//
int MCEA::GetOpenPosition(const string symbol) // Signal Open Position
{
//---
int ret=0;
int rise=1,
down=-1;
//--
int SMAC=SignalMACross1(symbol);
int DirM=DirectionMove(symbol,TFt);
//--
if(SMAC==rise && DirM==rise) ret=rise;
if(SMAC==down && DirM==down) ret=down;
//--
return(ret);
//---
} //-end GetOpenPosition()
//---------//
int MCEA::GetCloseInWeakSignal(const string symbol,int exis) // Signal Indicator Position Close in profit
{
//---
int ret=0;
int rise=1,
down=-1;
int bar=5;
int x=PairsIdxArray(symbol);
//--
double BMAK[];
ArrayResize(BMAK,bar,bar);
CopyBuffer(hSMAKc[x],0,0,bar,BMAK);
//--
ArraySetAsSeries(BMAK,true);
//--
bool BMKup=(BMAK[0]>BMAK[1]);
bool BMKdw=(BMAK[0]<BMAK[1]);
int DirM=DirectionMove(symbol,TFt);
int PPmv=PricePercentMove(symbol,TFt,5.0,0);
//--
if(exis==down && DirM==rise && PPmv==rise && BMKup) ret=rise;
if(exis==rise && DirM==down && PPmv==down && BMKdw) ret=down;
//--
return(ret);
//---
} //-end GetCloseInWeakSignal()
//---------//
int MCEA::PARSAR05(const string symbol) // formula Parabolic SAR M5
{
//---
int ret=0;
int rise=1,
down=-1;
int 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()
//---------//
bool MCEA::OpenBuy(const string symbol)
{
//---
ResetLastError();
//--
bool buyopen = false;
double ldLot = MLots(symbol);
ENUM_ORDER_TYPE type_req = ORDER_TYPE_BUY;
string ordertype = ReturnsOrderType(type_req);
string ldComm = GetCommentForOrder()+"_"+ordertype;
if(!CheckSpread(symbol)) return(false);
if(!GoodMarginTrade(symbol,type_req,ldLot,mc_symbol.Ask())) return(false);
//--
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
//-- structure is set to zero
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 "+ordertype+" Order for "+symbol+" ~ Ticket= ["+(string)mc_trade.ResultOrder()+"] successfully..!";
Do_Alerts(symbol,bsopen);
int xi=PairsIdxArray(symbol);
PbarB[xi]=iTime(symbol,TFt,0);
}
else
{
mc_trade.CheckResult(check);
Do_Alerts(Symbol(),"Open "+ordertype+" 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;
double sdLot = MLots(symbol);
ENUM_ORDER_TYPE type_req = ORDER_TYPE_SELL;
string ordertype = ReturnsOrderType(type_req);
string sdComm = GetCommentForOrder()+"_"+ordertype;
if(!CheckSpread(symbol)) return(false);
if(!GoodMarginTrade(symbol,type_req,sdLot,mc_symbol.Bid())) return(false);
//--
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
//-- structure is set to zero
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 "+ordertype+" Order for "+symbol+" ~ Ticket= ["+(string)mc_trade.ResultOrder()+"] successfully..!";
Do_Alerts(symbol,bsopen);
int xi=PairsIdxArray(symbol);
PbarS[xi]=iTime(symbol,TFt,0);
}
else
{
mc_trade.CheckResult(check);
Do_Alerts(Symbol(),"Open "+ordertype+" 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+35*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-35*pip);
else
if(use_tp==Yes && autotp==No) tpv=mc_symbol.NormalizePrice(atprice-TPval*pip);
else tpv=0.0;
}
}
//---
return(tpv);
//---
} //-end OrderTPSet()
//---------//
void MCEA::CheckOpenPMx(const string symbx) //-- function: CheckOpenTrade.
{
//---
int totalorder=PositionsTotal();
xtto=totalorder;
//--
int xi=PairsIdxArray(symbx);
xob[xi]=0;
xos[xi]=0;
profitb[xi]=0;
profits[xi]=0;
double pos_profit = 0.0;
double pos_swap = 0.0;
double 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);
PbarB[xi]=iTime(symbx,TFt,0);
}
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);
PbarS[xi]=iTime(symbx,TFt,0);
}
//--
}
}
//---
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 byprice:
{
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 byHiLo:
{
UpdatePrice(xsymb,TFt,2);
//--
if(ptype==POSITION_TYPE_BUY && (HIGH[0]>HIGH[1]))
pval=LOW[1];
if(ptype==POSITION_TYPE_SELL && (LOW[0]<LOW[1]))
pval=HIGH[1];
//--
break;
}
}
//--
return(pval);
//---
} //-end TSPrice()
//---------//
bool MCEA::ModifyOrdersSL(const string symbol,int TS_type)
{
//---
ResetLastError();
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
//--
int TRSP=TS_type;
bool modist=false;
int x=PairsIdxArray(symbol);
Pips(symbol);
//--
ulong pos_ticket = 0;
double price = 0.0;
double pos_open = 0.0;
double pos_stop = 0.0;
double pos_tp = 0.0;
double pos_profit = 0.0;
double pos_swap = 0.0;
double pos_comm = 0.0;
double netp = 0.0;
double modstart = 0.0;
double modminsl = 0.0;
//--
int total=PositionsTotal();
//--
for(int i=0; i<total; i++)
{
string symbolx=PositionGetSymbol(i);
if(mc_position.Select(symbolx) && symbolx==symbol && mc_position.Magic()==magicEA)
{
ENUM_POSITION_TYPE opstype = mc_position.PositionType();
if(opstype==POSITION_TYPE_BUY)
{
RefreshTick(symbol);
pos_ticket = mc_position.Ticket();
price = mc_position.PriceCurrent();
double vtrsb = mc_symbol.NormalizePrice(TSPrice(symbol,opstype,TRSP));
pos_open = mc_position.PriceOpen();
pos_stop = mc_position.StopLoss();
pos_tp = mc_position.TakeProfit();
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+(minSL*pip));
modminsl = mc_symbol.NormalizePrice(vtrsb+((minSL-1.0)*pip));
double modbuysl=vtrsb;
bool modbuy = (price>modminsl && modbuysl>modstart && (pos_stop==0.0||modbuysl>pos_stop));
//--
if(modbuy && netp>minprofit)
{
modist=mc_trade.PositionModify(pos_ticket,modbuysl,pos_tp);
if(modist) PrintFormat("Position modified SL: #%I64d %s %s",pos_ticket,symbol,EnumToString(opstype));
else break;
}
}
if(opstype==POSITION_TYPE_SELL)
{
RefreshTick(symbol);
pos_ticket = mc_position.Ticket();
price = mc_position.PriceCurrent();
double vtrss = mc_symbol.NormalizePrice(TSPrice(symbol,opstype,TRSP));
pos_open = mc_position.PriceOpen();
pos_stop = mc_position.StopLoss();
pos_tp = mc_position.TakeProfit();
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-(minSL*pip));
modminsl = mc_symbol.NormalizePrice(vtrss-((minSL+1.0)*pip));
double modselsl=vtrss;
bool modsel = (price<modminsl && modselsl<modstart && (pos_stop==0.0||modselsl<pos_stop));
//--
if(modsel && netp>minprofit)
{
modist=mc_trade.PositionModify(pos_ticket,modselsl,pos_tp);
if(modist) PrintFormat("Position modified SL: #%I64d %s %s",pos_ticket,symbol,EnumToString(opstype));
else break;
}
}
}
}
//--
return(modist);
//---
} //-end ModifyOrdersSL()
//---------//
bool MCEA::ModifyOrdersTP(const string symbol)
{
//---
ResetLastError();
MqlTradeRequest req={};
MqlTradeResult res={};
MqlTradeCheckResult check={};
//--
bool modist=false;
int x=PairsIdxArray(symbol);
Pips(symbol);
//--
double price = 0.0;
double pos_open = 0.0;
double pos_stop = 0.0;
double pos_tp = 0.0;
double buytp = 0.0;
double selltp = 0.0;
double precision = 0.0;
double modpostp = 0.0;
double freezeLvl = 0.0;
//--
int total=PositionsTotal();
//--
for(int i=0; i<total; i++)
{
string symbolx=PositionGetSymbol(i);
if(mc_position.Select(symbolx) && symbolx==symbol && mc_position.Magic()==magicEA)
{
ENUM_POSITION_TYPE opstype = mc_position.PositionType();
if(opstype==POSITION_TYPE_BUY)
{
RefreshTick(symbol);
ulong pos_ticket = mc_position.Ticket();
if(mc_position.SelectByTicket(pos_ticket))
{
int freeze = mc_symbol.FreezeLevel();
price = mc_position.PriceCurrent();
pos_open = mc_position.PriceOpen();
pos_stop = mc_position.StopLoss();
pos_tp = mc_position.TakeProfit();
buytp = pos_tp==0.0 ? mc_symbol.NormalizePrice(pos_open+(valTP*pip)) : pos_tp;
freezeLvl = mc_symbol.NormalizePrice(buytp-freeze);
precision = mc_symbol.NormalizePrice(price+(minTP*pip));
modpostp = mc_symbol.NormalizePrice(buytp+(minTP*pip));
bool modtpb = (price>pos_open && price<freezeLvl && precision>buytp && (pos_tp==0.0||modpostp>pos_tp));
//--
if(modtpb)
{
modist=mc_trade.PositionModify(pos_ticket,pos_stop,modpostp);
if(modist) PrintFormat("Position modified TP: #%I64d %s %s",pos_ticket,symbol,EnumToString(opstype));
else break;
}
}
}
if(opstype==POSITION_TYPE_SELL)
{
RefreshTick(symbol);
ulong pos_ticket = mc_position.Ticket();
if(mc_position.SelectByTicket(pos_ticket))
{
int freeze = mc_symbol.FreezeLevel();
price = mc_position.PriceCurrent();
pos_open = mc_position.PriceOpen();
pos_stop = mc_position.StopLoss();
pos_tp = mc_position.TakeProfit();
selltp = pos_tp==0.0 ? mc_symbol.NormalizePrice(pos_open-(valTP*pip)) : pos_tp;
freezeLvl = mc_symbol.NormalizePrice(selltp+freeze);
precision = mc_symbol.NormalizePrice(price-(minTP*pip));
modpostp = mc_symbol.NormalizePrice(selltp-(minTP*pip));
bool modtps = (price<pos_open && price>freezeLvl && precision<selltp && (pos_tp==0.0||modpostp<pos_tp));
//--
if(modtps)
{
modist=mc_trade.PositionModify(pos_ticket,pos_stop,modpostp);
if(modist) PrintFormat("Position modified TP: #%I64d %s %s",pos_ticket,symbol,EnumToString(opstype));
else break;
}
}
}
}
}
//--
return(modist);
//---
} //-end ModifyOrdersTP()
//---------//
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();
double pos_open = mc_position.PriceOpen();
double pos_stop = mc_position.StopLoss();
double 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();
double pos_open = mc_position.PriceOpen();
double pos_stop = mc_position.StopLoss();
double 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()
//---------//
bool MCEA::CloseBuyPositions(const string symbol)
{
//---
//--
ResetLastError();
bool buyclose=false;
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={};
//--
int x=PairsIdxArray(symbol);
//--- 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);
buyclose=mc_trade.PositionClose(position_Symbol,slip);
//--- output information about the closure
PrintFormat("Close Buy #%I64d %s %s",position_ticket,position_Symbol,EnumToString(type));
if(buyclose) PbarB[x]=iTime(symbol,TFt,0);
}
}
}
}
//---
return(buyclose);
//----
} //-end CloseBuyPositions()
//---------//
bool MCEA::CloseSellPositions(const string symbol)
{
//---
ResetLastError();
bool sellclose=false;
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={};
//--
int x=PairsIdxArray(symbol);
//--- 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);
sellclose=mc_trade.PositionClose(position_Symbol,slip);
//--- output information about the closure
PrintFormat("Close Sell #%I64d %s %s",position_ticket,position_Symbol,EnumToString(type));
if(sellclose) PbarS[x]=iTime(symbol,TFt,0);
}
}
}
}
//---
return(sellclose);
//----
} //-end CloseSellPositions()
//---------//
bool MCEA::CloseAllProfit(void)
{
//----
ResetLastError();
//--
int up=1,
dw=-1;
bool orclose=false;
string isgood="trend is still good";
//--
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));
if(orclose) PbarB[x]=iTime(symbol,TFt,0);
}
else if(hps==up) PrintFormat("Not Closed yet #%I64d %s %s",position_ticket,position_Symbol,isgood);
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));
if(orclose) PbarS[x]=iTime(symbol,TFt,0);
}
else if(hps==dw) PrintFormat("Not Closed yet #%I64d %s %s",position_ticket,position_Symbol,isgood);
}
}
}
//--
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();
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)
{
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(orclose) PbarB[x]=iTime(symbol,TFt,0);
}
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));
if(orclose) PbarS[x]=iTime(symbol,TFt,0);
}
}
}
}
//--
return(orclose);
//----
} //-end ManualCloseAllProfit()
//---------//
bool MCEA::CheckProfit(const string symbol,ENUM_POSITION_TYPE intype)
{
//---
Pips(symbol);
double posprofit=mc_symbol.NormalizePrice(5*pip);
bool inprofit=false;
//--
int ttlorder=PositionsTotal(); // number of open positions
//--
for(int x=0; x<arrsymbx; x++)
{
string symbol=DIRI[x];
//--
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);
//---
if(type==intype && cur_profit>posprofit) inprofit=true;
}
}
}
//--
return(inprofit);
//----
} //-end CheckProfit()
//---------//
bool MCEA::CheckLoss(const string symbol,ENUM_POSITION_TYPE intype)
{
//---
Pips(symbol);
double posloss=mc_symbol.NormalizePrice(5*pip);
bool inloss=false;
int ttlorder=PositionsTotal(); // number of open positions
//--
for(int x=0; x<arrsymbx; x++)
{
string symbol=DIRI[x];
//--
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);
//---
if(type==intype && cur_profit<-posloss) inloss=true;
}
}
}
//--
return(inloss);
//----
} //-end CheckLoss()
//---------//
bool MCEA::CheckProfitLoss(const string symbol)
{
//----
ResetLastError();
//--
bool closeinloss=false;
string isloss="due stop in loss.";
//--
int xx=PairsIdxArray(symbol);
//--
bool BuyProfitSellLoss=(xob[xx]>0 && CheckProfit(symbol,POSITION_TYPE_BUY)) && (xos[xx]>0 && CheckLoss(symbol,POSITION_TYPE_SELL));
bool SellProfitBuyLoss=(xos[xx]>0 && CheckProfit(symbol,POSITION_TYPE_SELL)) && (xob[xx]>0 && CheckLoss(symbol,POSITION_TYPE_BUY));
//--
if(BuyProfitSellLoss && !SellProfitBuyLoss)
{
if(CloseSellPositions(symbol))
{
PrintFormat("Close Sell %s %s %s",symbol,EnumToString(POSITION_TYPE_BUY),isloss);
closeinloss=true;
}
}
if(SellProfitBuyLoss && !BuyProfitSellLoss)
{
if(CloseBuyPositions(symbol))
{
PrintFormat("Close Buy %s %s %s",symbol,EnumToString(POSITION_TYPE_SELL),isloss);
closeinloss=true;
}
}
//--
return(closeinloss);
//----
} //-end CheckProfitLoss()
//---------//
void MCEA::CloseAllOrders(void) //-- function: close all order
{
//----
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);
if(closepos && type==POSITION_TYPE_BUY) PbarB[i]=iTime(position_Symbol,TFt,0);
if(closepos && type==POSITION_TYPE_SELL) PbarS[i]=iTime(position_Symbol,TFt,0);
//--- output information about the closure
PrintFormat("Close #%I64d %s %s",position_ticket,position_Symbol,EnumToString(type));
//---
}
}
//---
return;
//----
} //-end CloseAllOrders()
//---------//
void MCEA::CheckTargetCloseProfit(void)
{
//---
TodayOrders();
//--
bool closetgt=(mc_account.Equity()-mc_account.Balance())>((mc_account.Balance()*TCPUse)/100.0);
//--
if(closetgt)
{
CloseAllOrders();
string closeall="Close all order due to it is in accordance with the close profit target!";
Do_Alerts(Symbol(),closeall);
TodayOrders();
ArrayInitialize(PbarB,iTime(NULL,TFt,0));
ArrayInitialize(PbarS,iTime(NULL,TFt,0));
}
//--
return;
//---
} //-end CheckTargetCloseProfit()
//---------//
void MCEA::CheckClose(const string symbx)
{
//---
//--
ResetLastError();
Pips(symbx);
//--
datetime to=TimeCurrent();
datetime from=to-(60);
closetime=TimeCurrent()-(3); // 3 seconds ago
//--- 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
long deal_type =0; // Order Type
double deal_price =0.0; // deal/order CLOSE price
double deal_profit =0.0; // deal profit
double deal_swap =0.0; // position swap
double deal_comm =0.0; // position commission
string deal_symbol =""; // symbol of the deal
ENUM_DEAL_ENTRY deal_entry =0; // enum deal entry
double profit_loss =0.0; // Order profit or loss
//--
//--- 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
long deal_type =0; // Order Type
double deal_price =0.0; // deal/order CLOSE price
double deal_profit =0.0; // deal profit
double deal_swap =0.0; // position swap
double 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()
//---------//
double MCEA::MLots(const string symbx) // function: calculation lots size
{
//----
double Lsize=0.0;
double sym_Lm=0.0;
string sym_use ="";
int pil;
int Lpair;
int xsym=-1;
//--
string sCur1=StringSubstr(symbx,posCur1,3);
string 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();
double AFMar = mc_account.FreeMargin();
double AFLev = (double)mc_account.Leverage();
double symbid = mc_symbol.Bid();
//--
double Lmaxs = SymbolInfoDouble(symbx,SYMBOL_VOLUME_MAX);
double Lmins = SymbolInfoDouble(symbx,SYMBOL_VOLUME_MIN);
//--
double useRisk = (Risk/100.0);
double PctUse = ((100.0-Risk)/100.0);
//--
double NZ1=NonZeroDiv(AFMar*AFLev,csize);
double 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));
double 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)
{
//---
double resval=0.0;
if(val1==0.0 || val2==0.0) resval=0.00;
else
resval=val1/val2;
//--
return(resval);
//---
} //-end NonZeroDiv()
//---------//
string MCEA::ReturnsOrderType(ENUM_ORDER_TYPE ordtype)
{
//---
string str_type;
//--
switch(ordtype)
{
case 0: str_type="BUY"; break;
case 1: str_type="SELL"; break;
case 2: str_type="BUY LIMIT"; break;
case 3: str_type="SELL LIMIT"; break;
case 4: str_type="BUY STOP"; break;
case 5: str_type="SELL STOP"; break;
}
//--
return(str_type);
//----
} //-end ReturnsOrderType()
//---------//
void MCEA::TradeInfo(void) // function: write comments on the chart
{
//----
Pips(Symbol());
double spread=SymbolInfoInteger(Symbol(),SYMBOL_SPREAD)/xpip;
rem=zntm-TimeCurrent();
string postime=PosTimeZone();
string eawait=" - Waiting for active time..!";
//--
string comm="";
TodayOrders();
//--
comm="\n :: Server Date Time : "+string(ThisTime(year))+"."+string(ThisTime(mon))+"."+string(ThisTime(day))+ " "+TimeToString(TimeCurrent(),TIME_SECONDS)+
"\n ------------------------------------------------------------"+
"\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 :: Acc. Balance : "+ DoubleToString(mc_account.Balance(),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 :: Trading Session : "+ tz_ses+
"\n :: Trading Time : "+ postime;
if(TimeCurrent()<zntm)
{
comm=comm+
"\n :: Time Remaining : "+(string)ReqTime(rem,hour)+":"+(string)ReqTime(rem,min)+":"+(string)ReqTime(rem,sec) + eawait;
}
comm=comm+
"\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::PosTimeZone(void)
{
//---
string tzpos="";
//--
if(ReqTime(zntm,day)>ThisTime(day))
{
tzpos=tz_opn+ " Next day to " +tz_cls + " Next day";
}
else
if(TimeCurrent()<znop)
{
if(ThisTime(day)==ReqTime(znop,day) && ThisTime(day)==ReqTime(zncl,day))
tzpos=tz_opn+" to " +tz_cls+ " Today";
//else
if(ThisTime(day)==ReqTime(znop,day) && ThisTime(day)<ReqTime(zncl,day))
tzpos=tz_opn+ " Today to " +tz_cls+ " Next day";
}
else
if(TimeCurrent()>=znop && TimeCurrent()<zncl)
{
if(ThisTime(day)<ReqTime(zncl,day))
tzpos=tz_opn+ " Today to " +tz_cls+ " Next day";
else
if(ThisTime(day)==ReqTime(zncl,day))
tzpos=tz_opn+" to " +tz_cls+ " Today";
}
else
if(ThisTime(day)==ReqTime(znop,day) && ThisTime(day)<ReqTime(zncl,day))
{
tzpos=tz_opn+" Today to " +tz_cls+ " Next day";
}
else tzpos="Ahead of Trading Time Zone";
//--
return(tzpos);
//----
} //-end PosTimeZone()
//---------//
void MCEA::Set_Time_Zone(void)
{
//---
//-- Server Time==TimeCurrent()
datetime TTS=TimeTradeServer();
datetime GMT=TimeGMT();
//--
MqlDateTime svrtm,gmttm;
TimeToStruct(TTS,svrtm);
TimeToStruct(GMT,gmttm);
int svrhr=svrtm.hour; // Server time hour
int gmthr=gmttm.hour; // GMT time hour
int difhr=svrhr-gmthr; // Time difference Server time to GMT time
//--
int NZSGMT=12; // New Zealand Session GMT/UTC+12
int AUSGMT=10; // Australia Sydney Session GMT/UTC+10
int TOKGMT=9; // Asia Tokyo Session GMT/UTC+9
int EURGMT=0; // Europe London Session GMT/UTC 0
int USNGMT=-5; // US New York Session GMT/UTC-5
//--
int NZSStm=8; // New Zealand Session time start: 08:00 Local Time
int NZSCtm=17; // New Zealand Session time close: 17:00 Local Time
int AUSStm=7; // Australia Sydney Session time start: 07:00 Local Time
int AUSCtm=17; // Australia Sydney Session time close: 17:00 Local Time
int TOKStm=9; // Asia Tokyo Session time start: 09:00 Local Time
int TOKCtm=18; // Asia Tokyo Session time close: 18:00 Local Time
int EURStm=9; // Europe London Session time start: 09:00 Local Time
int EURCtm=19; // Europe London Session time close: 19:00 Local Time
int USNStm=8; // US New York Session time start: 08:00 Local Time
int USNCtm=17; // US New York Session time close: 17:00 Local Time
//--
int nzo = (NZSStm+difhr-NZSGMT)<0 ? 24+(NZSStm+difhr-NZSGMT) : (NZSStm+difhr-NZSGMT);
int nzc = (NZSCtm+difhr-NZSGMT)<0 ? 24+(NZSCtm+difhr-NZSGMT) : (NZSCtm+difhr-NZSGMT);
//--
int auo = (AUSStm+difhr-AUSGMT)<0 ? 24+(AUSStm+difhr-AUSGMT) : (AUSStm+difhr-AUSGMT);
int auc = (AUSCtm+difhr-AUSGMT)<0 ? 24+(AUSCtm+difhr-AUSGMT) : (AUSCtm+difhr-AUSGMT);
//--
int tko = (TOKStm+difhr-TOKGMT)<0 ? 24+(TOKStm+difhr-TOKGMT) : (TOKStm+difhr-TOKGMT);
int tkc = (TOKCtm+difhr-TOKGMT)<0 ? 24+(TOKCtm+difhr-TOKGMT) : (TOKCtm+difhr-TOKGMT);
//--
int euo = (EURStm+difhr-EURGMT)<0 ? 24+(EURStm+difhr-EURGMT) : (EURStm+difhr-EURGMT);
int euc = (EURCtm+difhr-EURGMT)<0 ? 24+(EURCtm+difhr-EURGMT) : (EURCtm+difhr-EURGMT);
//--
int uso = (USNStm+difhr-USNGMT)<0 ? 24+(USNStm+difhr-USNGMT) : (USNStm+difhr-USNGMT);
int usc = (USNCtm+difhr-USNGMT)<0 ? 24+(USNCtm+difhr-USNGMT) : (USNCtm+difhr-USNGMT);
if(usc==0||usc==24) usc=23;
//--
//---Trading on Custom Session
int _days00=ThisTime(day);
int _days10=ThisTime(day);
if(stsescuh>clsescuh) _days10=ThisTime(day)+1;
tmopcu=ReqDate(_days00,stsescuh,stsescum);
tmclcu=ReqDate(_days10,clsescuh,clsescum);
//--
//--Trading on New Zealand Session GMT/UTC+12
int _days01=ThisTime(hour)<nzc ? ThisTime(day)-1 : ThisTime(day);
int _days11=ThisTime(hour)<nzc ? ThisTime(day) : ThisTime(day)+1;
tmop01=ReqDate(_days01,nzo,0); // start: 08:00 Local Time == 20:00 GMT/UTC
tmcl01=ReqDate(_days11,nzc-1,59); // close: 17:00 Local Time == 05:00 GMT/UTC
//--
//--Trading on Australia Sydney Session GMT/UTC+10
int _days02=ThisTime(hour)<auc ? ThisTime(day)-1 : ThisTime(day);
int _days12=ThisTime(hour)<auc ? ThisTime(day) : ThisTime(day)+1;
tmop02=ReqDate(_days02,auo,0); // start: 07:00 Local Time == 21:00 GMT/UTC
tmcl02=ReqDate(_days12,auc-1,59); // close: 17:00 Local Time == 07:00 GMT/UTC
//--
//--Trading on Asia Tokyo Session GMT/UTC+9
int _days03=ThisTime(hour)<tkc ? ThisTime(day) : ThisTime(day)+1;
int _days13=ThisTime(hour)<tkc ? ThisTime(day) : ThisTime(day)+1;
tmop03=ReqDate(_days03,tko,0); // start: 09:00 Local Time == 00:00 GMT/UTC
tmcl03=ReqDate(_days13,tkc-1,59); // close: 18:00 Local Time == 09:00 GMT/UTC
//--
//--Trading on Europe London Session GMT/UTC 00:00
int _days04=ThisTime(hour)<euc ? ThisTime(day) : ThisTime(day)+1;
int _days14=ThisTime(hour)<euc ? ThisTime(day) : ThisTime(day)+1;
tmop04=ReqDate(_days04,euo,0); // start: 09:00 Local Time == 09:00 GMT/UTC
tmcl04=ReqDate(_days14,euc-1,59); // close: 19:00 Local Time == 19:00 GMT/UTC
//--
//--Trading on US New York Session GMT/UTC-5
int _days05=ThisTime(hour)<usc ? ThisTime(day) : ThisTime(day)+1;
int _days15=ThisTime(hour)<=usc ? ThisTime(day) : ThisTime(day)+1;
tmop05=ReqDate(_days05,uso,0); // start: 08:00 Local Time == 13:00 GMT/UTC
tmcl05=ReqDate(_days15,usc,59); // close: 17:00 Local Time == 22:00 GMT/UTC
//--
//--Not Use Trading Time Zone
if(trd_time_zone==No)
{
tmopno=ReqDate(ThisTime(day),0,15);
tmclno=ReqDate(ThisTime(day),23,59);
}
//--
Time_Zone();
//--
return;
//---
} //-end Set_Time_Zone()
//---------//
void MCEA::Time_Zone(void)
{
//---
//--
tz_ses="";
//--
switch(session)
{
case Cus_Session:
{
SesCuOp=StringToTime(tmopcu);
SesCuCl=StringToTime(tmclcu);
zntm=SesCuOp;
znop=SesCuOp;
zncl=SesCuCl;
tz_ses="Custom_Session";
tz_opn=timehr(stsescuh,stsescum);
tz_cls=timehr(clsescuh,clsescum);
break;
}
case New_Zealand:
{
Ses01Op=StringToTime(tmop01);
Ses01Cl=StringToTime(tmcl01);
zntm=Ses01Op;
znop=Ses01Op;
zncl=Ses01Cl;
tz_ses="New_Zealand/Oceania";
tz_opn=timehr(ReqTime(Ses01Op,hour),ReqTime(Ses01Op,min));
tz_cls=timehr(ReqTime(Ses01Cl,hour),ReqTime(Ses01Cl,min));
break;
}
case Australia:
{
Ses02Op=StringToTime(tmop02);
Ses02Cl=StringToTime(tmcl02);
zntm=Ses02Op;
znop=Ses02Op;
zncl=Ses02Cl;
tz_ses="Australia Sydney";
tz_opn=timehr(ReqTime(Ses02Op,hour),ReqTime(Ses02Op,min));
tz_cls=timehr(ReqTime(Ses02Cl,hour),ReqTime(Ses02Cl,min));
break;
}
case Asia_Tokyo:
{
Ses03Op=StringToTime(tmop03);
Ses03Cl=StringToTime(tmcl03);
zntm=Ses03Op;
znop=Ses03Op;
zncl=Ses03Cl;
tz_ses="Asia/Tokyo";
tz_opn=timehr(ReqTime(Ses03Op,hour),ReqTime(Ses03Op,min));
tz_cls=timehr(ReqTime(Ses03Cl,hour),ReqTime(Ses03Cl,min));
break;
}
case Europe_London:
{
Ses04Op=StringToTime(tmop04);
Ses04Cl=StringToTime(tmcl04);
zntm=Ses04Op;
znop=Ses04Op;
zncl=Ses04Cl;
tz_ses="Europe/London";
tz_opn=timehr(ReqTime(Ses04Op,hour),ReqTime(Ses04Op,min));
tz_cls=timehr(ReqTime(Ses04Cl,hour),ReqTime(Ses04Cl,min));
break;
}
case US_New_York:
{
Ses05Op=StringToTime(tmop05);
Ses05Cl=StringToTime(tmcl05);
zntm=Ses05Op;
znop=Ses05Op;
zncl=Ses05Cl;
tz_ses="US/New_York";
tz_opn=timehr(ReqTime(Ses05Op,hour),ReqTime(Ses05Op,min));
tz_cls=timehr(ReqTime(Ses05Cl,hour),ReqTime(Ses05Cl,min));
break;
}
}
//--
if(trd_time_zone==No)
{
SesNoOp=StringToTime(tmopno);
SesNoCl=StringToTime(tmclno);
zntm=SesNoOp;
znop=SesNoOp;
zncl=SesNoCl;
tz_ses="Not Use Time Zone";
tz_opn=timehr(ReqTime(SesNoOp,hour),ReqTime(SesNoOp,min));
tz_cls=timehr(ReqTime(SesNoCl,hour),ReqTime(SesNoCl,min));
}
//--
return;
//---
} //-end Time_Zone()
//---------//
bool MCEA::Trade_session(void)
{
//---
bool trd_ses=false;
ishour=ThisTime(hour);
if(ishour!=onhour) Set_Time_Zone();
datetime tcurr=TimeCurrent(); // Server Time
//--
switch(session)
{
case Cus_Session:
{
if(tcurr>=SesCuOp && tcurr<=SesCuCl) trd_ses=true;
break;
}
case New_Zealand:
{
if(tcurr>=Ses01Op && tcurr<=Ses01Cl) trd_ses=true;
break;
}
case Australia:
{
if(tcurr>=Ses02Op && tcurr<=Ses02Cl) trd_ses=true;
break;
}
case Asia_Tokyo:
{
if(tcurr>=Ses03Op && tcurr<=Ses03Cl) trd_ses=true;
break;
}
case Europe_London:
{
if(tcurr>=Ses04Op && tcurr<=Ses04Cl) trd_ses=true;
break;
}
case US_New_York:
{
if(tcurr>=Ses05Op && tcurr<=Ses05Cl) trd_ses=true;
break;
}
}
//--
if(trd_time_zone==No)
{
if(tcurr>=SesNoOp && tcurr<=SesNoCl) trd_ses=true;
}
//--
onhour=ishour;
//--
return(trd_ses);
//---
} //-end Trade_session()
//---------//
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()
//---------//
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::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()
//---------//
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)+string(x_sec);
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()
//---------//
int MCEA::ReqTime(datetime reqtime,
const int reqmode)
{
MqlDateTime tm;
TimeToStruct(reqtime,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 ReqTime()
//---------//
string MCEA::AccountMode() // function: to known account trade mode
{
//----
//--- 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.ValidatePairs(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()
//---------//
int WS(int width) // Width Scaling factor wide button
{
//---
int res=0;
int reswidth=0;
//--- Calculating the scaling factor wide button on a screen
int 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-tsatu)*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()
//---------//
//--------------------------------------------------------------------//
Please download the Expert Advisor: ExpMACross1_MCEA
