1632 lines
43 KiB
Plaintext
1632 lines
43 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Class Library
|
|
// ----------------------------------------------
|
|
// Name: XSCX121EA
|
|
// Description: an Expert Class which
|
|
// used X121 Setup ...
|
|
//
|
|
//
|
|
// Maintainer:
|
|
// ------------
|
|
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
|
|
//
|
|
//////////////////////////////////////////////////////
|
|
//
|
|
// Global Properties ...
|
|
#property library
|
|
#property copyright "Copyright 2023, SaherElm IT Center"
|
|
#property link "https://www.saherelm.ir"
|
|
#property version "1.00"
|
|
#property strict
|
|
|
|
//
|
|
// START Import and Inclused requirements ...
|
|
//
|
|
|
|
//
|
|
// Includes ...
|
|
#include "../Classes/x-saherelm.xea.class.mq5"
|
|
#include "../Libraries/x-saherelm.x121.draw.lib.mq5"
|
|
#include "../Libraries/x-saherelm.x121.support.lib.mq5"
|
|
#include "../Libraries/x-saherelm.x121.signaller.lib.mq5"
|
|
#include "../Classes/x-saherelm.x121.provider.class.mq5"
|
|
|
|
//
|
|
// END Import and Inclused requirements ...
|
|
//
|
|
|
|
//
|
|
// START Definitions ...
|
|
//
|
|
|
|
//
|
|
// an Structure to Holds a Support of Support ...
|
|
struct XSupport
|
|
{
|
|
//
|
|
// Supported Position ...
|
|
XPosition position;
|
|
|
|
//
|
|
// Last Support Date ...
|
|
ulong lastSupport;
|
|
|
|
//
|
|
// Last SUpported Volume ...
|
|
double lastSupportVolume;
|
|
};
|
|
|
|
//
|
|
// END Definitions ...
|
|
//
|
|
|
|
//
|
|
// START Overrides ...
|
|
//
|
|
|
|
//
|
|
// END Overrides ...
|
|
//
|
|
|
|
//
|
|
// an Expert Advisor Class by X121Provider ...
|
|
class XSCX121EA : public XSCBaseEA
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
// Constructor ...
|
|
void XSCX121EA(
|
|
string symbol, // Trading Symbol
|
|
ENUM_TIMEFRAMES period, // Trading Time Frame
|
|
ulong magic, // Magic Number
|
|
int slippage, // Slippgae
|
|
TOnStopLoss onStopLossTriggered = NULL, // On StopLoass Triggered Event Handler
|
|
TOnTakeProfit onTakeProfitTriggered = NULL, // On TakeProfit Triggered Event Handler
|
|
TOnDealsChanged onDealsChangedHandler = NULL, // On Deals Changed Event Handler
|
|
TOnOrdersChanged onOrdersChangedHandler = NULL, // On Orders Changed Event Handler
|
|
TOnPositionsChanged onPositionsChangedHandler = NULL, // On Positions Changed Event Handler
|
|
TOnTradeStateChanged onTradeStateChangedHandler = NULL, // On Trade State Changed Event Handler
|
|
TOnSignalConditions onSignalConditions = NULL // On SignalConditions Event Handler
|
|
) : XSCBaseEA(symbol,
|
|
period,
|
|
magic,
|
|
slippage,
|
|
onStopLossTriggered,
|
|
onTakeProfitTriggered,
|
|
onDealsChangedHandler,
|
|
onOrdersChangedHandler,
|
|
onPositionsChangedHandler,
|
|
onTradeStateChangedHandler)
|
|
{
|
|
mOnSignalConditions = onSignalConditions;
|
|
}
|
|
|
|
//
|
|
// DeConstructor ...
|
|
void ~XSCX121EA()
|
|
{
|
|
//
|
|
int providersCount = ArraySize(mProviders);
|
|
if (providersCount > 0)
|
|
{
|
|
//
|
|
for (int i = 0; i < providersCount; i++)
|
|
{
|
|
//
|
|
X121SignalProvider iProvider = mProviders[i];
|
|
|
|
//
|
|
delete iProvider.provider;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// START Properties ...
|
|
//
|
|
|
|
//
|
|
// Add Provider ...
|
|
bool AddProvider(
|
|
X121SignalProvider &provider // Specific Provider ...
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Provider ...
|
|
if (provider.symbol == NULL ||
|
|
provider.period == NULL ||
|
|
provider.riskAmount <= 0 ||
|
|
StringLen(provider.symbol) == 0 ||
|
|
ArraySize(provider.providers) == 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Exists or not ...
|
|
int idx = GetProviderIndex(
|
|
provider.symbol,
|
|
provider.period);
|
|
if (idx >= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
PrepareProviderConfig();
|
|
|
|
//
|
|
// Make Instance of X121Provider Class ...
|
|
provider.provider = new XSCX121Provider(
|
|
mSymbol,
|
|
mPeriod);
|
|
|
|
//
|
|
// Attach Event Listener ...
|
|
if (mOnSignalConditions != NULL)
|
|
{
|
|
//
|
|
// Attach Event Handlers ...
|
|
provider.provider.AddOnSignalConditionEventHandler(mOnSignalConditions);
|
|
}
|
|
|
|
//
|
|
// Set Signallers to Provider Class ...
|
|
result = provider.provider.SetSignallers(provider.providers);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Initialize Provider ...
|
|
result = provider.provider.SetConfig(mProviderConfig);
|
|
|
|
//
|
|
// Add Prepared Provider to Providers ...
|
|
Add(
|
|
provider,
|
|
mProviders);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Add Providers ...
|
|
int AddProviders(
|
|
X121SignalProvider &providers[] // Specific Providers ...
|
|
)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
int providersCount = ArraySize(providers);
|
|
if (providersCount <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < providersCount; i++)
|
|
{
|
|
//
|
|
X121SignalProvider iProvider = providers[i];
|
|
|
|
//
|
|
bool isAdded = AddProvider(iProvider);
|
|
if (isAdded)
|
|
{
|
|
result++;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// END Properties ...
|
|
//
|
|
|
|
//
|
|
// START Overrides ...
|
|
//
|
|
|
|
//
|
|
void OnPositionsChangedHandler(int count)
|
|
{
|
|
//
|
|
XPosition positions[];
|
|
mTrader.GetPositions(positions);
|
|
int positionsCount = ArraySize(positions);
|
|
if (positionsCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < positionsCount; i++)
|
|
{
|
|
//
|
|
XPosition iPosition = positions[i];
|
|
|
|
//
|
|
XPositionPack pack;
|
|
bool hasPositionPack = mTrader.GetPositionPack(
|
|
iPosition.ticket,
|
|
pack);
|
|
if (hasPositionPack)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Handle TakeProfit Event ...
|
|
void OnTakeProfitTriggered(const XDeal &deal)
|
|
{
|
|
//
|
|
// Get Take Profit Position ...
|
|
ulong ticket = deal.positionId;
|
|
string symbol = deal.symbol;
|
|
|
|
//
|
|
XOrder supportOrders[];
|
|
|
|
//
|
|
XOrder orders[];
|
|
mTrader.GetOrders(
|
|
orders,
|
|
symbol,
|
|
NULL,
|
|
ORDER_STATE_PLACED);
|
|
int ordersCount = ArraySize(orders);
|
|
if (ordersCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < ordersCount; i++)
|
|
{
|
|
//
|
|
XOrder iOrder = orders[i];
|
|
|
|
//
|
|
string params[];
|
|
bool isSupport = ExtractSupportParams(
|
|
iOrder.comment,
|
|
params);
|
|
if (!isSupport)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
ulong parentTicket = ExtractParentTicket(iOrder.comment);
|
|
if (parentTicket != ticket)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
Add(
|
|
iOrder,
|
|
supportOrders);
|
|
}
|
|
|
|
//
|
|
int supportOrdersCount = ArraySize(supportOrders);
|
|
if (supportOrdersCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
bool isCanceled = mTrader.CancelOrders(supportOrders);
|
|
if (isCanceled)
|
|
{
|
|
//
|
|
string message = "Close (" + ToString(supportOrdersCount) + ") Support of: (" + ToString(ticket) + ") due it's Take Profit ...";
|
|
|
|
//
|
|
LogMessage(message);
|
|
}
|
|
}
|
|
|
|
//
|
|
// END Overrides ...
|
|
//
|
|
|
|
//
|
|
// START Inheritance Functions ...
|
|
//
|
|
|
|
//
|
|
void PrepareTag()
|
|
{
|
|
mTag = "X121EA:" + mSymbol + "," + ToString(mPeriod) + (string)mMagic;
|
|
}
|
|
|
|
//
|
|
// Check Providers Guard States ...
|
|
bool CheckGuard(XGuard &guards[])
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
Clean(guards);
|
|
|
|
//
|
|
int providersCount = ArraySize(mProviders);
|
|
if (providersCount <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < providersCount; i++)
|
|
{
|
|
//
|
|
X121SignalProvider iProvider = mProviders[i];
|
|
|
|
//
|
|
XGuard iGuards[];
|
|
bool iHasGuard = iProvider.provider.GuardCheck(iGuards);
|
|
if (iHasGuard)
|
|
{
|
|
//
|
|
Copy(
|
|
iGuards,
|
|
guards,
|
|
false);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Here we Can Implement Custom Guards Senario ...
|
|
|
|
//
|
|
// Do Management Equity ...
|
|
HandleEquityManagement();
|
|
|
|
//
|
|
result = ArraySize(guards) > 0;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Providers for Signals ...
|
|
bool SignalCheck(XSignal &signals[])
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
Clean(signals);
|
|
|
|
//
|
|
// Check Max Allowed Positions ...
|
|
result = ChecPositionsForTrade();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Equity ...
|
|
result = CheckEquityForTrade();
|
|
if (!result) {
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int providersCount = ArraySize(mProviders);
|
|
if (providersCount <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < providersCount; i++)
|
|
{
|
|
//
|
|
X121SignalProvider iProvider = mProviders[i];
|
|
|
|
//
|
|
int iFoundedPivots = iProvider.provider.CountPivots();
|
|
int iReuiredPivots = iProvider.provider.GetMinPivots();
|
|
if (iFoundedPivots < iReuiredPivots)
|
|
{
|
|
//
|
|
iProvider.provider.ProccessPivotPoints();
|
|
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
X121MarketConditions iConditions;
|
|
//
|
|
// By Use this Template we Can Test Signallers
|
|
// then Make Them Traditional ...
|
|
bool iHasSignal = XTMPProcessSignal(
|
|
iConditions,
|
|
iProvider.provider);
|
|
|
|
//
|
|
// TODO: Fix this ...
|
|
// iProvider.provider.ProcessTick(iConditions);
|
|
|
|
//
|
|
if (iHasSignal && iConditions.hasSignal)
|
|
{
|
|
//
|
|
// Check Signalling is Enabled by Signal type ...
|
|
bool isiSignalLong = IsLong(iConditions.signal.type);
|
|
if ((isiSignalLong && !mEnableLongs) || (!isiSignalLong && !mEnableShorts))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
PrepareConditionsSignal(iConditions);
|
|
|
|
//
|
|
// Generate Support Signals ...
|
|
// GenerateSignalSupports(
|
|
// iConditions.signal,
|
|
// iProvider.provider);
|
|
|
|
//
|
|
// DrawConditionsSignalOnChart(iConditions);
|
|
|
|
//
|
|
Add(
|
|
iConditions.signal,
|
|
signals);
|
|
}
|
|
}
|
|
|
|
//
|
|
result = ArraySize(signals) > 0;
|
|
|
|
//
|
|
// IMPORTANT:
|
|
// Since we have to Implement our Signal Execution Senario
|
|
// Ignore this here for Default behaviour and implememt or Execution ...
|
|
if (result)
|
|
{
|
|
//
|
|
XSignal allowedSignals[];
|
|
|
|
//
|
|
// Select Which Signal need To Execute ...
|
|
bool hasEquity = CheckEquityForTrade();
|
|
if (hasEquity)
|
|
{
|
|
//
|
|
// Since we have necessary Equity for Trade ...
|
|
// Accept all incomming Signals ...
|
|
Copy(
|
|
signals,
|
|
allowedSignals);
|
|
|
|
//
|
|
// TODO:
|
|
// Implement Trade Policies ...
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// How to Select Signals when there is no Equity for Trade ...
|
|
LogMessage("No Equity ...");
|
|
}
|
|
|
|
//
|
|
int allowedSignalsCount = ArraySize(allowedSignals);
|
|
if (allowedSignalsCount > 0)
|
|
{
|
|
//
|
|
// Execute Signals oly when allowed ...
|
|
mTrader.ExecuteSignals(allowedSignals);
|
|
}
|
|
|
|
//
|
|
// Prevent Default Base Signal Execution ...
|
|
|
|
//
|
|
Clean(signals);
|
|
|
|
//
|
|
return false;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// END Inheritance Functions ...
|
|
//
|
|
|
|
//
|
|
// START Provided Actions ...
|
|
//
|
|
|
|
//
|
|
// END Provided Actions ...
|
|
//
|
|
|
|
//
|
|
// Protected ...
|
|
protected:
|
|
//
|
|
// Private ...
|
|
private:
|
|
//
|
|
// Props ...
|
|
X121SignalProvider mProviders[];
|
|
X121ProviderInputs mProviderConfig;
|
|
TOnSignalConditions mOnSignalConditions;
|
|
|
|
//
|
|
// Actions ...
|
|
|
|
//
|
|
// SUPPORT ...
|
|
//
|
|
|
|
//
|
|
// EQUITYMANAGEMENT ...
|
|
// Supported Positions ...
|
|
XSupport mSupports[];
|
|
|
|
//
|
|
// EQUITYMANAGEMENT ...
|
|
// Check Support of Supports Exists or ot ...
|
|
bool HasSuppors()
|
|
{
|
|
return CountSupports() > 0;
|
|
}
|
|
|
|
//
|
|
// EQUITYMANAGEMENT ...
|
|
// Count Exists Support of Supports ...
|
|
int CountSupports()
|
|
{
|
|
return ArraySize(mSupports);
|
|
}
|
|
|
|
//
|
|
// EQUITYMANAGEMENT ...
|
|
// Retrieve Supported of Supports ...
|
|
int GetSupportsIndex(
|
|
ulong ticket // Desired Support Position Ticket ...
|
|
)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
int supportsCount = CountSupports();
|
|
if (supportsCount <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < supportsCount; i++)
|
|
{
|
|
//
|
|
XSupport iSupport = mSupports[i];
|
|
|
|
//
|
|
if (iSupport.position.ticket != 0 &&
|
|
iSupport.position.ticket == ticket)
|
|
{
|
|
//
|
|
result = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// EQUITYMANAGEMENT ...
|
|
// Add Supported of Supports ...
|
|
bool AddSupports(
|
|
XSupport &support // Support item ...
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Check Support Exists or not ...
|
|
int supIndex = GetSupportsIndex(support.position.ticket);
|
|
if (supIndex < 0)
|
|
{
|
|
//
|
|
// Add New ...
|
|
Add(support,
|
|
mSupports);
|
|
|
|
//
|
|
result = true;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Update Exists ...
|
|
|
|
//
|
|
int supportsCount = CountSupports();
|
|
XSupport collection[];
|
|
for (int i = 0; i < supportsCount; i++)
|
|
{
|
|
//
|
|
XSupport iSupport = mSupports[i];
|
|
|
|
//
|
|
if (iSupport.position.ticket == support.position.ticket)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
Add(iSupport,
|
|
collection);
|
|
}
|
|
|
|
//
|
|
Add(support,
|
|
collection);
|
|
|
|
//
|
|
Copy(
|
|
collection,
|
|
mSupports,
|
|
true);
|
|
|
|
//
|
|
Clean(collection);
|
|
|
|
//
|
|
result = true;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// EQUITYMANAGEMENT ...
|
|
// Remove Supported Of Supports ...
|
|
bool RemoveSupports(
|
|
XSupport &support // Support item ...
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Check Support Exists or not ...
|
|
int supIndex = GetSupportsIndex(support.position.ticket);
|
|
if (supIndex < 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int supportsCount = CountSupports();
|
|
XSupport collection[];
|
|
for (int i = 0; i < supportsCount; i++)
|
|
{
|
|
//
|
|
XSupport iSupport = mSupports[i];
|
|
|
|
//
|
|
if (iSupport.position.ticket == support.position.ticket)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
Add(iSupport,
|
|
collection);
|
|
}
|
|
|
|
//
|
|
Copy(
|
|
collection,
|
|
mSupports,
|
|
true);
|
|
|
|
//
|
|
Clean(collection);
|
|
|
|
//
|
|
result = true;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// EQUITYMANAGEMENT ...
|
|
int GetSupportAge(
|
|
int index // Supported Index
|
|
)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
int supportsCount = CountSupports();
|
|
if (index < 0 || index > supportsCount - 1)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Required Info ...
|
|
string symbol = mSupports[index].position.symbol;
|
|
ENUM_TIMEFRAMES period = mSupports[index].position.period;
|
|
datetime lastDate = MilliSecondsToTiem(mSupports[index].lastSupport);
|
|
|
|
//
|
|
// Calculate Age ...
|
|
result = iBarShift(
|
|
symbol,
|
|
period,
|
|
lastDate);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// EQUITYMANAGEMENT ...
|
|
//
|
|
|
|
//
|
|
// Do All Equity Management Works here ...
|
|
void HandleEquityManagement()
|
|
{
|
|
|
|
//
|
|
// Handle Hedging Positions ...
|
|
HandleHedging();
|
|
|
|
//
|
|
return;
|
|
|
|
//
|
|
// Close All Long Time Placed Support Signals
|
|
// Which doesn't Triggered yest ...
|
|
HandleCancelAllUntriggeredSupports();
|
|
|
|
//
|
|
// Check Equity ...
|
|
bool hasEquity = CheckEquityForTrade();
|
|
if (hasEquity)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Retrieve Provider Count ...
|
|
int providersCount = ArraySize(mProviders);
|
|
if (providersCount <= 0)
|
|
{
|
|
//
|
|
// We Have at least two Position for Hedging ...
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Loop Through Registered Provider Instances ...
|
|
for (int i = 0; i < providersCount; i++)
|
|
{
|
|
//
|
|
bool canIgnoreSupporting = false;
|
|
|
|
//
|
|
X121SignalProvider iSProvider = mProviders[i];
|
|
|
|
//
|
|
string symbol = iSProvider.symbol;
|
|
ENUM_TIMEFRAMES period = iSProvider.period;
|
|
XSCX121Provider *analyzer = iSProvider.provider;
|
|
|
|
//
|
|
// We Have to Detect Each Providers In DrawDown Signals and then
|
|
// Found any Support Signals for them ...
|
|
// 1- must have at least TWO Support Signal without tp ...
|
|
// 2- there are some signals by providing tp ...
|
|
// 3- Trend base and Conditional Supports by tp ...
|
|
|
|
//
|
|
XPosition inDrawdownPositions[];
|
|
GetInDrawdownPositions(
|
|
inDrawdownPositions, // Result ...
|
|
symbol,
|
|
NULL, // All Types ...
|
|
period,
|
|
NULL, // All Providers ...
|
|
NULL // Select All ...
|
|
);
|
|
int inDrawdownPositionsCount = ArraySize(inDrawdownPositions);
|
|
if (inDrawdownPositionsCount <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Find Oldest Position to CHeck Trade Age ...
|
|
XPosition oldestInDrawdownPosition;
|
|
int oldestInDrawdownPositionAge = GetOldest(
|
|
oldestInDrawdownPosition,
|
|
inDrawdownPositions);
|
|
bool isTooOldForSupport = oldestInDrawdownPositionAge >= oldAgePositionForSupportFactor;
|
|
if (!isTooOldForSupport)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Now we Have to Check Exists EQM Supports ...
|
|
XOrder orders[];
|
|
GetOrders(
|
|
orders,
|
|
symbol,
|
|
NULL, // All Types ...
|
|
NULL, // All States ...
|
|
period,
|
|
NULL // All Providers ...
|
|
);
|
|
int ordersCount = ArraySize(orders);
|
|
if (ordersCount > 0)
|
|
{
|
|
//
|
|
// Extract EQM Support Signals ...
|
|
XOrder supportOrders[];
|
|
ordersCount = GetEQMSupportOrders(
|
|
supportOrders,
|
|
orders,
|
|
period);
|
|
if (ordersCount > 0)
|
|
{
|
|
//
|
|
// Since there are EQM Untriggere Support Orders here ...
|
|
// we have to check theirs longest Age ...
|
|
XOrder longestUntriggeredSupportOrder;
|
|
int longestUntriggeredSupportOrderAge = GetOldest(
|
|
longestUntriggeredSupportOrder,
|
|
supportOrders);
|
|
canIgnoreSupporting = longestUntriggeredSupportOrderAge < oldAgeSupportForReNewFactor;
|
|
if (canIgnoreSupporting)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Here we Have To Generate new Support Signals and Execute them ...
|
|
XSignal supports[];
|
|
int supportsCount = GenerateMarketSupports(
|
|
supports,
|
|
symbol, // Trading Symbol ...
|
|
period, // Trading Timeframe ...
|
|
analyzer // Market Analizer ( Signal Provider Instance ) ...
|
|
);
|
|
if (supportsCount <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
PrepareSignals(supports);
|
|
|
|
//
|
|
string comment = GenerateXEQMSupportComment(period);
|
|
int executed = mTrader.ExecuteSignals(
|
|
supports,
|
|
comment);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Close All Positions in Summary Profit ...
|
|
bool HandleHedging()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// List All Open Positions and Calculate Profit Summary ...
|
|
|
|
//
|
|
double profit = 0;
|
|
double requiredProfit = 0;
|
|
|
|
//
|
|
XPosition positions[];
|
|
GetPositions(
|
|
positions, // Result ...
|
|
NULL, // All Symbols ...
|
|
NULL, // All Types ...
|
|
NULL, // All Period ...
|
|
NULL // All Providers ...
|
|
);
|
|
int positionsCount = ArraySize(positions);
|
|
if (positionsCount <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < positionsCount; i++)
|
|
{
|
|
//
|
|
XPosition iPosition = positions[i];
|
|
|
|
//
|
|
profit += iPosition.profit;
|
|
requiredProfit += ((iPosition.volume / minProfitPerVolumeFactor) * minProfitPerTrade) + (-1 * iPosition.swap);
|
|
}
|
|
|
|
//
|
|
// Check We Can Hedge or not ...
|
|
result = profit >= requiredProfit;
|
|
if (!result)
|
|
{
|
|
//
|
|
// Here we Have to Close Long In Profit Trades ...
|
|
// Open Positions ...
|
|
XPosition longestInProfitPosition;
|
|
int longestInProfitPositionAge = GetOldest(
|
|
longestInProfitPosition,
|
|
positions);
|
|
double requireProfit = minProfitPerTrade * (longestInProfitPosition.profit / minProfitPerVolumeFactor) + -1 * (longestInProfitPosition.swap);
|
|
bool canClose =
|
|
longestInProfitPositionAge >= oldAgePositionForSupportFactor &&
|
|
longestInProfitPosition.profit > 0 && longestInProfitPosition.profit > requireProfit;
|
|
if (canClose)
|
|
{
|
|
//
|
|
string comment = "EQM Close In Profit ...";
|
|
|
|
//
|
|
bool isClosed = mTrader.Close(
|
|
longestInProfitPosition.ticket,
|
|
comment);
|
|
if (isClosed)
|
|
{
|
|
//
|
|
// Force Cancel All Pending Orders ...
|
|
HandleCancelAllUntriggeredSupports(true);
|
|
|
|
//
|
|
string message = "EQM Close Position (" + ToString(longestInProfitPosition.ticket) + ") by: " + ToString(longestInProfitPosition.profit);
|
|
|
|
//
|
|
LogMessage(message);
|
|
|
|
//
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check if one Position is Open and it's in Drawdown and ore than
|
|
// longest age ...
|
|
// close it ...
|
|
// if (!result)
|
|
// {
|
|
// //
|
|
// if (longestInProfitPositionAge >= oldAgePositionForSupportFactor)
|
|
// {
|
|
// //
|
|
// string comment = "EQM Close In DD ...";
|
|
|
|
// //
|
|
// int closed = mTrader.ClosePositions(
|
|
// positions,
|
|
// comment);
|
|
// result = closed == positionsCount;
|
|
// }
|
|
// }
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string comment = "EQM Hedge ...";
|
|
int closed = mTrader.ClosePositions(
|
|
positions,
|
|
comment);
|
|
|
|
//
|
|
result = closed == positionsCount;
|
|
if (result)
|
|
{
|
|
//
|
|
// Force Cancel All Pending Orders ...
|
|
HandleCancelAllUntriggeredSupports(true);
|
|
|
|
//
|
|
string message = "EQM Close (" + ToString(closed) + ") Positions due HEDGE by: " + ToString(profit);
|
|
|
|
//
|
|
LogMessage(message);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// We Have To Cancell All Untriggered Supports ...
|
|
void HandleCancelAllUntriggeredSupports(
|
|
bool force = false // Force Close All ...
|
|
)
|
|
{
|
|
//
|
|
// Retrieve all Placed EQM Supports ...
|
|
XOrder orders[];
|
|
GetOrders(
|
|
orders,
|
|
NULL, // All Symbols ...
|
|
NULL, // All Types ...
|
|
NULL, // All State ...
|
|
NULL, // All Periods ...
|
|
NULL // All Providers ...
|
|
);
|
|
int ordersCount = ArraySize(orders);
|
|
if (ordersCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
XOrder supports[];
|
|
int supportsCount = GetEQMSupportOrders(
|
|
supports,
|
|
orders,
|
|
NULL // All Time Frames ...
|
|
);
|
|
if (supportsCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
XOrder oldest;
|
|
int oldestAge = GetOldest(
|
|
oldest,
|
|
orders);
|
|
bool isTooOldForCancel = oldestAge >= oldAgeSupportForReNewFactor;
|
|
if (!force && !isTooOldForCancel)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
bool isCanceled = mTrader.CancelOrders(
|
|
supports);
|
|
}
|
|
|
|
//
|
|
// Pepare a Collection Of Signals ...
|
|
void PrepareSignals(XSignal &signals[])
|
|
{
|
|
//
|
|
int signalsCount = ArraySize(signals);
|
|
if (signalsCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < signalsCount; i++)
|
|
{
|
|
//
|
|
PrepareSignal(signals[i]);
|
|
}
|
|
}
|
|
|
|
//
|
|
// PROVIDERS ...
|
|
//
|
|
|
|
//
|
|
// Find Specific Provider Index by using give symbol and period ...
|
|
int GetProviderIndex(
|
|
string symbol, // Trading Symbol ...
|
|
ENUM_TIMEFRAMES period // Trading Time frame ...
|
|
)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (period == NULL ||
|
|
symbol == NULL ||
|
|
StringLen(symbol) == 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int providersCount = ArraySize(mProviders);
|
|
if (providersCount <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < providersCount; i++)
|
|
{
|
|
//
|
|
X121SignalProvider iProvider = mProviders[i];
|
|
|
|
//
|
|
if (iProvider.symbol == symbol && iProvider.period == period)
|
|
{
|
|
//
|
|
result = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Prepare Default Configurations for X121Provider Setup ...
|
|
void PrepareProviderConfig()
|
|
{
|
|
//
|
|
// XCT ...
|
|
// Candle Timing ...
|
|
mProviderConfig.xctConfig.clr = clrBlueViolet;
|
|
mProviderConfig.xctConfig.corner = CORNER_RIGHT_UPPER;
|
|
mProviderConfig.xctConfig.showCandleTime = true;
|
|
|
|
//
|
|
// XCC ...
|
|
// Candle Styling ...
|
|
mProviderConfig.xccConfig.upColor = clrLime;
|
|
mProviderConfig.xccConfig.downColor = clrRed;
|
|
mProviderConfig.xccConfig.lineColor = clrLime;
|
|
mProviderConfig.xccConfig.bearishColor = clrRed;
|
|
mProviderConfig.xccConfig.bullishColor = clrLime;
|
|
mProviderConfig.xccConfig.volumesColor = clrGreen;
|
|
mProviderConfig.xccConfig.showCandles = true;
|
|
|
|
//
|
|
// XHK ...
|
|
// HikenAshi Candle Representing ...
|
|
mProviderConfig.xhkConfig.drawCandleLines = false;
|
|
|
|
//
|
|
// XTM ...
|
|
// Trend Magic ...
|
|
mProviderConfig.xtmConfig.length = 35;
|
|
mProviderConfig.xtmConfig.shift = 0;
|
|
mProviderConfig.xtmConfig.method = MODE_SMA;
|
|
mProviderConfig.xtmConfig.appliedTo = PRICE_LOW;
|
|
mProviderConfig.xtmConfig.showLine = false;
|
|
|
|
//
|
|
// XPV ...
|
|
// Peaks And Vales ...
|
|
mProviderConfig.xpvConfig.shortLength = 9;
|
|
mProviderConfig.xpvConfig.mediumLength = 17;
|
|
mProviderConfig.xpvConfig.longLength = 26;
|
|
mProviderConfig.xpvConfig.hindLength = 35;
|
|
mProviderConfig.xpvConfig.fiboLevel1 = 0.382;
|
|
mProviderConfig.xpvConfig.fiboLevel2 = 0.5;
|
|
mProviderConfig.xpvConfig.fiboLevel3 = 0.618;
|
|
mProviderConfig.xpvConfig.hhMode = MODE_HIGH;
|
|
mProviderConfig.xpvConfig.llMode = MODE_LOW;
|
|
mProviderConfig.xpvConfig.showPeaksAndVales = false;
|
|
mProviderConfig.xpvConfig.showLevels = false;
|
|
mProviderConfig.xpvConfig.showFibo1Levels = false;
|
|
mProviderConfig.xpvConfig.showFibo2Levels = false;
|
|
mProviderConfig.xpvConfig.showFibo3Levels = false;
|
|
|
|
//
|
|
// XAMA ...
|
|
// Adaptive Moving Average ...
|
|
mProviderConfig.xamaConfig.length = 52;
|
|
mProviderConfig.xamaConfig.fastEMA = 2;
|
|
mProviderConfig.xamaConfig.slowEMA = 30;
|
|
mProviderConfig.xamaConfig.maShift = 0;
|
|
mProviderConfig.xamaConfig.appliedTo = PRICE_LOW;
|
|
mProviderConfig.xamaConfig.showLine = false;
|
|
|
|
//
|
|
// XMRB ...
|
|
// Moving Average Ribbon ...
|
|
mProviderConfig.xmrbConfig.fast1Length = 3;
|
|
mProviderConfig.xmrbConfig.slow1Length = 5;
|
|
mProviderConfig.xmrbConfig.fast2Length = 8;
|
|
mProviderConfig.xmrbConfig.slow2Length = 13;
|
|
mProviderConfig.xmrbConfig.fast3Length = 21;
|
|
mProviderConfig.xmrbConfig.slow3Length = 34;
|
|
mProviderConfig.xmrbConfig.fast4Length = 55;
|
|
mProviderConfig.xmrbConfig.slow4Length = 89;
|
|
mProviderConfig.xmrbConfig.fast5Length = 144;
|
|
mProviderConfig.xmrbConfig.slow5Length = 233;
|
|
mProviderConfig.xmrbConfig.ribbonMode = MODE_EMA;
|
|
mProviderConfig.xmrbConfig.ribbonAppliedTo = PRICE_CLOSE;
|
|
mProviderConfig.xmrbConfig.showFastMa = false;
|
|
mProviderConfig.xmrbConfig.showSlowMa = false;
|
|
mProviderConfig.xmrbConfig.showRibbon = false;
|
|
|
|
//
|
|
// XCHE ...
|
|
// Chandelier Exit Points ...
|
|
mProviderConfig.xcheConfig.length = 35;
|
|
mProviderConfig.xcheConfig.loopback = 26;
|
|
mProviderConfig.xcheConfig.multiplier1 = 3;
|
|
mProviderConfig.xcheConfig.multiplier2 = 3.5;
|
|
mProviderConfig.xcheConfig.upAppliedTo = PRICE_HIGH;
|
|
mProviderConfig.xcheConfig.downAppliedTo = PRICE_LOW;
|
|
mProviderConfig.xcheConfig.showLongExit1Line = false;
|
|
mProviderConfig.xcheConfig.showShortExit1Line = false;
|
|
mProviderConfig.xcheConfig.showLongExit2Line = false;
|
|
mProviderConfig.xcheConfig.showShortExit2Line = false;
|
|
|
|
//
|
|
// XICH ...
|
|
// Ichimopku Kinko Hyo ...
|
|
mProviderConfig.xichConfig.tenkanSenLength = 9;
|
|
mProviderConfig.xichConfig.tenkanSenMode = X_XICH_HH_LL_MODE;
|
|
mProviderConfig.xichConfig.kijunSenLength = 26;
|
|
mProviderConfig.xichConfig.kijunSenMode = X_XICH_HH_LL_MODE;
|
|
mProviderConfig.xichConfig.senkouSpanBLength = 52;
|
|
mProviderConfig.xichConfig.senkouSpanBMode = X_XICH_HH_LL_MODE;
|
|
mProviderConfig.xichConfig.chikuoSpanAppliedTo = PRICE_CLOSE;
|
|
mProviderConfig.xichConfig.showTenkanSen = false;
|
|
mProviderConfig.xichConfig.showKijunSen = false;
|
|
mProviderConfig.xichConfig.showKijunSenPlus = false;
|
|
mProviderConfig.xichConfig.showKijunSenNegative = false;
|
|
mProviderConfig.xichConfig.showChikouSpan = false;
|
|
mProviderConfig.xichConfig.showSenkouSpanA = false;
|
|
mProviderConfig.xichConfig.showSenkouSpanB = false;
|
|
mProviderConfig.xichConfig.showKumo = false;
|
|
mProviderConfig.xichConfig.shiftKumo = true;
|
|
|
|
//
|
|
// XTRND ...
|
|
// Trend Detector ...
|
|
mProviderConfig.xtrndConfig.cycleLength = 2;
|
|
mProviderConfig.xtrndConfig.numberOfVerifications = 2;
|
|
mProviderConfig.xtrndConfig.hhMode = MODE_HIGH;
|
|
mProviderConfig.xtrndConfig.llMode = MODE_LOW;
|
|
mProviderConfig.xtrndConfig.l1Method = X_PERIOD_AUTO;
|
|
mProviderConfig.xtrndConfig.l1Period = NULL;
|
|
mProviderConfig.xtrndConfig.l2Method = X_PERIOD_AUTO;
|
|
mProviderConfig.xtrndConfig.l2Period = NULL;
|
|
mProviderConfig.xtrndConfig.l3Method = X_PERIOD_AUTO;
|
|
mProviderConfig.xtrndConfig.l3Period = NULL;
|
|
mProviderConfig.xtrndConfig.showConsolidations = false;
|
|
mProviderConfig.xtrndConfig.showTrend = false;
|
|
mProviderConfig.xtrndConfig.showL1Trend = false;
|
|
mProviderConfig.xtrndConfig.showL2Trend = false;
|
|
mProviderConfig.xtrndConfig.showL3Trend = false;
|
|
|
|
//
|
|
// XSSLC ...
|
|
// SSL Channel ...
|
|
mProviderConfig.xsslcConfig.length = 36;
|
|
mProviderConfig.xsslcConfig.method = MODE_SMA;
|
|
mProviderConfig.xsslcConfig.upAppliedTo = PRICE_HIGH;
|
|
mProviderConfig.xsslcConfig.downAppliedTo = PRICE_LOW;
|
|
mProviderConfig.xsslcConfig.showUp = false;
|
|
mProviderConfig.xsslcConfig.showDown = false;
|
|
|
|
//
|
|
// XHULL ...
|
|
// Hull Trend Detection Channel ...
|
|
mProviderConfig.xhullConfig.length = 72;
|
|
mProviderConfig.xhullConfig.divisor = 2;
|
|
mProviderConfig.xhullConfig.upAppliedTo = PRICE_HIGH;
|
|
mProviderConfig.xhullConfig.downAppliedTo = PRICE_LOW;
|
|
mProviderConfig.xhullConfig.showUpZone = false;
|
|
mProviderConfig.xhullConfig.showDownZone = false;
|
|
|
|
//
|
|
// XOSC ...
|
|
mProviderConfig.xoscConfig.atrLength = 14;
|
|
mProviderConfig.xoscConfig.rviLength = 10;
|
|
mProviderConfig.xoscConfig.bullpLength = 13;
|
|
mProviderConfig.xoscConfig.bearpLength = 13;
|
|
mProviderConfig.xoscConfig.volumeAppliedTo = VOLUME_TICK;
|
|
mProviderConfig.xoscConfig.rsiLength = 14;
|
|
mProviderConfig.xoscConfig.rsiAppliedTo = PRICE_CLOSE;
|
|
mProviderConfig.xoscConfig.cciLength = 14;
|
|
mProviderConfig.xoscConfig.cciAppliedTo = PRICE_TYPICAL;
|
|
mProviderConfig.xoscConfig.stddevLength = 20;
|
|
mProviderConfig.xoscConfig.stddevShift = 0;
|
|
mProviderConfig.xoscConfig.stddevMethod = MODE_SMA;
|
|
mProviderConfig.xoscConfig.stddevAppliedTo = PRICE_CLOSE;
|
|
mProviderConfig.xoscConfig.momentumLength = 14;
|
|
mProviderConfig.xoscConfig.momentumAppliedTo = PRICE_CLOSE;
|
|
mProviderConfig.xoscConfig.sarStep = 0.02;
|
|
mProviderConfig.xoscConfig.sarMaximum = 0.2;
|
|
mProviderConfig.xoscConfig.macdFastLength = 12;
|
|
mProviderConfig.xoscConfig.macdSlowLength = 26;
|
|
mProviderConfig.xoscConfig.macdSignaLength = 9;
|
|
mProviderConfig.xoscConfig.macdAppliedTo = PRICE_CLOSE;
|
|
mProviderConfig.xoscConfig.stochKLength = 5;
|
|
mProviderConfig.xoscConfig.stochDLength = 3;
|
|
mProviderConfig.xoscConfig.stochSlowing = 3;
|
|
mProviderConfig.xoscConfig.stochMaMethod = MODE_SMA;
|
|
mProviderConfig.xoscConfig.stochMode = STO_LOWHIGH;
|
|
|
|
//
|
|
// XSTR ...
|
|
mProviderConfig.xstrConfig.atrLength = 12;
|
|
mProviderConfig.xstrConfig.atrMultiplier = 3.0;
|
|
mProviderConfig.xstrConfig.atrAppliedTo = PRICE_MEDIAN;
|
|
mProviderConfig.xstrConfig.showTrends = false;
|
|
mProviderConfig.xstrConfig.fillTrends = false;
|
|
|
|
//
|
|
// XFBB ...
|
|
mProviderConfig.xfbbConfig.length = 200;
|
|
mProviderConfig.xfbbConfig.multiplier = 3.0;
|
|
mProviderConfig.xfbbConfig.appliedTo = PRICE_TYPICAL;
|
|
mProviderConfig.xfbbConfig.showBase = false;
|
|
mProviderConfig.xfbbConfig.showBand = false;
|
|
mProviderConfig.xfbbConfig.showGoldenArea = false;
|
|
mProviderConfig.xfbbConfig.showOthers = false;
|
|
|
|
//
|
|
// XDEMA ...
|
|
mProviderConfig.xdemaConfig.length = 200;
|
|
mProviderConfig.xdemaConfig.shift = 0;
|
|
mProviderConfig.xdemaConfig.showDema = false;
|
|
mProviderConfig.xdemaConfig.showEMA = false;
|
|
mProviderConfig.xdemaConfig.showEMAOfEMA = false;
|
|
|
|
//
|
|
PreDefineProviderConfig();
|
|
}
|
|
|
|
//
|
|
void PreDefineProviderConfig()
|
|
{
|
|
//
|
|
// Default Configs For Different States ...
|
|
bool showPV = false;
|
|
bool showHK = false;
|
|
bool showTM = false;
|
|
bool showCHE = false;
|
|
bool showSTR = false;
|
|
bool showFBB = false;
|
|
bool showMRB = false;
|
|
bool showTRND = false;
|
|
bool showDEMA = false;
|
|
bool showHULL = false;
|
|
bool showSimpleIchi = false;
|
|
|
|
//
|
|
// Predefine ...
|
|
|
|
//
|
|
// X786 ...
|
|
showPV = true;
|
|
// showTM = false;
|
|
// showHK = false;
|
|
showCHE = true;
|
|
// showSTR = false;
|
|
// showDEMA = true;
|
|
showTRND = true;
|
|
// showHULL = false;
|
|
// showSimpleIchi = false;
|
|
|
|
//
|
|
if (showHK)
|
|
{
|
|
//
|
|
// Hiken Ashi ...
|
|
mProviderConfig.xccConfig.showCandles = false;
|
|
mProviderConfig.xhkConfig.drawCandles = true;
|
|
}
|
|
if (showPV)
|
|
{
|
|
//
|
|
// Peaks and Vales ...
|
|
mProviderConfig.xpvConfig.showLevels = true;
|
|
mProviderConfig.xpvConfig.showFibo1Levels = true;
|
|
mProviderConfig.xpvConfig.showFibo2Levels = true;
|
|
mProviderConfig.xpvConfig.showFibo3Levels = true;
|
|
mProviderConfig.xpvConfig.showPeaksAndVales = true;
|
|
}
|
|
if (showSimpleIchi)
|
|
{
|
|
//
|
|
// Simple Ichimoku Kinko Hyo ...
|
|
mProviderConfig.xichConfig.showKijunSen = true;
|
|
mProviderConfig.xichConfig.showTenkanSen = true;
|
|
mProviderConfig.xichConfig.showSenkouSpanA = true;
|
|
mProviderConfig.xichConfig.showSenkouSpanB = true;
|
|
}
|
|
if (showCHE)
|
|
{
|
|
//
|
|
// Chandelier Exit ...
|
|
mProviderConfig.xcheConfig.showLongExit1Line = true;
|
|
mProviderConfig.xcheConfig.showLongExit2Line = true;
|
|
mProviderConfig.xcheConfig.showShortExit1Line = true;
|
|
mProviderConfig.xcheConfig.showShortExit2Line = true;
|
|
}
|
|
if (showTRND)
|
|
{
|
|
//
|
|
// Show Trend ...
|
|
mProviderConfig.xtrndConfig.showTrend = true;
|
|
mProviderConfig.xtrndConfig.showL1Trend = true;
|
|
mProviderConfig.xtrndConfig.showL2Trend = true;
|
|
mProviderConfig.xtrndConfig.showL3Trend = true;
|
|
mProviderConfig.xtrndConfig.showConsolidations = false;
|
|
}
|
|
if (showSTR)
|
|
{
|
|
//
|
|
// Show Super Trend ...
|
|
mProviderConfig.xstrConfig.showTrends = true;
|
|
}
|
|
if (showFBB)
|
|
{
|
|
//
|
|
// Show Fibonacci Band ...
|
|
mProviderConfig.xfbbConfig.showBase = true;
|
|
mProviderConfig.xfbbConfig.showBand = true;
|
|
mProviderConfig.xfbbConfig.showGoldenArea = true;
|
|
}
|
|
if (showDEMA)
|
|
{
|
|
//
|
|
// Show Double EMA ...
|
|
mProviderConfig.xdemaConfig.showDema = true;
|
|
}
|
|
if (showMRB)
|
|
{
|
|
//
|
|
mProviderConfig.xmrbConfig.showFastMa = true;
|
|
mProviderConfig.xmrbConfig.showSlowMa = true;
|
|
mProviderConfig.xmrbConfig.showRibbon = false;
|
|
}
|
|
if (showTM)
|
|
{
|
|
mProviderConfig.xtmConfig.showLine = true;
|
|
}
|
|
if (showHULL)
|
|
{
|
|
//
|
|
mProviderConfig.xhullConfig.showUpZone = true;
|
|
mProviderConfig.xhullConfig.showDownZone = true;
|
|
}
|
|
|
|
//
|
|
// X128 ...
|
|
//
|
|
// XTM ...
|
|
// Trend Magic ...
|
|
// mProviderConfig.xtmConfig.length = 17;
|
|
// mProviderConfig.xtmConfig.shift = 0;
|
|
// mProviderConfig.xtmConfig.method = MODE_SMA;
|
|
// mProviderConfig.xtmConfig.appliedTo = PRICE_CLOSE;
|
|
// mProviderConfig.xtmConfig.showLine = false;
|
|
|
|
//
|
|
// XAMA ...
|
|
// Adaptive Moving Average ...
|
|
// mProviderConfig.xamaConfig.length = 52;
|
|
// mProviderConfig.xamaConfig.fastEMA = 2;
|
|
// mProviderConfig.xamaConfig.slowEMA = 6;
|
|
// mProviderConfig.xamaConfig.maShift = 0;
|
|
// mProviderConfig.xamaConfig.appliedTo = PRICE_CLOSE;
|
|
// mProviderConfig.xamaConfig.showLine = false;
|
|
}
|
|
|
|
//
|
|
void PrepareConditionsSignal(X121MarketConditions &conditions)
|
|
{
|
|
//
|
|
if (!conditions.hasSignal)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
bool isLong = IsLong(conditions.signal.type);
|
|
|
|
//
|
|
// Check Calculate TP ...
|
|
if (
|
|
conditions.signal.sl > 0 &&
|
|
conditions.signal.r2r > 0 &&
|
|
conditions.signal.entry > 0 &&
|
|
conditions.signal.calculateTP)
|
|
{
|
|
//
|
|
double riskPrice = MathAbs(conditions.signal.entry - conditions.signal.sl);
|
|
double riskPoint = PriceToPoint(
|
|
conditions.signal.symbol,
|
|
riskPrice);
|
|
double rewardPoint = riskPoint * conditions.signal.r2r;
|
|
double rewardPrice = PointToPrice(
|
|
conditions.signal.symbol,
|
|
rewardPoint);
|
|
|
|
//
|
|
double tp =
|
|
isLong
|
|
? conditions.signal.entry + rewardPrice
|
|
: conditions.signal.entry - rewardPrice;
|
|
|
|
//
|
|
conditions.signal.tp = tp;
|
|
}
|
|
|
|
//
|
|
PrepareSignal(conditions.signal);
|
|
}
|
|
|
|
//
|
|
void DrawConditionsSignalOnChart(X121MarketConditions &conditions)
|
|
{
|
|
//
|
|
ulong mTicket = MathRand() * 100000;
|
|
|
|
//
|
|
DrawSignal(
|
|
mTicket,
|
|
conditions.signal);
|
|
|
|
//
|
|
DrawSupportResistance(
|
|
0,
|
|
conditions.supportResistances,
|
|
conditions.signal.providers[0]);
|
|
}
|
|
};
|
|
|
|
//
|
|
// START Usefull Functions ...
|
|
//
|
|
|
|
//
|
|
// END Usefull Functions ...
|
|
//
|