1385 lines
31 KiB
Plaintext
1385 lines
31 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Library
|
|
// ---------------------------------------
|
|
// Name: XCATBLib
|
|
// Description: required Parsers for XCATB ...
|
|
//
|
|
//
|
|
// Maintainer:
|
|
// ------------
|
|
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
|
|
//
|
|
//////////////////////////////////////////////////////
|
|
//
|
|
// Global Properties ...
|
|
#property library
|
|
#property copyright "Copyright `023, SaherElm IT Center"
|
|
#property link "https://www.saherelm.ir"
|
|
#property version "1.00"
|
|
#property strict
|
|
|
|
//
|
|
// Imports ...
|
|
#include "../Classes/x-saherelm.x-bar.analyser.class.mq5"
|
|
#include "../Classes/x-saherelm.x-poi.drawer.class.mq5"
|
|
#include "../Libraries/x-saherelm.common.lib.mq5";
|
|
#include "../Libraries/x-saherelm.x-poi.lib.mq5"
|
|
|
|
//
|
|
// Definiions ...
|
|
|
|
//
|
|
enum ENUM_XCAEA_TIGGER_TYPE
|
|
{
|
|
XCA_TRIGGER_NONE, // None
|
|
XCA_TRIGGER_BULL, // TriggerBull
|
|
XCA_TRIGGER_BEAR, // TriggerBear
|
|
};
|
|
|
|
//
|
|
bool IsValid(ENUM_XCAEA_TIGGER_TYPE value)
|
|
{
|
|
return value != XCA_TRIGGER_NONE;
|
|
}
|
|
|
|
//
|
|
string ToString(ENUM_XCAEA_TIGGER_TYPE value)
|
|
{
|
|
return EnumToString(value);
|
|
}
|
|
|
|
//
|
|
ENUM_XCAEA_TIGGER_TYPE GetType(string type)
|
|
{
|
|
//
|
|
ENUM_XCAEA_TIGGER_TYPE result = XCA_TRIGGER_NONE;
|
|
|
|
//
|
|
bool isTriggerBull = type == ToString(XCA_TRIGGER_BULL);
|
|
bool isTriggerBear = type == ToString(XCA_TRIGGER_BEAR);
|
|
|
|
//
|
|
if (isTriggerBull)
|
|
{
|
|
result = XCA_TRIGGER_BULL;
|
|
}
|
|
else if (isTriggerBear)
|
|
{
|
|
result = XCA_TRIGGER_BEAR;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
ENUM_X_DIRECTION GetDirection(ENUM_XCAEA_TIGGER_TYPE value)
|
|
{
|
|
return value == XCA_TRIGGER_BULL
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
}
|
|
|
|
//
|
|
struct XTriggerBlock
|
|
{
|
|
//
|
|
// Props ...
|
|
XBoxZone ob; // Order Block
|
|
XBoxZone fvg; // Fair Value Gap
|
|
XOHCL swingBar; // Swing of Trigger
|
|
XBoxZone trigger; // Trigger Block
|
|
XBoxZone rLiquidity; // Reversal Liquidity
|
|
XBoxZone fLiquidity; // Following Liquidity
|
|
|
|
//
|
|
XSignal signal; // Pepared Signal
|
|
|
|
//
|
|
// Constructor ...
|
|
XTriggerBlock()
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
//
|
|
// Cleanup ...
|
|
void Clean()
|
|
{
|
|
//
|
|
ob.Clean();
|
|
fvg.Clean();
|
|
signal.Clean();
|
|
trigger.Clean();
|
|
swingBar.Clean();
|
|
rLiquidity.Clean();
|
|
fLiquidity.Clean();
|
|
|
|
//
|
|
ZeroMemory(this);
|
|
}
|
|
|
|
//
|
|
// Validate ...
|
|
bool IsValid()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = ob.IsValid() &&
|
|
fvg.IsValid() &&
|
|
trigger.IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool IsBullish()
|
|
{
|
|
return IsValid() &&
|
|
ob.IsBullish();
|
|
}
|
|
|
|
//
|
|
bool IsBearish()
|
|
{
|
|
return IsValid() &&
|
|
ob.IsBearish();
|
|
}
|
|
|
|
//
|
|
int ToIndex()
|
|
{
|
|
return trigger.ToIndex();
|
|
}
|
|
|
|
//
|
|
int FromIndex()
|
|
{
|
|
return trigger.FromIndex();
|
|
}
|
|
|
|
//
|
|
ENUM_X_DIRECTION GetDirection()
|
|
{
|
|
//
|
|
ENUM_X_DIRECTION result = X_DIRECTION_NONE;
|
|
|
|
//
|
|
if (IsValid())
|
|
{
|
|
result = ob.dir;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Extensions ...
|
|
|
|
bool DetectTriggerBlock(
|
|
//
|
|
string symbol,
|
|
ENUM_TIMEFRAMES period,
|
|
//
|
|
XTriggerBlock &tb,
|
|
//
|
|
XCBarAnalyser *barAnalyser,
|
|
//
|
|
// Required Buffers ...
|
|
const double &_atrBuffer[],
|
|
const double &_rsiBuffer[],
|
|
const double &_adxBuffer[],
|
|
const double &_adxpBuffer[],
|
|
const double &_adxnBuffer[],
|
|
const double &_peakBuffer[],
|
|
const double &_valeBuffer[],
|
|
const double &_deltaBuffer[],
|
|
const double &_sarBuffer[],
|
|
const double &_sarStateBuffer[],
|
|
const double &_trendBuffer[],
|
|
const double &_trendStateBuffer[],
|
|
const double &_atrUpperBuffer[],
|
|
const double &_atrLowerBuffer[],
|
|
const double &_sBarOpenSBuffer[],
|
|
const double &_sBarCloseBuffer[],
|
|
const double &_hkSBarOpenBuffer[],
|
|
const double &_hkSBarCloseBuffer[],
|
|
const double &_peakGoldenBuffer[],
|
|
const double &_valeGoldenBuffer[],
|
|
const double &_deltaSignalBuffer[],
|
|
const double &_bullishVolumeSignalBuffer[],
|
|
const double &_bearishVolumeSignalBuffer[],
|
|
//
|
|
int barIndex,
|
|
//
|
|
int _r2r,
|
|
double _slAtrMultiplier,
|
|
//
|
|
// Configs ...
|
|
double _rsiOBLevel,
|
|
double _rsiOSLevel,
|
|
double _adxThreshold,
|
|
//
|
|
// Validators ...
|
|
//
|
|
bool _forceObBarType = false,
|
|
bool _forceFVGBarType = false,
|
|
bool _forceHasSwing = false,
|
|
bool _forceHasFLiquidity = false,
|
|
bool _forceHasRLiquidity = false,
|
|
bool _validateGapSequence = false,
|
|
bool _validateBlockEdgeBreakout = false,
|
|
//
|
|
// Filters ...
|
|
bool _filterBasedOnPV = false,
|
|
bool _filterBasedOnSar = false,
|
|
bool _filterBasedOnRSI = false,
|
|
bool _filterBasedOnADX = false,
|
|
bool _filterBasedOnATR = false,
|
|
bool _filterBasedOnTrend = false,
|
|
bool _filterBasedOnDelta = false,
|
|
bool _filterBasedOnVolume = false,
|
|
bool _filterBasedOnSignalBar = false,
|
|
bool _filterBasedOnHKSignalBar = false //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Custom Configs ...
|
|
|
|
//
|
|
// Validators ...
|
|
_forceHasSwing = true;
|
|
_forceObBarType = true;
|
|
_forceFVGBarType = true;
|
|
_validateGapSequence = true;
|
|
|
|
//
|
|
_forceHasFLiquidity = false;
|
|
_forceHasRLiquidity = false;
|
|
_validateBlockEdgeBreakout = false;
|
|
|
|
//
|
|
// Filters ...
|
|
_filterBasedOnPV = true;
|
|
_filterBasedOnATR = true;
|
|
_filterBasedOnDelta = true;
|
|
_filterBasedOnVolume = true;
|
|
|
|
//
|
|
_filterBasedOnSar = false;
|
|
_filterBasedOnRSI = false;
|
|
_filterBasedOnADX = false;
|
|
_filterBasedOnTrend = false;
|
|
_filterBasedOnSignalBar = false;
|
|
_filterBasedOnHKSignalBar = false;
|
|
|
|
//
|
|
tb.Clean();
|
|
|
|
//
|
|
result = barAnalyser != NULL;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int zIDX = 0;
|
|
bool has = false;
|
|
bool isDone = false;
|
|
ENUM_X_DIRECTION iDir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
// Retrieve Required Bars ...
|
|
|
|
//
|
|
XOHCL iBar;
|
|
XOHCL zBar; // Current Start Checking Bar (Usually Used for Triggering) ...
|
|
has = zBar.Init(
|
|
symbol,
|
|
period,
|
|
barIndex //
|
|
);
|
|
|
|
//
|
|
// Detect Based Order Block ...
|
|
has =
|
|
has &&
|
|
barAnalyser.IsOB(
|
|
zBar,
|
|
tb.ob,
|
|
_forceFVGBarType, // Force FVG Bar Type ...
|
|
_forceObBarType // Force Block Two Bar Checking ...
|
|
);
|
|
|
|
//
|
|
// Detect Based Fair Value Gap ...
|
|
has =
|
|
has &&
|
|
barAnalyser.IsFVG(
|
|
zBar,
|
|
tb.fvg,
|
|
_forceFVGBarType // Force FVG Bar Type ...
|
|
);
|
|
|
|
//
|
|
// Clone Trigger Block ...
|
|
if (has)
|
|
{
|
|
tb.trigger = tb.ob;
|
|
}
|
|
|
|
//
|
|
bool isBullish =
|
|
has &&
|
|
tb.IsBullish();
|
|
|
|
//
|
|
bool isBearish =
|
|
has &&
|
|
tb.IsBearish();
|
|
|
|
//
|
|
int toIDX = tb.ToIndex();
|
|
int fromIDX = tb.FromIndex();
|
|
|
|
//
|
|
// Verifications and Filters ...
|
|
|
|
//
|
|
int loopback = 144;
|
|
|
|
//
|
|
// Forces ...
|
|
|
|
//
|
|
// Force Has Proper Swing ...
|
|
if (has &&
|
|
_forceHasSwing)
|
|
{
|
|
//
|
|
XOHCL iPBar;
|
|
XOHCL iP2Bar;
|
|
toIDX = tb.ToIndex();
|
|
fromIDX = tb.FromIndex();
|
|
for (int i = toIDX; i <= fromIDX; i++)
|
|
{
|
|
//
|
|
// Initialize iBar ...
|
|
isDone = iBar.Init(
|
|
zBar.symbol,
|
|
zBar.period,
|
|
i //
|
|
);
|
|
isDone =
|
|
isDone &&
|
|
iBar.GetPreviousBar(iPBar);
|
|
isDone =
|
|
isDone &&
|
|
iPBar.GetPreviousBar(iP2Bar);
|
|
isDone =
|
|
isDone &&
|
|
barAnalyser.IsSimpleSwing(
|
|
iBar,
|
|
iDir //
|
|
) &&
|
|
iDir == tb.GetDirection();
|
|
if (isDone)
|
|
{
|
|
//
|
|
bool canSet =
|
|
!tb.swingBar.IsValid()
|
|
? true
|
|
: (isBullish
|
|
? tb.swingBar.low > iP2Bar.low
|
|
: tb.swingBar.high < iP2Bar.high);
|
|
if (canSet)
|
|
{
|
|
tb.swingBar = iP2Bar;
|
|
}
|
|
}
|
|
|
|
//
|
|
iBar.Clean();
|
|
iPBar.Clean();
|
|
iP2Bar.Clean();
|
|
}
|
|
|
|
//
|
|
has = tb.swingBar.IsValid();
|
|
}
|
|
|
|
//
|
|
// Force Has Liquidity ...
|
|
// TODO: Add Validation based on Liquidities
|
|
// if necessary ...
|
|
if (has &&
|
|
(_forceHasFLiquidity ||
|
|
_forceHasRLiquidity))
|
|
{
|
|
//
|
|
toIDX = tb.ToIndex();
|
|
fromIDX = tb.FromIndex();
|
|
for (int i = toIDX; i < fromIDX + loopback; i++)
|
|
{
|
|
//
|
|
// Initialize iBar ...
|
|
isDone = iBar.Init(
|
|
zBar.symbol,
|
|
zBar.period,
|
|
i //
|
|
);
|
|
|
|
//
|
|
bool isRejected =
|
|
isDone &&
|
|
barAnalyser.IsRejected(
|
|
iBar,
|
|
iDir,
|
|
false, // Force Bar Type ...
|
|
true // Force Fibo Pressure ...
|
|
);
|
|
|
|
//
|
|
// Following Liquidity ...
|
|
bool isFLiq =
|
|
isDone &&
|
|
isRejected &&
|
|
iDir == tb.GetDirection() &&
|
|
(isBullish
|
|
? iBar.low < tb.trigger.lower
|
|
: iBar.high > tb.trigger.upper);
|
|
if (isFLiq &&
|
|
_forceHasFLiquidity &&
|
|
!tb.fLiquidity.IsValid())
|
|
{
|
|
//
|
|
FillLiquidity(
|
|
iBar,
|
|
iDir,
|
|
tb.fLiquidity,
|
|
tb.trigger.to //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Reversal Liquidity ...
|
|
bool isRLiq =
|
|
isDone &&
|
|
isRejected &&
|
|
Opposit(iDir) == tb.GetDirection() &&
|
|
(isBullish
|
|
? iBar.low > tb.trigger.upper
|
|
: iBar.high < tb.trigger.lower);
|
|
if (isRLiq &&
|
|
_forceHasRLiquidity &&
|
|
!tb.rLiquidity.IsValid())
|
|
{
|
|
//
|
|
FillLiquidity(
|
|
iBar,
|
|
iDir,
|
|
tb.rLiquidity,
|
|
tb.trigger.to //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Checking Conditions ...
|
|
isDone =
|
|
(!_forceHasFLiquidity
|
|
? true
|
|
: tb.fLiquidity.IsValid()) &&
|
|
(!_forceHasRLiquidity
|
|
? true
|
|
: tb.rLiquidity.IsValid());
|
|
if (isDone)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBar.Clean();
|
|
}
|
|
|
|
//
|
|
// Checking Conditions ...
|
|
has =
|
|
(!_forceHasFLiquidity
|
|
? true
|
|
: tb.fLiquidity.IsValid()) &&
|
|
(!_forceHasRLiquidity
|
|
? true
|
|
: tb.rLiquidity.IsValid());
|
|
}
|
|
|
|
//
|
|
// Validations ...
|
|
|
|
//
|
|
// Validating Gap Sequence means
|
|
// Gap Bars must Follow each Other ...
|
|
if (has &&
|
|
_validateGapSequence)
|
|
{
|
|
//
|
|
XOHCL iPBar;
|
|
toIDX = tb.fvg.ToIndex();
|
|
fromIDX = tb.fvg.FromIndex();
|
|
|
|
//
|
|
for (int i = toIDX; i < fromIDX - 1; i++)
|
|
{
|
|
//
|
|
// Initialize iBar ...
|
|
has = iBar.Init(
|
|
zBar.symbol,
|
|
zBar.period,
|
|
i //
|
|
);
|
|
has =
|
|
has &&
|
|
iBar.GetPreviousBar(iPBar);
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? iBar.low > iPBar.low
|
|
: iBar.high < iPBar.high);
|
|
if (!has)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
iBar.Clean();
|
|
iPBar.Clean();
|
|
}
|
|
|
|
//
|
|
// Validate Block Edge Breakout ...
|
|
if (has &&
|
|
_validateBlockEdgeBreakout)
|
|
{
|
|
//
|
|
has = tb.fvg.ToBar(iBar);
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? (iBar.GetDown() < tb.ob.upper &&
|
|
iBar.GetUp() > tb.ob.upper)
|
|
: (iBar.GetDown() < tb.ob.lower &&
|
|
iBar.GetUp() > tb.ob.lower));
|
|
|
|
//
|
|
iBar.Clean();
|
|
}
|
|
|
|
//
|
|
// Filters ...
|
|
|
|
//
|
|
// PV ...
|
|
if (has &&
|
|
_filterBasedOnPV)
|
|
{
|
|
//
|
|
double iPeak = _peakBuffer[barIndex];
|
|
double iPPeak = _peakBuffer[barIndex + 1];
|
|
double iP2Peak = _peakBuffer[barIndex + 2];
|
|
|
|
//
|
|
double iPeakGolden = _peakGoldenBuffer[barIndex];
|
|
double iPPeakGolden = _peakGoldenBuffer[barIndex + 1];
|
|
double iP2PeakGolden = _peakGoldenBuffer[barIndex + 2];
|
|
|
|
//
|
|
double iVale = _valeBuffer[barIndex];
|
|
double iPVale = _valeBuffer[barIndex + 1];
|
|
double iP2Vale = _valeBuffer[barIndex + 2];
|
|
|
|
//
|
|
double iValeGolden = _valeGoldenBuffer[barIndex];
|
|
double iPValeGolden = _valeGoldenBuffer[barIndex + 1];
|
|
double iP2ValeGolden = _valeGoldenBuffer[barIndex + 2];
|
|
|
|
//
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? (tb.trigger.lower <= iVale ||
|
|
tb.trigger.lower <= iValeGolden)
|
|
: (tb.trigger.upper >= iPeak ||
|
|
tb.trigger.upper >= iPeakGolden));
|
|
}
|
|
|
|
//
|
|
// SAR ...
|
|
if (has &&
|
|
_filterBasedOnSar)
|
|
{
|
|
//
|
|
double iSarState = _sarStateBuffer[barIndex];
|
|
double iPSarState = _sarStateBuffer[barIndex + 1];
|
|
double iP2SarState = _sarStateBuffer[barIndex + 2];
|
|
|
|
//
|
|
bool isSarBullish = iSarState > 0;
|
|
bool isPSarBullish = iPSarState > 0;
|
|
bool isP2SarBullish = iP2SarState > 0;
|
|
|
|
//
|
|
bool isSarBearish = iSarState < 0;
|
|
bool isPSarBearish = iPSarState < 0;
|
|
bool isP2SarBearish = iP2SarState < 0;
|
|
|
|
//
|
|
bool isSarSwitchedToBullish =
|
|
isSarBullish &&
|
|
!isPSarBullish;
|
|
|
|
//
|
|
bool isSarSwitchedToBearish =
|
|
isSarBearish &&
|
|
!isPSarBearish;
|
|
|
|
//
|
|
bool isSarPSwitchedToBullish =
|
|
isPSarBullish &&
|
|
!isP2SarBullish;
|
|
|
|
//
|
|
bool isSarPSwitchedToBearish =
|
|
isPSarBearish &&
|
|
!isP2SarBearish;
|
|
|
|
//
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? (isSarSwitchedToBullish ||
|
|
isSarPSwitchedToBullish)
|
|
: (isSarSwitchedToBearish ||
|
|
isSarPSwitchedToBearish));
|
|
}
|
|
|
|
//
|
|
// RSI ...
|
|
if (has &&
|
|
_filterBasedOnRSI)
|
|
{
|
|
//
|
|
double rsiTrend = (_rsiOBLevel + _rsiOSLevel) / 2;
|
|
|
|
//
|
|
double iRSI = rsiBuffer[barIndex];
|
|
double iPRSI = rsiBuffer[barIndex + 1];
|
|
double iP2RSI = rsiBuffer[barIndex + 2];
|
|
|
|
//
|
|
bool isRSICrossedOverOS =
|
|
iRSI > rsiOSLevel &&
|
|
iPRSI <= rsiOSLevel;
|
|
|
|
//
|
|
bool isRSICrossedUnderOB =
|
|
iRSI < rsiOBLevel &&
|
|
iPRSI >= rsiOBLevel;
|
|
|
|
//
|
|
bool isPRSICrossedOverOS =
|
|
iPRSI > rsiOSLevel &&
|
|
iP2RSI <= rsiOSLevel;
|
|
|
|
//
|
|
bool isPRSICrossedUnderOB =
|
|
iPRSI < rsiOBLevel &&
|
|
iP2RSI >= rsiOBLevel;
|
|
|
|
//
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? (isRSICrossedOverOS ||
|
|
isPRSICrossedOverOS)
|
|
: (isRSICrossedUnderOB ||
|
|
isPRSICrossedUnderOB));
|
|
}
|
|
|
|
//
|
|
// ADX ...
|
|
if (has &&
|
|
_filterBasedOnADX)
|
|
{
|
|
//
|
|
// ADX ...
|
|
double iADX = adxBuffer[barIndex];
|
|
double iPADX = adxBuffer[barIndex + 1];
|
|
double iP2ADX = adxBuffer[barIndex + 2];
|
|
|
|
//
|
|
// ADX +DI ...
|
|
double iADXP = adxpBuffer[barIndex];
|
|
double iPADXP = adxpBuffer[barIndex + 1];
|
|
double iP2ADXP = adxpBuffer[barIndex + 2];
|
|
|
|
//
|
|
// ADX -DI ...
|
|
double iADXN = adxnBuffer[barIndex];
|
|
double iPADXN = adxnBuffer[barIndex + 1];
|
|
double iP2ADXN = adxnBuffer[barIndex + 2];
|
|
|
|
//
|
|
// Preparing Conditions ...
|
|
|
|
//
|
|
bool isADXBullish = iADX > adxThreshold;
|
|
bool isADXBearish = iADX < adxThreshold;
|
|
|
|
//
|
|
bool isPADXBullish = iPADX > adxThreshold;
|
|
bool isPADXBearish = iPADX < adxThreshold;
|
|
|
|
//
|
|
bool isP2ADXBullish = iP2ADX > adxThreshold;
|
|
bool isP2ADXBearish = iP2ADX < adxThreshold;
|
|
|
|
//
|
|
bool isADXSwitchedToBullish =
|
|
isADXBullish &&
|
|
!isPADXBullish;
|
|
|
|
//
|
|
bool isADXSwitchedToBearish =
|
|
isADXBearish &&
|
|
!isPADXBearish;
|
|
|
|
//
|
|
bool isPADXSwitchedToBullish =
|
|
isPADXBullish &&
|
|
!isP2ADXBullish;
|
|
|
|
//
|
|
bool isPADXSwitchedToBearish =
|
|
isPADXBearish &&
|
|
!isP2ADXBearish;
|
|
|
|
//
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? (isADXSwitchedToBullish ||
|
|
isPADXSwitchedToBullish)
|
|
: (isADXSwitchedToBearish ||
|
|
isPADXSwitchedToBearish));
|
|
}
|
|
|
|
//
|
|
// ATR ...
|
|
if (has &&
|
|
_filterBasedOnATR)
|
|
{
|
|
//
|
|
fromIDX = tb.FromIndex();
|
|
double iATRUpper = _atrUpperBuffer[fromIDX];
|
|
double iATRLower = _atrLowerBuffer[fromIDX];
|
|
|
|
//
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? tb.trigger.lower < iATRLower
|
|
: tb.trigger.upper > iATRUpper);
|
|
}
|
|
|
|
//
|
|
// TREND ...
|
|
if (has &&
|
|
_filterBasedOnTrend)
|
|
{
|
|
//
|
|
double iTrendState = _trendStateBuffer[barIndex];
|
|
double iPTrendState = _trendStateBuffer[barIndex + 1];
|
|
|
|
//
|
|
bool isTrendBullish = iTrendState > 0;
|
|
bool isPTrendBullish = iPTrendState > 0;
|
|
|
|
//
|
|
bool isTrendBearish = iTrendState < 0;
|
|
bool isPTrendBearish = iPTrendState < 0;
|
|
|
|
//
|
|
double trends[];
|
|
int toIDX = tb.ToIndex();
|
|
int fromIDX = tb.FromIndex();
|
|
double iTrend = trendBuffer[toIDX];
|
|
for (int i = toIDX; i <= fromIDX; i++)
|
|
{
|
|
//
|
|
Add(
|
|
trendBuffer[i],
|
|
trends //
|
|
);
|
|
}
|
|
double trendsMin = GetMin(trends);
|
|
double trendsMax = GetMax(trends);
|
|
double trendsAVG = GetAverage(trends);
|
|
|
|
//
|
|
bool isTrendUp =
|
|
iTrend > trendsMin &&
|
|
iTrend >= trendsAVG;
|
|
|
|
//
|
|
bool isTrendDown =
|
|
iTrend < trendsMax &&
|
|
iTrend <= trendsAVG;
|
|
|
|
//
|
|
bool isTrendSwitchedToBullish =
|
|
isTrendUp &&
|
|
isTrendBullish &&
|
|
!isPTrendBullish;
|
|
|
|
//
|
|
bool isTrendSwitchedToBearish =
|
|
isTrendDown &&
|
|
isTrendBearish &&
|
|
!isPTrendBearish;
|
|
|
|
//
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? isTrendSwitchedToBullish
|
|
: isTrendSwitchedToBearish);
|
|
}
|
|
|
|
//
|
|
// DELTA ...
|
|
if (has &&
|
|
_filterBasedOnDelta)
|
|
{
|
|
//
|
|
double iDelta = _deltaBuffer[barIndex];
|
|
double iPDelta = _deltaBuffer[barIndex + 1];
|
|
|
|
//
|
|
bool isDeltaUp = iDelta > iPDelta;
|
|
bool isDeltaDown = iDelta < iPDelta;
|
|
|
|
//
|
|
double iDeltaSignal = _deltaSignalBuffer[barIndex];
|
|
double iPDeltaSignal = _deltaSignalBuffer[barIndex + 1];
|
|
|
|
//
|
|
bool isDeltaSignalUp = iDeltaSignal > iPDeltaSignal;
|
|
bool isDeltaSignalDown = iDeltaSignal < iPDeltaSignal;
|
|
|
|
//
|
|
bool isDeltaSwitchedToBullish =
|
|
isDeltaUp &&
|
|
isDeltaSignalUp &&
|
|
iDelta > iDeltaSignal &&
|
|
iPDelta < iPDeltaSignal;
|
|
|
|
//
|
|
bool isDeltaSwitchedToBearish =
|
|
isDeltaDown &&
|
|
isDeltaSignalDown &&
|
|
iDelta < iDeltaSignal &&
|
|
iPDelta > iPDeltaSignal;
|
|
|
|
//
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? isDeltaSwitchedToBullish
|
|
: isDeltaSwitchedToBearish);
|
|
}
|
|
|
|
//
|
|
// VOLUME ...
|
|
if (has &&
|
|
_filterBasedOnVolume)
|
|
{
|
|
//
|
|
double iBullishVolumeSignal = _bullishVolumeSignalBuffer[barIndex];
|
|
double iPBullishVolumeSignal = _bullishVolumeSignalBuffer[barIndex + 1];
|
|
|
|
//
|
|
bool isBullishVolumeSignalUp = iBullishVolumeSignal > iPBullishVolumeSignal;
|
|
bool isBullishVolumeSignalDown = iBullishVolumeSignal < iPBullishVolumeSignal;
|
|
|
|
//
|
|
double iBearishVolumeSignal = _bearishVolumeSignalBuffer[barIndex];
|
|
double iPBearishVolumeSignal = _bearishVolumeSignalBuffer[barIndex + 1];
|
|
|
|
//
|
|
bool isBearishVolumeSignalUp = iBearishVolumeSignal > iPBearishVolumeSignal;
|
|
bool isBearishVolumeSignalDown = iBearishVolumeSignal < iPBearishVolumeSignal;
|
|
|
|
//
|
|
bool isVolumeSwitchdToBullish =
|
|
isBullishVolumeSignalUp &&
|
|
!isBearishVolumeSignalUp &&
|
|
iBullishVolumeSignal > iBearishVolumeSignal &&
|
|
iPBullishVolumeSignal < iPBearishVolumeSignal;
|
|
|
|
//
|
|
bool isVolumeSwitchdToBearish =
|
|
isBearishVolumeSignalUp &&
|
|
!isBullishVolumeSignalUp &&
|
|
iBearishVolumeSignal > iBullishVolumeSignal &&
|
|
iPBearishVolumeSignal < iPBullishVolumeSignal;
|
|
|
|
//
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? isVolumeSwitchdToBullish
|
|
: isVolumeSwitchdToBearish);
|
|
}
|
|
|
|
//
|
|
// SIGNAL Bar ...
|
|
if (has &&
|
|
_filterBasedOnSignalBar)
|
|
{
|
|
//
|
|
double iSignalOpen = _sBarOpenSBuffer[barIndex];
|
|
double iPSignalOpen = _sBarOpenSBuffer[barIndex + 1];
|
|
|
|
//
|
|
double iSignalClose = _sBarCloseBuffer[barIndex];
|
|
double iPSignalClose = _sBarCloseBuffer[barIndex + 1];
|
|
|
|
//
|
|
bool isSignalBarBullish = iSignalOpen < iSignalClose;
|
|
bool isPSignalBarBullish = iPSignalOpen < iPSignalClose;
|
|
|
|
//
|
|
bool isSignalBarBearish = iSignalOpen > iSignalClose;
|
|
bool isPSignalBarBearish = iPSignalOpen > iPSignalClose;
|
|
|
|
//
|
|
bool isSignalBarSwitchedToBullish =
|
|
isSignalBarBullish &&
|
|
!isPSignalBarBullish;
|
|
|
|
//
|
|
bool isSignalBarSwitchedToBearish =
|
|
isSignalBarBearish &&
|
|
!isPSignalBarBearish;
|
|
|
|
//
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? isSignalBarSwitchedToBullish
|
|
: isSignalBarSwitchedToBearish);
|
|
}
|
|
|
|
//
|
|
// HK SIGNAL Bar ...
|
|
if (has &&
|
|
_filterBasedOnHKSignalBar)
|
|
{
|
|
//
|
|
double iHKSignalOpen = _hkSBarOpenBuffer[barIndex];
|
|
double iPHKSignalOpen = _hkSBarOpenBuffer[barIndex + 1];
|
|
|
|
//
|
|
double iHKSignalClose = _hkSBarCloseBuffer[barIndex];
|
|
double iPHKSignalClose = _hkSBarCloseBuffer[barIndex + 1];
|
|
|
|
//
|
|
bool isHKSignalBarBullish = iHKSignalOpen < iHKSignalClose;
|
|
bool isPHKSignalBarBullish = iPHKSignalOpen < iPHKSignalClose;
|
|
|
|
//
|
|
bool isHKSignalBarBearish = iHKSignalOpen > iHKSignalClose;
|
|
bool isPHKSignalBarBearish = iPHKSignalOpen > iPHKSignalClose;
|
|
|
|
//
|
|
bool isHKSignalBarSwitchedToBullish =
|
|
isHKSignalBarBullish &&
|
|
!isPHKSignalBarBullish;
|
|
|
|
//
|
|
bool isHKSignalBarSwitchedToBearish =
|
|
isHKSignalBarBearish &&
|
|
!isPHKSignalBarBearish;
|
|
|
|
//
|
|
has =
|
|
has &&
|
|
(isBullish
|
|
? isHKSignalBarSwitchedToBullish
|
|
: isHKSignalBarSwitchedToBearish);
|
|
}
|
|
|
|
//
|
|
// Preparing Signal ...
|
|
if (has)
|
|
{
|
|
//
|
|
double targets[];
|
|
for (int i = 1; i <= _r2r; i++)
|
|
{
|
|
//
|
|
Add(
|
|
(double)i,
|
|
targets //
|
|
);
|
|
}
|
|
|
|
//
|
|
double iATR = atrBuffer[barIndex];
|
|
double slAdditional = _slAtrMultiplier * iATR;
|
|
|
|
//
|
|
has = ToSignal(
|
|
tb.trigger,
|
|
tb.signal,
|
|
targets,
|
|
slAdditional //
|
|
);
|
|
}
|
|
|
|
//
|
|
result = has;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Draw Specific Trigger Block ...
|
|
bool DrawTriggerBlock(
|
|
XTriggerBlock &trigger,
|
|
XCPOIDrawer *drawer,
|
|
CArrayObj &objects,
|
|
datetime to = NULL,
|
|
int rrZoneLength = 10,
|
|
//
|
|
// Styles ...
|
|
//
|
|
// Trigger Block ...
|
|
int tbWidth = 1, // Trigger Block Width
|
|
color tbBullishColor = clrAqua, // Trigger Block Bullish Color
|
|
color tbBearishColor = clrMagenta, // Trigger Block Bearish Color
|
|
ENUM_LINE_STYLE tbStyle = STYLE_DASHDOTDOT, // Trigger Block Style
|
|
//
|
|
// OB ...
|
|
int obWidth = 1, // OB Width
|
|
color obBullishColor = clrLime, // OB Bullish Color
|
|
color obBearishColor = clrRed, // OB Bearish Color
|
|
ENUM_LINE_STYLE obStyle = STYLE_DOT, // OB Style
|
|
//
|
|
// FVG ...
|
|
int fvgWidth = 2, // FVG Width
|
|
color fvgBullishColor = clrLime, // FVG Bullish Color
|
|
color fvgBearishColor = clrRed, // FVG Bearish Color
|
|
ENUM_LINE_STYLE fvgStyle = STYLE_SOLID // FVG Style
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
result = trigger.IsValid() &&
|
|
drawer != NULL;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Update To ...
|
|
bool canUpdateTo = IsValid(to);
|
|
if (canUpdateTo)
|
|
{
|
|
//
|
|
trigger.trigger.to = to;
|
|
trigger.rLiquidity.to = to;
|
|
trigger.fLiquidity.to = to;
|
|
}
|
|
|
|
//
|
|
bool isBullish = trigger.IsBullish();
|
|
|
|
//
|
|
// Draw OB ...
|
|
if (trigger.ob.IsValid())
|
|
{
|
|
//
|
|
XCBoxObject *iOBObj;
|
|
result = drawer.DrawBox(
|
|
trigger.ob,
|
|
iOBObj //
|
|
);
|
|
if (result)
|
|
{
|
|
//
|
|
// Style Object ...
|
|
|
|
//
|
|
color iClr =
|
|
isBullish
|
|
? obBullishColor
|
|
: obBearishColor;
|
|
|
|
//
|
|
iOBObj.BoxColor(iClr);
|
|
iOBObj.BoxWidth(obWidth);
|
|
iOBObj.BoxStyle(obStyle);
|
|
|
|
//
|
|
// Store Object ...
|
|
objects.Add(iOBObj);
|
|
}
|
|
ZeroMemory(iOBObj);
|
|
|
|
//
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Draw FVG ...
|
|
if (trigger.fvg.IsValid())
|
|
{
|
|
//
|
|
XCBoxObject *iFVGObj;
|
|
result = drawer.DrawBox(
|
|
trigger.fvg,
|
|
iFVGObj //
|
|
);
|
|
if (result)
|
|
{
|
|
//
|
|
// Style Object ...
|
|
|
|
//
|
|
color iClr =
|
|
isBullish
|
|
? fvgBullishColor
|
|
: fvgBearishColor;
|
|
|
|
//
|
|
iFVGObj.BoxColor(iClr);
|
|
iFVGObj.BoxWidth(fvgWidth);
|
|
iFVGObj.BoxStyle(fvgStyle);
|
|
|
|
//
|
|
// Store Object ...
|
|
objects.Add(iFVGObj);
|
|
}
|
|
ZeroMemory(iFVGObj);
|
|
|
|
//
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Draw Trigger ...
|
|
if (trigger.trigger.IsValid())
|
|
{
|
|
//
|
|
XCBoxObject *iTriggerObj;
|
|
result = drawer.DrawBox(
|
|
trigger.trigger,
|
|
iTriggerObj //
|
|
);
|
|
if (result)
|
|
{
|
|
//
|
|
// Style Object ...
|
|
|
|
//
|
|
color iClr =
|
|
isBullish
|
|
? tbBullishColor
|
|
: tbBearishColor;
|
|
|
|
//
|
|
iTriggerObj.BoxColor(iClr);
|
|
iTriggerObj.BoxWidth(tbWidth);
|
|
iTriggerObj.BoxStyle(tbStyle);
|
|
|
|
//
|
|
// Store Object ...
|
|
objects.Add(iTriggerObj);
|
|
}
|
|
ZeroMemory(iTriggerObj);
|
|
|
|
//
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Draw Liquidities ...
|
|
|
|
//
|
|
// Reversla Liquidity ...
|
|
if (trigger.rLiquidity.IsValid())
|
|
{
|
|
//
|
|
XCBoxObject *iLiqObj;
|
|
result = drawer.DrawBox(
|
|
trigger.rLiquidity,
|
|
iLiqObj //
|
|
);
|
|
if (result)
|
|
{
|
|
objects.Add(iLiqObj);
|
|
}
|
|
ZeroMemory(iLiqObj);
|
|
|
|
//
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Following Liquidity ...
|
|
if (trigger.fLiquidity.IsValid())
|
|
{
|
|
//
|
|
XCBoxObject *iLiqObj;
|
|
result = drawer.DrawBox(
|
|
trigger.fLiquidity,
|
|
iLiqObj //
|
|
);
|
|
if (result)
|
|
{
|
|
objects.Add(iLiqObj);
|
|
}
|
|
ZeroMemory(iLiqObj);
|
|
|
|
//
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Draw Swing Bar ...
|
|
if (trigger.swingBar.IsValid())
|
|
{
|
|
//
|
|
color swingColor =
|
|
trigger.fvg.IsBullish()
|
|
? clrAqua
|
|
: clrMagenta;
|
|
ENUM_X_PRICE swingPType =
|
|
trigger.fvg.IsBullish()
|
|
? X_PRICE_LOW
|
|
: X_PRICE_HIGH;
|
|
|
|
//
|
|
XCBarArrowObject *swingObj;
|
|
result = drawer.CreateBarArrow(
|
|
trigger.swingBar,
|
|
swingObj,
|
|
swingPType,
|
|
159,
|
|
swingColor //
|
|
);
|
|
if (result)
|
|
{
|
|
objects.Add(swingObj);
|
|
}
|
|
ZeroMemory(swingObj);
|
|
|
|
//
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Draw RR of Signal ...
|
|
if (trigger.signal.IsValid() &&
|
|
rrZoneLength > 0)
|
|
{
|
|
//
|
|
XCRRObject *iRRObj;
|
|
iRRObj = new XCRRObject();
|
|
result = iRRObj.Create(
|
|
drawer.ChartIdentification(),
|
|
drawer.SubWindowIdentification(),
|
|
trigger.signal,
|
|
rrZoneLength //
|
|
);
|
|
if (result)
|
|
{
|
|
//
|
|
int iWidth = 2;
|
|
ENUM_LINE_STYLE iStyle = STYLE_SOLID;
|
|
|
|
//
|
|
iRRObj.TPWidth(iWidth);
|
|
iRRObj.SLWidth(iWidth);
|
|
iRRObj.EntryWidth(iWidth);
|
|
iRRObj.TargetWidth(iWidth);
|
|
|
|
//
|
|
iRRObj.TPStyle(iStyle);
|
|
iRRObj.SLStyle(iStyle);
|
|
iRRObj.EntryStyle(iStyle);
|
|
iRRObj.TargetStyle(iStyle);
|
|
|
|
//
|
|
iRRObj.TPColor(clrLime);
|
|
iRRObj.SLColor(clrRed);
|
|
iRRObj.EntryColor(clrYellow);
|
|
iRRObj.TargetColor(clrLightBlue);
|
|
|
|
//
|
|
objects.Add(iRRObj);
|
|
}
|
|
ZeroMemory(iRRObj);
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
return result;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|