2085 lines
41 KiB
Plaintext
2085 lines
41 KiB
Plaintext
///////////////////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 XTEST Signal Provider Indicators Library
|
|
// ----------------------------------------------------------------
|
|
//
|
|
// 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
|
|
|
|
//
|
|
// Include Provider Inputs ...
|
|
#include "x-saherelm.xtest.provider.inputs.lib.mq5"
|
|
|
|
//
|
|
// Include Provider Class ...
|
|
#include "../Classes/x-saherelm.provider.lib.mq5"
|
|
|
|
//
|
|
// Signallers ...
|
|
input group "XTEST Signallers";
|
|
|
|
//
|
|
// XTD ...
|
|
input group "XTEST XTD Signaller";
|
|
input bool xTESTXTDEnableSignaller = true; // Enable Signaller
|
|
input bool xTESTXTDAllowLongSignals = true; // Enable Long Signals
|
|
input bool xTESTXTDAllowShortSignals = true; // Enable Short Signals
|
|
|
|
//
|
|
// XTAM ...
|
|
input group "XTEST XTAM Signaller";
|
|
input bool xTESTXTAMEnableSignaller = true; // Enable Signaller
|
|
input bool xTESTXTAMAllowLongSignals = true; // Enable Long Signals
|
|
input bool xTESTXTAMAllowShortSignals = true; // Enable Short Signals
|
|
|
|
//
|
|
// XSI ...
|
|
input group "XTEST XSI Signaller";
|
|
input bool xTESTXSIEnableSignaller = true; // Enable Signaller
|
|
input bool xTESTXSIAllowLongSignals = true; // Enable Long Signals
|
|
input bool xTESTXSIAllowShortSignals = true; // Enable Short Signals
|
|
|
|
//
|
|
// XTSFI ...
|
|
input group "XTEST XTSFI Signaller";
|
|
input bool xTESTXTSFIEnableSignaller = true; // Enable Signaller
|
|
input bool xTESTXTSFIAllowLongSignals = true; // Enable Long Signals
|
|
input bool xTESTXTSFIAllowShortSignals = true; // Enable Short Signals
|
|
|
|
//
|
|
// XOBDLH ...
|
|
// input group "XTEST XOBDLH Signaller";
|
|
// input bool xTESTXOBDLHEnableSignaller = true; // Enable Signaller
|
|
// input bool xTESTXOBDLHAllowLongSignals = true; // Enable Long Signals
|
|
// input bool xTESTXOBDLHAllowShortSignals = true; // Enable Short Signals
|
|
|
|
//
|
|
// XCHMACC ...
|
|
input group "XTEST XCHMACC Signaller";
|
|
input bool xTESTXCHMACCEnableSignaller = true; // Enable Signaller
|
|
input bool xTESTXCHMACCAllowLongSignals = true; // Enable Long Signals
|
|
input bool xTESTXCHMACCAllowShortSignals = true; // Enable Short Signals
|
|
|
|
//
|
|
// XCHMAMX ...
|
|
// input group "XTEST XCHMAMX Signaller";
|
|
// input bool xTESTXCHMAMXEnableSignaller = true; // Enable Signaller
|
|
// input bool xTESTXCHMAMXAllowLongSignals = true; // Enable Long Signals
|
|
// input bool xTESTXCHMAMXAllowShortSignals = true; // Enable Short Signals
|
|
|
|
//
|
|
// XCHMAMN ...
|
|
input group "XTEST XCHMAMN Signaller";
|
|
// input bool xTESTXCHMAMNEnableSignaller = true; // Enable Signaller
|
|
// input bool xTESTXCHMAMNAllowLongSignals = true; // Enable Long Signals
|
|
// input bool xTESTXCHMAMNAllowShortSignals = true; // Enable Short Signals
|
|
|
|
//
|
|
// Check in Test Mode or not ...
|
|
bool xTESTIsTestMode = false;
|
|
|
|
//
|
|
// Detect max Input Length of Indicators ...
|
|
int xTESTMaxLengthOfInputs = 0;
|
|
|
|
//
|
|
// Detect Calculated Bars ...
|
|
int xTESTCalculatedBars = 0;
|
|
|
|
//
|
|
// Check prevent Double Signalling on Same Candle ...
|
|
bool xTESTWaitUntilNextCandle = false;
|
|
|
|
//
|
|
// Signaller Variables ...
|
|
//
|
|
// XTD ...
|
|
bool xTESTMXTDEnableSignaller = xTESTXTDEnableSignaller;
|
|
bool xTESTMXTDAllowLongSignals = xTESTXTDAllowLongSignals;
|
|
bool xTESTMXTDAllowShortSignals = xTESTXTDAllowShortSignals;
|
|
|
|
//
|
|
// XTAM ...
|
|
bool xTESTMXTAMEnableSignaller = xTESTXTAMEnableSignaller;
|
|
bool xTESTMXTAMAllowLongSignals = xTESTXTAMAllowLongSignals;
|
|
bool xTESTMXTAMAllowShortSignals = xTESTXTAMAllowShortSignals;
|
|
|
|
//
|
|
// XSI ...
|
|
bool xTESTMXSIEnableSignaller = xTESTXSIEnableSignaller;
|
|
bool xTESTMXSIAllowLongSignals = xTESTXSIAllowLongSignals;
|
|
bool xTESTMXSIAllowShortSignals = xTESTXSIAllowShortSignals;
|
|
|
|
//
|
|
// XTSFI ...
|
|
bool xTESTMXTSFIEnableSignaller = xTESTXTSFIEnableSignaller;
|
|
bool xTESTMXTSFIAllowLongSignals = xTESTXTSFIAllowLongSignals;
|
|
bool xTESTMXTSFIAllowShortSignals = xTESTXTSFIAllowShortSignals;
|
|
|
|
//
|
|
// XOBDLH ...
|
|
bool xTESTMXOBDLHEnableSignaller = false; // xTESTXOBDLHEnableSignaller;
|
|
bool xTESTMXOBDLHAllowLongSignals = false; // xTESTXOBDLHAllowLongSignals;
|
|
bool xTESTMXOBDLHAllowShortSignals = false; // xTESTXOBDLHAllowShortSignals;
|
|
|
|
//
|
|
// XCHMACC ...
|
|
bool xTESTMXCHMACCEnableSignaller = xTESTXCHMACCEnableSignaller;
|
|
bool xTESTMXCHMACCAllowLongSignals = xTESTXCHMACCAllowLongSignals;
|
|
bool xTESTMXCHMACCAllowShortSignals = xTESTXCHMACCAllowShortSignals;
|
|
|
|
//
|
|
// XCHMAMX ...
|
|
bool xTESTMXCHMAMXEnableSignaller = false; // xTESTXCHMAMXEnableSignaller;
|
|
bool xTESTMXCHMAMXAllowLongSignals = false; // xTESTXCHMAMXAllowLongSignals;
|
|
bool xTESTMXCHMAMXAllowShortSignals = false; // xTESTXCHMAMXAllowShortSignals;
|
|
|
|
//
|
|
// XCHMAMN ...
|
|
bool xTESTMXCHMAMNEnableSignaller = false; // xTESTXCHMAMNEnableSignaller;
|
|
bool xTESTMXCHMAMNAllowLongSignals = false; // xTESTXCHMAMNAllowLongSignals;
|
|
bool xTESTMXCHMAMNAllowShortSignals = false; // xTESTXCHMAMNAllowShortSignals;
|
|
|
|
//
|
|
XCProvider *xTESTProvider;
|
|
|
|
//
|
|
// Validate Indicators Inputs ...
|
|
bool XTESTValidateIndicatorsInputs()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// XTM ...
|
|
result = XTMValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XAMA ...
|
|
result = XAMAValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XTD ...
|
|
result = XTDValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XFI ...
|
|
result = XFIValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XTS ...
|
|
result = XTSValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XOBD ...
|
|
result = XOBDValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XLH ...
|
|
result = XLHValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XRSI ...
|
|
result = XRSIValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHLH ...
|
|
result = XCHLHValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHMA ...
|
|
result = XCHMAValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Make an Instance Of XCProvider Class for Use ...
|
|
xTESTProvider = new XCProvider(
|
|
//
|
|
// Commons ...
|
|
_Symbol,
|
|
_Period,
|
|
//
|
|
// Signallers ...
|
|
//
|
|
// XTD ...
|
|
xTESTMXTDEnableSignaller,
|
|
xTESTMXTDAllowLongSignals,
|
|
xTESTMXTDAllowShortSignals,
|
|
//
|
|
// XTAM ...
|
|
xTESTMXTAMEnableSignaller,
|
|
xTESTMXTAMAllowLongSignals,
|
|
xTESTMXTAMAllowShortSignals,
|
|
//
|
|
// XSI ...
|
|
xTESTMXSIEnableSignaller,
|
|
xTESTMXSIAllowLongSignals,
|
|
xTESTMXSIAllowShortSignals,
|
|
//
|
|
// XTSFI ...
|
|
xTESTMXTSFIEnableSignaller,
|
|
xTESTMXTSFIAllowLongSignals,
|
|
xTESTMXTSFIAllowShortSignals,
|
|
//
|
|
// XOBDLH ...
|
|
xTESTMXOBDLHEnableSignaller,
|
|
xTESTMXOBDLHAllowLongSignals,
|
|
xTESTMXOBDLHAllowShortSignals,
|
|
//
|
|
// XCHMACC ...
|
|
xTESTMXCHMACCEnableSignaller,
|
|
xTESTMXCHMACCAllowLongSignals,
|
|
xTESTMXCHMACCAllowShortSignals,
|
|
//
|
|
// XCHMAMX ...
|
|
xTESTMXCHMAMXEnableSignaller,
|
|
xTESTMXCHMAMXAllowLongSignals,
|
|
xTESTMXCHMAMXAllowShortSignals,
|
|
//
|
|
// XCHMAMN ...
|
|
xTESTMXCHMAMNEnableSignaller,
|
|
xTESTMXCHMAMNAllowLongSignals,
|
|
xTESTMXCHMAMNAllowShortSignals
|
|
//
|
|
);
|
|
|
|
//
|
|
result = true;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Init Indicators ...
|
|
bool XTESTInitIndicators()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Make it Enable when we need to Log Market Conditions ...
|
|
xTESTIsTestMode = IsRunningOnTestMode();
|
|
|
|
//
|
|
// Check and Calculate Max Length in Inputs ...
|
|
//
|
|
|
|
//
|
|
// XTM ...
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xTMMaPeriod,
|
|
xTESTNumberOfItemsPerTick);
|
|
|
|
//
|
|
// XAMA ...
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xAMALength,
|
|
xTESTNumberOfItemsPerTick);
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xAMAFastEMA,
|
|
xTESTNumberOfItemsPerTick);
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xAMASlowEMA,
|
|
xTESTNumberOfItemsPerTick);
|
|
|
|
//
|
|
// XLH ...
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xLHLength,
|
|
xTESTNumberOfItemsPerTick);
|
|
|
|
//
|
|
// XTD ...
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xTDLength,
|
|
xTESTMaxLengthOfInputs);
|
|
|
|
//
|
|
// XFI ...
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xFILength,
|
|
xTESTMaxLengthOfInputs);
|
|
|
|
//
|
|
// XRSI ...
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xRSILength,
|
|
xTESTMaxLengthOfInputs);
|
|
|
|
//
|
|
// XOBD ...
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xOBDLength,
|
|
xTESTMaxLengthOfInputs);
|
|
|
|
//
|
|
// XCHLH ...
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xCHLHLcLength,
|
|
xTESTMaxLengthOfInputs);
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xCHLHMcLength,
|
|
xTESTMaxLengthOfInputs);
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xCHLHScLength,
|
|
xTESTMaxLengthOfInputs);
|
|
|
|
//
|
|
// XCHMA ...
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xCHMAScFastLength,
|
|
xTESTMaxLengthOfInputs);
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xCHMAScSlowLength,
|
|
xTESTMaxLengthOfInputs);
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xCHMAMcFastLength,
|
|
xTESTMaxLengthOfInputs);
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xCHMAMcSlowLength,
|
|
xTESTMaxLengthOfInputs);
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xCHMALcFastLength,
|
|
xTESTMaxLengthOfInputs);
|
|
xTESTMaxLengthOfInputs = MathMax(
|
|
xCHMALcSlowLength,
|
|
xTESTMaxLengthOfInputs);
|
|
|
|
//
|
|
// Validate Indicators Inputs before Initialization ...
|
|
result = XTESTValidateIndicatorsInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Validate Signallers ...
|
|
|
|
//
|
|
// XTD ...
|
|
bool isXTDEnable =
|
|
xTESTXTDEnableSignaller &&
|
|
(xTESTXTDAllowLongSignals ||
|
|
xTESTXTDAllowShortSignals);
|
|
|
|
//
|
|
// XTAM ...
|
|
bool isXTAMEnable =
|
|
xTESTXTAMEnableSignaller &&
|
|
(xTESTXTAMAllowLongSignals ||
|
|
xTESTXTAMAllowShortSignals);
|
|
|
|
//
|
|
// XSI ...
|
|
bool isXSIEnable =
|
|
xTESTXSIEnableSignaller &&
|
|
(xTESTXSIAllowLongSignals ||
|
|
xTESTXSIAllowShortSignals);
|
|
|
|
//
|
|
// XTSFI ...
|
|
bool isXTSFIEnable =
|
|
xTESTXTSFIEnableSignaller &&
|
|
(xTESTXTSFIAllowLongSignals ||
|
|
xTESTXTSFIAllowShortSignals);
|
|
|
|
//
|
|
// XOBDLH ...
|
|
bool isXOBDLHEnable = false;
|
|
// xTESTXOBDLHEnableSignaller &&
|
|
// (xTESTXOBDLHAllowLongSignals ||
|
|
// xTESTXOBDLHAllowShortSignals);
|
|
|
|
//
|
|
// XCHMACC ...
|
|
bool isXCHMACCEnable =
|
|
xTESTXCHMACCEnableSignaller &&
|
|
(xTESTXCHMACCAllowLongSignals ||
|
|
xTESTXCHMACCAllowShortSignals);
|
|
|
|
//
|
|
// XCHMAMX ...
|
|
bool isXCHMAMXEnable = false;
|
|
// xTESTXCHMAMXEnableSignaller &&
|
|
// (xTESTXCHMAMXAllowLongSignals ||
|
|
// xTESTXCHMAMXAllowShortSignals);
|
|
|
|
//
|
|
// XCHMAMN ...
|
|
bool isXCHMAMNEnable = false;
|
|
// xTESTXCHMAMNEnableSignaller &&
|
|
// (xTESTXCHMAMNAllowLongSignals ||
|
|
// xTESTXCHMAMNAllowShortSignals);
|
|
|
|
//
|
|
bool hasSignaller =
|
|
//
|
|
isXTDEnable ||
|
|
isXTAMEnable ||
|
|
isXSIEnable ||
|
|
isXTSFIEnable ||
|
|
isXOBDLHEnable ||
|
|
isXCHMACCEnable ||
|
|
isXCHMAMXEnable ||
|
|
isXCHMAMNEnable
|
|
//
|
|
;
|
|
result = hasSignaller;
|
|
if (!result)
|
|
{
|
|
//
|
|
LogMessage("XTEST doesn't enable any Signaller ...");
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Initialize Indicator/Oscillator Handlers ...
|
|
ResetLastError();
|
|
|
|
//
|
|
// XTM Init ...
|
|
result = XTMInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XAMA Init ...
|
|
result = XAMAInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XLH Init ...
|
|
result = XLHInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XTD Init ...
|
|
result = XTDInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XFI Init ...
|
|
result = XFIInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XTS Init ...
|
|
result = XTSInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XRSI Init ...
|
|
result = XRSIInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XOBD Init ...
|
|
result = XOBDInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCLH Init ...
|
|
result = XCHLHInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHMA Init ...
|
|
result = XCHMAInitHandlers();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = true;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Release Indicators ...
|
|
void XTESTReleaseIndicators()
|
|
{
|
|
//
|
|
// Release Handlers ...
|
|
XTMReleaseHandlers();
|
|
XAMAReleaseHandlers();
|
|
XLHReleaseHandlers();
|
|
XTDReleaseHandlers();
|
|
XFIReleaseHandlers();
|
|
XTSReleaseHandlers();
|
|
XRSIReleaseHandlers();
|
|
XOBDReleaseHandlers();
|
|
XCHMAReleaseHandlers();
|
|
XCHLHReleaseHandlers();
|
|
}
|
|
|
|
//
|
|
// Handle Reading Buffers ...
|
|
void XTESTHandleReadingBuffers()
|
|
{
|
|
//
|
|
// Reading Calculated Bars for a Simple Handler ...
|
|
xTESTCalculatedBars = BarsCalculated(xTMHandler);
|
|
|
|
//
|
|
// Read Indicators Buffers ...
|
|
XTMReadBuffers(xTESTNumberOfItemsPerTick);
|
|
XAMAReadBuffers(xTESTNumberOfItemsPerTick);
|
|
XLHReadBuffers(xTESTNumberOfItemsPerTick);
|
|
XTDReadBuffers(xTESTNumberOfItemsPerTick);
|
|
XFIReadBuffers(xTESTNumberOfItemsPerTick);
|
|
XTSReadBuffers(xTESTNumberOfItemsPerTick);
|
|
XRSIReadBuffers(xTESTNumberOfItemsPerTick);
|
|
XOBDReadBuffers(xTESTNumberOfItemsPerTick);
|
|
XCHMAReadBuffers(xTESTNumberOfItemsPerTick);
|
|
XCHLHReadBuffers(xTESTNumberOfItemsPerTick);
|
|
|
|
//
|
|
xTESTProvider.ReadConditions();
|
|
}
|
|
|
|
//
|
|
//
|
|
// START Combination Functions ...
|
|
//
|
|
//
|
|
|
|
//
|
|
// Can Open Long Trade ...
|
|
// this is a Function will Check all market Conditions and get all
|
|
// Strategy requirement Verifications for Long Signals ...
|
|
bool XTESTCanOpenLongTrade(
|
|
XProvidedSignal &info // Retrieve Signal Additional Info on this Object
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
info.tp = 0;
|
|
info.sl = 0;
|
|
ArrayResize(
|
|
info.signallers,
|
|
0);
|
|
|
|
//
|
|
bool hasSignal = XTESTHasLongSignal(info);
|
|
|
|
//
|
|
result =
|
|
//
|
|
hasSignal
|
|
//
|
|
;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
xTESTProvider.ClearConditions();
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Can Close Long Trade ...
|
|
// this is a Function will Check all market Conditions and get all
|
|
// Strategy requirement Verifications for Long Signals ...
|
|
bool XTESTCanCloseLongTrade()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Can Open Short Trade ...
|
|
// this is a Function will Check all market Conditions and get all
|
|
// Strategy requirement Verifications for Short Signals ...
|
|
bool XTESTCanOpenShortTrade(
|
|
XProvidedSignal &info // Retrieve Signal Additional Info on this Object
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
info.tp = 0;
|
|
info.sl = 0;
|
|
ArrayResize(
|
|
info.signallers,
|
|
0);
|
|
|
|
//
|
|
bool hasSignal = XTESTHasShortSignal(info);
|
|
|
|
//
|
|
result =
|
|
//
|
|
hasSignal
|
|
//
|
|
;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
xTESTProvider.ClearConditions();
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Can Close Short Trade ...
|
|
// this is a Function will Check all market Conditions and get all
|
|
// Strategy requirement Verifications for Short Signals ...
|
|
bool XTESTCanCloseShortTrade()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
//
|
|
// END Combination Functions ...
|
|
//
|
|
//
|
|
|
|
//
|
|
//
|
|
// START Combination Signaling ...
|
|
//
|
|
//
|
|
|
|
//
|
|
// Check Market Conditions by Combination of Power of All tools for LONGs ...
|
|
bool XTESTHasLongSignal(
|
|
XProvidedSignal &info // Retrieve Signal Additional Info on this Object
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// XTD ...
|
|
bool isXTDHasSignal = XTESTXTDHasLongSignal();
|
|
if (isXTDHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XTD),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XTAM ...
|
|
bool isXTAMHasSignal = XTESTXTAMHasLongSignal();
|
|
if (isXTAMHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XTAM),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XSI ...
|
|
bool isXSIHasSignal = XTESTXSIHasLongSignal();
|
|
if (isXSIHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XSI),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XTSFI ...
|
|
bool isXTSFIHasSignal = XTESTXTSFIHasLongSignal();
|
|
if (isXTSFIHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XTSFI),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XOBD XLH ...
|
|
bool isXOBDLHHasSignal = XTESTXOBDLHHasLongSignal();
|
|
if (isXOBDLHHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XOBDLH),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XCHMA Cycles Cross ...
|
|
bool isXCHMACCHasSignal = XTESTXCHMACCHasLongSignal();
|
|
if (isXCHMACCHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XCHMACC),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XCHMA Cycles Min ...
|
|
bool isXCHMAMNHasSignal = XTESTXCHMAMNHasLongSignal();
|
|
if (isXCHMAMNHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XCHMAMN),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XCHMA Cycles Max
|
|
bool isXCHMAMXHasSignal = XTESTXCHMAMXHasLongSignal();
|
|
if (isXCHMAMXHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XCHMAMX),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
result =
|
|
//
|
|
isXTDHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXTAMHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXSIHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXTSFIHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXOBDLHHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXCHMACCHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXCHMAMNHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXCHMAMXHasSignal
|
|
//
|
|
;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
// Only Log Signals Time Market Conditions if is in Testing Mode ...
|
|
if (xTESTIsTestMode || xTESTEnableSignalAlerts)
|
|
{
|
|
//
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
string message = xTESTProvider.GenerateConditionsString(mConditions);
|
|
|
|
//
|
|
LogMessage(
|
|
"Long Signal Provided by: \n" +
|
|
info.signallers[ArraySize(info.signallers) - 1] + "\n" +
|
|
"Pusher: " + (string)ArraySize(info.signallers) + "\n" +
|
|
"Market Conditions: " + message);
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Market Conditions by Combination of Power of All tools for SHORTs ...
|
|
bool XTESTHasShortSignal(
|
|
XProvidedSignal &info // Retrieve Signal Additional Info on this Object
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// XTD ...
|
|
bool isXTDHasSignal = XTESTXTDHasShortSignal();
|
|
if (isXTDHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XTD),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XTAM ...
|
|
bool isXTAMHasSignal = XTESTXTAMHasShortSignal();
|
|
if (isXTAMHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XTAM),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XSI ...
|
|
bool isXSIHasSignal = XTESTXSIHasShortSignal();
|
|
if (isXSIHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XSI),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XTSFI ...
|
|
bool isXTSFIHasSignal = XTESTXTSFIHasShortSignal();
|
|
if (isXTSFIHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XTSFI),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XOBD XLH ...
|
|
bool isXOBDLHHasSignal = XTESTXOBDLHHasShortSignal();
|
|
if (isXOBDLHHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XOBDLH),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XCHMA Cycles Cross ...
|
|
bool isXCHMACCHasSignal = XTESTXCHMACCHasShortSignal();
|
|
if (isXCHMACCHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XCHMACC),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XCHMA Cycles Min ...
|
|
bool isXCHMAMNHasSignal = XTESTXCHMAMNHasShortSignal();
|
|
if (isXCHMAMNHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XCHMAMN),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
// XCHMA Cycles Max
|
|
bool isXCHMAMXHasSignal = XTESTXCHMAMXHasShortSignal();
|
|
if (isXCHMAMXHasSignal)
|
|
{
|
|
//
|
|
Add(
|
|
EnumToString(XCHMAMX),
|
|
info.signallers);
|
|
}
|
|
|
|
//
|
|
result =
|
|
//
|
|
isXTDHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXTAMHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXSIHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXTSFIHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXOBDLHHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXCHMACCHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXCHMAMNHasSignal
|
|
//
|
|
||
|
|
//
|
|
isXCHMAMXHasSignal
|
|
//
|
|
;
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
// Only Log Signals Time Market Conditions if is in Testing Mode ...
|
|
if (xTESTIsTestMode || xTESTEnableSignalAlerts)
|
|
{
|
|
//
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
string message = xTESTProvider.GenerateConditionsString(mConditions);
|
|
|
|
//
|
|
LogMessage(
|
|
"Short Signal Provided by: \n" +
|
|
info.signallers[ArraySize(info.signallers) - 1] + "\n" +
|
|
"Pusher: " + (string)ArraySize(info.signallers) + "\n" +
|
|
"Market Conditions: " + message);
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
//
|
|
// END Combination Signaling ...
|
|
//
|
|
//
|
|
|
|
//
|
|
// START Signal Providers ...
|
|
//
|
|
|
|
//
|
|
// Disbale All Signallers Longs ...
|
|
void XTESTDisableLongSignallers()
|
|
{
|
|
//
|
|
// XTD ...
|
|
if (xTESTMXTDEnableSignaller)
|
|
{
|
|
//
|
|
xTESTProvider.DisbaleXTDLongs();
|
|
xTESTMXTDAllowLongSignals = false;
|
|
}
|
|
|
|
//
|
|
// XTAM ...
|
|
if (xTESTMXTAMEnableSignaller)
|
|
{
|
|
//
|
|
xTESTProvider.DisbaleXTAMLongs();
|
|
xTESTMXTAMAllowLongSignals = false;
|
|
}
|
|
|
|
//
|
|
// XSI ...
|
|
if (xTESTMXSIEnableSignaller)
|
|
{
|
|
//
|
|
xTESTProvider.DisbaleXSILongs();
|
|
xTESTMXSIAllowLongSignals = false;
|
|
}
|
|
|
|
//
|
|
// XTSFI ...
|
|
if (xTESTMXTSFIEnableSignaller)
|
|
{
|
|
//
|
|
xTESTProvider.DisbaleXTSFILongs();
|
|
xTESTMXTSFIAllowLongSignals = false;
|
|
}
|
|
|
|
//
|
|
// XOBDLH ...
|
|
// if (xTESTMXOBDLHEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTProvider.DisbaleXOBDLHLongs();
|
|
// xTESTMXOBDLHAllowLongSignals = false;
|
|
// }
|
|
|
|
//
|
|
// XCHMACC ...
|
|
if (xTESTMXCHMACCEnableSignaller)
|
|
{
|
|
//
|
|
xTESTProvider.DisbaleXCHMACCLongs();
|
|
xTESTMXCHMACCAllowLongSignals = false;
|
|
}
|
|
|
|
//
|
|
// XCHMAMX ...
|
|
// if (xTESTMXCHMAMXEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTProvider.DisbaleXCHMAMXLongs();
|
|
// xTESTMXCHMAMXAllowLongSignals = false;
|
|
// }
|
|
|
|
//
|
|
// XCHMAMN ...
|
|
// if (xTESTMXCHMAMNEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTProvider.DisbaleXCHMAMNLongs();
|
|
// xTESTMXCHMAMNAllowLongSignals = false;
|
|
// }
|
|
}
|
|
|
|
//
|
|
// Enable All Signallers Longs ...
|
|
// Only if they are Configured as Enable at Settings ...
|
|
void XTESTEnableLongSignallers()
|
|
{
|
|
//
|
|
// XTD ...
|
|
if (xTESTMXTDEnableSignaller)
|
|
{
|
|
//
|
|
xTESTMXTDAllowLongSignals =
|
|
xTESTXTDAllowLongSignals
|
|
? true
|
|
: xTESTMXTDAllowLongSignals;
|
|
|
|
//
|
|
if (xTESTMXTDAllowLongSignals)
|
|
{
|
|
xTESTProvider.EnableXTDLongs();
|
|
}
|
|
}
|
|
|
|
//
|
|
// XTAM ...
|
|
if (xTESTMXTAMEnableSignaller)
|
|
{
|
|
//
|
|
xTESTMXTAMAllowLongSignals =
|
|
xTESTXTAMAllowLongSignals
|
|
? true
|
|
: xTESTMXTAMAllowLongSignals;
|
|
|
|
//
|
|
if (xTESTMXTAMAllowLongSignals)
|
|
{
|
|
xTESTProvider.EnableXTAMLongs();
|
|
}
|
|
}
|
|
|
|
//
|
|
// XSI ...
|
|
if (xTESTMXSIEnableSignaller)
|
|
{
|
|
//
|
|
xTESTMXSIAllowLongSignals =
|
|
xTESTXSIAllowLongSignals
|
|
? true
|
|
: xTESTMXSIAllowLongSignals;
|
|
|
|
//
|
|
if (xTESTMXSIAllowLongSignals)
|
|
{
|
|
xTESTProvider.EnableXSILongs();
|
|
}
|
|
}
|
|
|
|
//
|
|
// XTSFI ...
|
|
if (xTESTMXTSFIEnableSignaller)
|
|
{
|
|
//
|
|
xTESTMXTSFIAllowLongSignals =
|
|
xTESTXTSFIAllowLongSignals
|
|
? true
|
|
: xTESTMXTSFIAllowLongSignals;
|
|
|
|
//
|
|
if (xTESTMXTSFIAllowLongSignals)
|
|
{
|
|
xTESTProvider.EnableXTSFILongs();
|
|
}
|
|
}
|
|
|
|
//
|
|
// XOBDLH ...
|
|
// if (xTESTMXOBDLHEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTMXOBDLHAllowLongSignals =
|
|
// xTESTXOBDLHAllowLongSignals
|
|
// ? true
|
|
// : xTESTMXOBDLHAllowLongSignals;
|
|
|
|
// //
|
|
// if (xTESTMXOBDLHAllowLongSignals)
|
|
// {
|
|
// xTESTProvider.EnableXOBDLHLongs();
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// XCHMACC ...
|
|
if (xTESTMXCHMACCEnableSignaller)
|
|
{
|
|
//
|
|
xTESTMXCHMACCAllowLongSignals =
|
|
xTESTXCHMACCAllowLongSignals
|
|
? true
|
|
: xTESTMXCHMACCAllowLongSignals;
|
|
|
|
//
|
|
if (xTESTMXCHMACCAllowLongSignals)
|
|
{
|
|
xTESTProvider.EnableXCHMACCLongs();
|
|
}
|
|
}
|
|
|
|
//
|
|
// XCHMAMX ...
|
|
// if (xTESTMXCHMAMXEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTMXCHMAMXAllowLongSignals =
|
|
// xTESTXCHMAMXAllowLongSignals
|
|
// ? true
|
|
// : xTESTMXCHMAMXAllowLongSignals;
|
|
|
|
// //
|
|
// if (xTESTMXCHMAMXAllowLongSignals)
|
|
// {
|
|
// xTESTProvider.EnableXCHMAMXLongs();
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// XCHMAMN ...
|
|
// if (xTESTMXCHMAMNEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTMXCHMAMNAllowLongSignals =
|
|
// xTESTXCHMAMNAllowLongSignals
|
|
// ? true
|
|
// : xTESTMXCHMAMNAllowLongSignals;
|
|
|
|
// //
|
|
// if (xTESTMXCHMAMNAllowLongSignals)
|
|
// {
|
|
// xTESTProvider.EnableXCHMAMNLongs();
|
|
// }
|
|
// }
|
|
}
|
|
|
|
//
|
|
// Disable All Signallers Shorts ...
|
|
void XTESTDisableShortSignallers()
|
|
{
|
|
//
|
|
// XTD ...
|
|
if (xTESTMXTDEnableSignaller)
|
|
{
|
|
//
|
|
xTESTProvider.DisableXTDShorts();
|
|
xTESTMXTDAllowShortSignals = false;
|
|
}
|
|
|
|
//
|
|
// XTAM ...
|
|
if (xTESTMXTAMEnableSignaller)
|
|
{
|
|
//
|
|
xTESTProvider.DisableXTAMShorts();
|
|
xTESTMXTAMAllowShortSignals = false;
|
|
}
|
|
|
|
//
|
|
// XSI ...
|
|
if (xTESTMXSIEnableSignaller)
|
|
{
|
|
//
|
|
xTESTProvider.DisableXSIShorts();
|
|
xTESTMXSIAllowShortSignals = false;
|
|
}
|
|
|
|
//
|
|
// XTSFI ...
|
|
if (xTESTMXTSFIEnableSignaller)
|
|
{
|
|
//
|
|
xTESTProvider.DisableXTSFIShorts();
|
|
xTESTMXTSFIAllowShortSignals = false;
|
|
}
|
|
|
|
//
|
|
// XOBDLH ...
|
|
// if (xTESTMXOBDLHEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTProvider.DisableXOBDLHShorts();
|
|
// xTESTMXOBDLHAllowShortSignals = false;
|
|
// }
|
|
|
|
//
|
|
// XCHMACC ...
|
|
if (xTESTMXCHMACCEnableSignaller)
|
|
{
|
|
//
|
|
xTESTProvider.DisableXCHMACCShorts();
|
|
xTESTMXCHMACCAllowShortSignals = false;
|
|
}
|
|
|
|
//
|
|
// XCHMAMX ...
|
|
// if (xTESTMXCHMAMXEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTProvider.DisableXCHMAMXShorts();
|
|
// xTESTMXCHMAMXAllowShortSignals = false;
|
|
// }
|
|
|
|
//
|
|
// XCHMAMN ...
|
|
// if (xTESTMXCHMAMNEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTProvider.DisableXCHMAMNShorts();
|
|
// xTESTMXCHMAMNAllowShortSignals = false;
|
|
// }
|
|
}
|
|
|
|
//
|
|
// Enable All Signallers Shorts ...
|
|
// Only if they are Configured as Enable at Settings ...
|
|
void XTESTEnableShortSignallers()
|
|
{
|
|
//
|
|
// XTD ...
|
|
if (xTESTMXTDEnableSignaller)
|
|
{
|
|
//
|
|
xTESTMXTDAllowShortSignals =
|
|
xTESTXTDAllowShortSignals
|
|
? true
|
|
: xTESTMXTDAllowShortSignals;
|
|
|
|
//
|
|
if (xTESTMXTDAllowShortSignals)
|
|
{
|
|
xTESTProvider.EnableXTDShorts();
|
|
}
|
|
}
|
|
|
|
//
|
|
// XTAM ...
|
|
if (xTESTMXTAMEnableSignaller)
|
|
{
|
|
//
|
|
xTESTMXTAMAllowShortSignals =
|
|
xTESTXTAMAllowShortSignals
|
|
? true
|
|
: xTESTMXTAMAllowShortSignals;
|
|
|
|
//
|
|
if (xTESTMXTAMAllowShortSignals)
|
|
{
|
|
xTESTProvider.EnableXTAMShorts();
|
|
}
|
|
}
|
|
|
|
//
|
|
// XSI ...
|
|
if (xTESTMXSIEnableSignaller)
|
|
{
|
|
//
|
|
xTESTMXSIAllowShortSignals =
|
|
xTESTXSIAllowShortSignals
|
|
? true
|
|
: xTESTMXSIAllowShortSignals;
|
|
|
|
//
|
|
if (xTESTMXSIAllowShortSignals)
|
|
{
|
|
xTESTProvider.EnableXSIShorts();
|
|
}
|
|
}
|
|
|
|
//
|
|
// XTSFI ...
|
|
if (xTESTMXTSFIEnableSignaller)
|
|
{
|
|
//
|
|
xTESTMXTSFIAllowShortSignals =
|
|
xTESTXTSFIAllowShortSignals
|
|
? true
|
|
: xTESTMXTSFIAllowShortSignals;
|
|
|
|
//
|
|
if (xTESTMXTSFIAllowShortSignals)
|
|
{
|
|
xTESTProvider.EnableXTSFIShorts();
|
|
}
|
|
}
|
|
|
|
//
|
|
// XOBDLH ...
|
|
// if (xTESTMXOBDLHEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTMXOBDLHAllowShortSignals =
|
|
// xTESTXOBDLHAllowShortSignals
|
|
// ? true
|
|
// : xTESTMXOBDLHAllowShortSignals;
|
|
|
|
// //
|
|
// if (xTESTMXOBDLHAllowShortSignals)
|
|
// {
|
|
// xTESTProvider.EnableXOBDLHShorts();
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// XCHMACC ...
|
|
if (xTESTMXCHMACCEnableSignaller)
|
|
{
|
|
//
|
|
xTESTMXCHMACCAllowShortSignals =
|
|
xTESTXCHMACCAllowShortSignals
|
|
? true
|
|
: xTESTMXCHMACCAllowShortSignals;
|
|
|
|
//
|
|
if (xTESTMXCHMACCAllowShortSignals)
|
|
{
|
|
xTESTProvider.EnableXCHMACCShorts();
|
|
}
|
|
}
|
|
|
|
//
|
|
// XCHMAMX ...
|
|
// if (xTESTMXCHMAMXEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTMXCHMAMXAllowShortSignals =
|
|
// xTESTXCHMAMXAllowShortSignals
|
|
// ? true
|
|
// : xTESTMXCHMAMXAllowShortSignals;
|
|
|
|
// //
|
|
// if (xTESTMXCHMAMXAllowShortSignals)
|
|
// {
|
|
// xTESTProvider.EnableXCHMAMXShorts();
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// XCHMAMN ...
|
|
// if (xTESTMXCHMAMNEnableSignaller)
|
|
// {
|
|
// //
|
|
// xTESTMXCHMAMNAllowShortSignals =
|
|
// xTESTXCHMAMNAllowShortSignals
|
|
// ? true
|
|
// : xTESTMXCHMAMNAllowShortSignals;
|
|
|
|
// //
|
|
// if (xTESTMXCHMAMNAllowShortSignals)
|
|
// {
|
|
// xTESTProvider.EnableXCHMAMNShorts();
|
|
// }
|
|
// }
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// XTD Long Signal Checking ...
|
|
bool XTESTXTDHasLongSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXTDEnableSignaller ||
|
|
!xTESTMXTDAllowLongSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XTDHasLongConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XTD Short Signal Checking ...
|
|
bool XTESTXTDHasShortSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXTDEnableSignaller ||
|
|
!xTESTMXTDAllowShortSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XTDHasShortConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XTAM Long Signal Checking ...
|
|
bool XTESTXTAMHasLongSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXTAMEnableSignaller ||
|
|
!xTESTMXTAMAllowLongSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XTAMHasLongConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XTAM Short Signal Checking ...
|
|
bool XTESTXTAMHasShortSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXTAMEnableSignaller ||
|
|
!xTESTMXTAMAllowShortSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XTAMHasShortConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XSI Long Signal Checking ...
|
|
bool XTESTXSIHasLongSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXSIEnableSignaller ||
|
|
!xTESTMXSIAllowLongSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XSIHasLongConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XSI Short Signal Checking ...
|
|
bool XTESTXSIHasShortSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXSIEnableSignaller ||
|
|
!xTESTMXSIAllowShortSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XSIHasShortConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XTSFI Long Signal Checking ...
|
|
bool XTESTXTSFIHasLongSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXTSFIEnableSignaller ||
|
|
!xTESTMXTSFIAllowLongSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XTSFIHasLongConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XTSFI Short Signal Checking ...
|
|
bool XTESTXTSFIHasShortSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXTSFIEnableSignaller ||
|
|
!xTESTMXTSFIAllowShortSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XTSFIHasShortConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XOBDLH Long Signal Checking ...
|
|
bool XTESTXOBDLHHasLongSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXOBDLHEnableSignaller ||
|
|
!xTESTMXOBDLHAllowLongSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XOBDLHHasLongConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XOBDLH Short Signal Checking ...
|
|
bool XTESTXOBDLHHasShortSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXOBDLHEnableSignaller ||
|
|
!xTESTMXOBDLHAllowShortSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XOBDLHHasShortConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHMACC Long Signal Checking ...
|
|
bool XTESTXCHMACCHasLongSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXCHMACCEnableSignaller ||
|
|
!xTESTMXCHMACCAllowLongSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XCHMACCHasLongConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHMACC Short Signal Checking ...
|
|
bool XTESTXCHMACCHasShortSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXCHMACCEnableSignaller ||
|
|
!xTESTMXCHMACCAllowShortSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XCHMACCHasShortConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHMAMN Long Signal Checking ...
|
|
bool XTESTXCHMAMNHasLongSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXCHMAMNEnableSignaller ||
|
|
!xTESTMXCHMAMNAllowLongSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XCHMAMNHasLongConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHMAMN Short Signal Checking ...
|
|
bool XTESTXCHMAMNHasShortSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXCHMAMNEnableSignaller ||
|
|
!xTESTMXCHMAMNAllowShortSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XCHMAMNHasShortConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHMAMX Long Signal Checking ...
|
|
bool XTESTXCHMAMXHasLongSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXCHMAMXEnableSignaller ||
|
|
!xTESTMXCHMAMXAllowLongSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XCHMAMXHasLongConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XCHMAMX Short Signal Checking ...
|
|
bool XTESTXCHMAMXHasShortSignal()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!xTESTMXCHMAMXEnableSignaller ||
|
|
!xTESTMXCHMAMXAllowShortSignals)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve Market Condition ...
|
|
XMarketConditions mConditions = xTESTProvider.GetLastMarketCondition();
|
|
|
|
//
|
|
// Start Analysing Market based On Conditions ...
|
|
result =
|
|
//
|
|
// Base Condition:
|
|
xTESTProvider.XCHMAMXHasShortConditions()
|
|
//
|
|
&&
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// END Signal Providers ...
|
|
//
|