2560 lines
71 KiB
Plaintext
2560 lines
71 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Class Library
|
|
// --------------------------------------
|
|
// Name: XCX121SMCStrategy
|
|
// Description: provides all based classes for use ...
|
|
//
|
|
//
|
|
// 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
|
|
|
|
//
|
|
// Imports ...
|
|
|
|
//
|
|
#include "../Classes/x-121.smc.base.strategy.class.mq5"
|
|
#include "../Classes/x-121.smc.market.cycle.helper.class.mq5"
|
|
|
|
//
|
|
#include "../Signals/x-121.smc.test.signal.lib.mq5"
|
|
#include "../Signals/x-121.smc.xpvdp.signal.lib.mq5"
|
|
#include "../Signals/x-121.smc.xpvob.signal.lib.mq5"
|
|
#include "../Signals/x-121.smc.xpvsupdem.signal.lib.mq5"
|
|
|
|
//
|
|
// Definitions ...
|
|
|
|
//
|
|
// XStrategy Class Implementation(s) ...
|
|
class XCX121SMCStrategy : public XCX121SMCBaseStrategy
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor(s) ...
|
|
void XCX121SMCStrategy(
|
|
//
|
|
// Base ...
|
|
string _symbol, // Trading Symbol
|
|
ENUM_TIMEFRAMES _period // Trading TimeFrame
|
|
)
|
|
: XCX121SMCBaseStrategy(_symbol, _period)
|
|
{
|
|
InitialHelpers();
|
|
}
|
|
|
|
//
|
|
// Deconstructur ...
|
|
void ~XCX121SMCStrategy()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Overrides Actions ...
|
|
|
|
/**
|
|
* Destroy All Class Implementations ...
|
|
*/
|
|
void Destroy() override
|
|
{
|
|
//
|
|
delete mTriggerCycleHelper;
|
|
delete mDecisionCycleHelper;
|
|
delete mAnalyseCycleHelper;
|
|
delete mVerificationCycleHelper;
|
|
delete mConsolidationCycleHelper;
|
|
delete mVisionCycleHelper;
|
|
}
|
|
|
|
/**
|
|
* Check Conditions For Signal ...
|
|
*/
|
|
bool HasSignal(
|
|
XSignal &signal,
|
|
X121SMCStrategyConditions &conditions //
|
|
) override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
signal.Clean();
|
|
conditions.Clean();
|
|
|
|
//
|
|
int pushers = 0;
|
|
|
|
//
|
|
double sl = 0;
|
|
double tp = 0;
|
|
double risk = 0;
|
|
double entry = 0;
|
|
double reward = 0;
|
|
double r2r = R2R();
|
|
string provider = "";
|
|
double volume = Volume();
|
|
ENUM_POSITION_TYPE type = POSITION_TYPE_BUY;
|
|
ENUM_X_ORDER_MODES mode = X_ORDER_MODE_MARKET;
|
|
|
|
//
|
|
bool hasLong = false;
|
|
bool hasShort = false;
|
|
|
|
//
|
|
double selectedSL = 0;
|
|
|
|
//
|
|
// Start Calculations ...
|
|
|
|
//
|
|
// Retrieve Common Data ...
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
// Required Value For SL/TP Calculations ...
|
|
double points = GetPoints(symbol);
|
|
double pip = GetPipPrice(symbol);
|
|
double pip2 = 2 * pip;
|
|
|
|
//
|
|
// Retrieve and Fill Cycle Conditions ...
|
|
result = GetCyclesConditions(conditions);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check Spread for Signalling Conditions ...
|
|
bool isSpreadPassed = IsSpreadPass();
|
|
result = isSpreadPassed;
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Signal Conditions ...
|
|
bool hasSignal = false;
|
|
|
|
//
|
|
bool hasTestSignal = false;
|
|
bool hasXPVOBSignal = false;
|
|
bool hasXPVDPSignal = false;
|
|
bool hasXPVSUPDEMSignal = false;
|
|
|
|
//
|
|
// Test Signal ...
|
|
if (!hasSignal)
|
|
{
|
|
//
|
|
hasTestSignal = DetectTestSignal(conditions);
|
|
hasSignal = hasTestSignal;
|
|
}
|
|
|
|
//
|
|
// XPVOB Signal ...
|
|
if (!hasSignal)
|
|
{
|
|
//
|
|
hasXPVOBSignal = DetectXPVOBSignal(conditions);
|
|
hasSignal = hasXPVOBSignal;
|
|
}
|
|
|
|
//
|
|
// XPVDP Signal ...
|
|
if (!hasSignal)
|
|
{
|
|
//
|
|
hasXPVDPSignal = DetectXPVDPSignal(conditions);
|
|
hasSignal = hasXPVDPSignal;
|
|
}
|
|
|
|
//
|
|
// XPVSUPDEM Signal ...
|
|
if (!hasSignal)
|
|
{
|
|
//
|
|
hasXPVSUPDEMSignal = DetectXPVSUPDEMSignal(conditions);
|
|
hasSignal = hasXPVSUPDEMSignal;
|
|
}
|
|
|
|
//
|
|
result = hasSignal;
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Combine all Signals Conditions ...
|
|
selectedSL = conditions.sl;
|
|
provider = conditions.provider;
|
|
|
|
//
|
|
hasLong =
|
|
//
|
|
IsBullish(conditions.signalDir)
|
|
//
|
|
;
|
|
|
|
//
|
|
hasShort =
|
|
//
|
|
IsBearish(conditions.signalDir)
|
|
//
|
|
;
|
|
|
|
//
|
|
result = hasLong ||
|
|
hasShort;
|
|
|
|
//
|
|
// Rmove Signal Condition ...
|
|
if (result)
|
|
{
|
|
//
|
|
// TYPE ...
|
|
type =
|
|
hasLong
|
|
? POSITION_TYPE_BUY
|
|
: POSITION_TYPE_SELL;
|
|
ENUM_X_POSITION_TYPES xType =
|
|
hasLong
|
|
? X_POSITION_TYPE_LONG
|
|
: X_POSITION_TYPE_SHORT;
|
|
|
|
//
|
|
entry = GetEntry(
|
|
conditions.symbol,
|
|
type //
|
|
);
|
|
|
|
//
|
|
double slAddition = 0;
|
|
sl =
|
|
hasLong
|
|
? selectedSL - slAddition
|
|
: selectedSL + slAddition;
|
|
|
|
//
|
|
// RISK Reward ...
|
|
risk =
|
|
hasLong
|
|
? entry - sl
|
|
: sl - entry;
|
|
reward = risk * r2r;
|
|
tp =
|
|
hasLong
|
|
? entry + reward
|
|
: entry - reward;
|
|
|
|
//
|
|
signal.sl = sl;
|
|
signal.tp = tp;
|
|
signal.type = type;
|
|
signal.mode = mode;
|
|
signal.entry = entry;
|
|
signal.volume = volume;
|
|
signal.symbol = symbol;
|
|
signal.period = period;
|
|
signal.pushers = pushers;
|
|
signal.provider = provider;
|
|
signal.time = TimeCurrent();
|
|
|
|
//
|
|
// Configure Signal Protecting ...
|
|
if (hasXPVOBSignal ||
|
|
hasXPVDPSignal ||
|
|
hasXPVSUPDEMSignal)
|
|
{
|
|
//
|
|
signal.fullTPLevel = r2r;
|
|
signal.partialCloseOnTPLevel = 2;
|
|
signal.partialCloseMultiplier = 0.5;
|
|
|
|
//
|
|
signal.riskFreeOnBreakEven = true;
|
|
signal.tpLevelForBreakEven = 1;
|
|
|
|
//
|
|
signal.trailSL = true;
|
|
signal.trailSLStartOnReachTPLevel = 3;
|
|
}
|
|
|
|
//
|
|
result = PrepareSignal(signal);
|
|
if (result)
|
|
{
|
|
DrawSignal(signal);
|
|
}
|
|
|
|
//
|
|
hasLong = false;
|
|
hasShort = false;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Customize Strategy Identifier ...
|
|
*/
|
|
string GetTag() override
|
|
{
|
|
return X121SMCStrategyToken;
|
|
}
|
|
|
|
//
|
|
// Protected ...
|
|
protected:
|
|
//
|
|
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
// Trigger Order Flow ...
|
|
XPVPivot mOrderFlow[];
|
|
ENUM_X_DIRECTION mOrderFlowDir;
|
|
|
|
//
|
|
ENUM_XPOI_EVENTS mTriggerPOIEvents[];
|
|
ENUM_X_CYCLE_EVENTS mTriggerCycleEvents[];
|
|
XC121SMCCycleHelper *mTriggerCycleHelper;
|
|
|
|
//
|
|
ENUM_XPOI_EVENTS mDecisionPOIEvents[];
|
|
ENUM_X_CYCLE_EVENTS mDecisionCycleEvents[];
|
|
XC121SMCCycleHelper *mDecisionCycleHelper;
|
|
|
|
//
|
|
ENUM_XPOI_EVENTS mAnalysePOIEvents[];
|
|
ENUM_X_CYCLE_EVENTS mAnalyseCycleEvents[];
|
|
XC121SMCCycleHelper *mAnalyseCycleHelper;
|
|
|
|
//
|
|
ENUM_XPOI_EVENTS mVerificationPOIEvents[];
|
|
ENUM_X_CYCLE_EVENTS mVerificationCycleEvents[];
|
|
XC121SMCCycleHelper *mVerificationCycleHelper;
|
|
|
|
//
|
|
ENUM_XPOI_EVENTS mConsolidationPOIEvents[];
|
|
ENUM_X_CYCLE_EVENTS mConsolidationCycleEvents[];
|
|
XC121SMCCycleHelper *mConsolidationCycleHelper;
|
|
|
|
//
|
|
ENUM_XPOI_EVENTS mVisionPOIEvents[];
|
|
ENUM_X_CYCLE_EVENTS mVisionCycleEvents[];
|
|
XC121SMCCycleHelper *mVisionCycleHelper;
|
|
|
|
//
|
|
// Actions ...
|
|
|
|
/**
|
|
* Retrieve Cycles Conditions ...
|
|
*
|
|
* @param conditions: X121SMCStrategyConditions instance Reference ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool GetCyclesConditions(
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
conditions.time = cTime;
|
|
conditions.symbol = symbol;
|
|
conditions.period = period;
|
|
|
|
//
|
|
int conditionsLoopback = 7;
|
|
|
|
//
|
|
// Fill Cycles Conditions ...
|
|
|
|
//
|
|
// Trigger ...
|
|
result = mTriggerCycleHelper.GetConditions(
|
|
mTriggerCycleEvents,
|
|
mTriggerPOIEvents,
|
|
conditions.triggerConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.triggerConditions.state = mTriggerState;
|
|
|
|
//
|
|
// Decision ...
|
|
result = mDecisionCycleHelper.GetConditions(
|
|
mDecisionCycleEvents,
|
|
mDecisionPOIEvents,
|
|
conditions.decisionConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.decisionConditions.state = mDecisionState;
|
|
|
|
//
|
|
// Analyse ...
|
|
result = mAnalyseCycleHelper.GetConditions(
|
|
mAnalyseCycleEvents,
|
|
mAnalysePOIEvents,
|
|
conditions.analyseConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.analyseConditions.state = mAnalyseState;
|
|
|
|
//
|
|
// Verification ...
|
|
result = mVerificationCycleHelper.GetConditions(
|
|
mVerificationCycleEvents,
|
|
mVerificationPOIEvents,
|
|
conditions.verificationConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.verificationConditions.state = mVerificationState;
|
|
|
|
//
|
|
// Consolidation ...
|
|
result = mConsolidationCycleHelper.GetConditions(
|
|
mConsolidationCycleEvents,
|
|
mConsolidationPOIEvents,
|
|
conditions.consolidationConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.consolidationConditions.state = mConsolidationState;
|
|
|
|
//
|
|
// Vision ...
|
|
result = mVisionCycleHelper.GetConditions(
|
|
mVisionCycleEvents,
|
|
mVisionPOIEvents,
|
|
conditions.visionConditions,
|
|
zIndex,
|
|
conditionsLoopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
return result;
|
|
}
|
|
conditions.visionConditions.state = mVisionState;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Signalling Functions ...
|
|
|
|
//
|
|
// Test Signal ...
|
|
X121SMCStrategyTestSignalConditions mTestConditions;
|
|
bool DetectTestSignal(
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_XTEST;
|
|
string providerStr = ToString(provider);
|
|
|
|
//
|
|
// Detect Setup Conditions ...
|
|
datetime setupTime = mTestConditions.setupTime;
|
|
bool isSetuped = mTestConditions.IsSetuped();
|
|
ENUM_X_DIRECTION setupDir = mTestConditions.dir;
|
|
if (!isSetuped)
|
|
{
|
|
//
|
|
// Detect Signal Setup ...
|
|
isSetuped = DetectX121SMCTestSiganlSetup(
|
|
symbol,
|
|
period,
|
|
mTestConditions,
|
|
mTriggerCycleHelper,
|
|
mDecisionCycleHelper,
|
|
mAnalyseCycleHelper,
|
|
mVerificationCycleHelper,
|
|
mConsolidationCycleHelper,
|
|
mVisionCycleHelper //
|
|
);
|
|
|
|
//
|
|
setupDir = mTestConditions.dir;
|
|
setupTime = mTestConditions.setupTime;
|
|
}
|
|
|
|
// ClearDraws();
|
|
// ENUM_X_DIRECTION activeZoneDir;
|
|
// bool hasTicksZone = mTestConditions.HasTicksZone();
|
|
// bool hasActiveZone = mTestConditions.HasActiveZone(activeZoneDir);
|
|
// if (hasActiveZone)
|
|
// {
|
|
// //
|
|
// if (IsBullish(activeZoneDir))
|
|
// {
|
|
// //
|
|
// mTestConditions.activeDemandZone.To(cTime);
|
|
// XCDemandZoneObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateDemandZone(
|
|
// mTestConditions.activeDemandZone,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// //
|
|
// mTestConditions.activeSupplyZone.To(cTime);
|
|
// XCSupplyZoneObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateSupplyZone(
|
|
// mTestConditions.activeSupplyZone,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
// }
|
|
// if (hasTicksZone)
|
|
// {
|
|
// //
|
|
// XCTicksZoneObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateTicksZone(
|
|
// mTestConditions.ticksZone,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
|
|
//
|
|
result = isSetuped;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Trigger Conditions ...
|
|
bool canTrigger = mTestConditions.CanTrigger();
|
|
datetime triggerTime = mTestConditions.triggerTime;
|
|
if (!canTrigger)
|
|
{
|
|
//
|
|
// Detect Signal Trigger ...
|
|
canTrigger = DetectX121SMCTestSiganlTrigger(
|
|
mTestConditions,
|
|
symbol,
|
|
period,
|
|
mTriggerCycleHelper,
|
|
mDecisionCycleHelper,
|
|
mAnalyseCycleHelper,
|
|
mVerificationCycleHelper,
|
|
mConsolidationCycleHelper,
|
|
mVisionCycleHelper //
|
|
);
|
|
|
|
//
|
|
result = canTrigger;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
triggerTime = mTestConditions.triggerTime;
|
|
}
|
|
|
|
//
|
|
// Check Signal Direction ...
|
|
|
|
//
|
|
isBullish = IsBullish(setupDir);
|
|
isBearish = IsBearish(setupDir);
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Issues Signal on Conditions ...
|
|
conditions.signalDir = setupDir;
|
|
conditions.provider = providerStr;
|
|
conditions.sl = mTestConditions.sl;
|
|
|
|
//
|
|
mTestConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XPVOB Signal ...
|
|
X121SMCStrategyXPVOBSignalConditions mXPVOBConditions;
|
|
bool DetectXPVOBSignal(
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_XPVOB;
|
|
string providerStr = ToString(provider);
|
|
|
|
//
|
|
// Detect Setup Conditions ...
|
|
datetime setupTime = mXPVOBConditions.setupTime;
|
|
bool isSetuped = mXPVOBConditions.IsSetuped();
|
|
ENUM_X_DIRECTION setupDir = mXPVOBConditions.dir;
|
|
if (!isSetuped)
|
|
{
|
|
//
|
|
// Detect Signal Setup ...
|
|
isSetuped = DetectX121SMCXPVOBSiganlSetup(
|
|
symbol,
|
|
period,
|
|
mXPVOBConditions,
|
|
mTriggerCycleHelper,
|
|
mDecisionCycleHelper,
|
|
mAnalyseCycleHelper,
|
|
mVerificationCycleHelper,
|
|
mConsolidationCycleHelper,
|
|
mVisionCycleHelper //
|
|
);
|
|
|
|
//
|
|
result = isSetuped;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
setupDir = mXPVOBConditions.dir;
|
|
setupTime = mXPVOBConditions.setupTime;
|
|
}
|
|
|
|
//
|
|
// Draw Conditions Active FVG ...
|
|
// if (isSetuped)
|
|
// {
|
|
// //
|
|
// XCFVG *iFVG = mXPVOBConditions.activeFVG;
|
|
// if (iFVG != NULL && iFVG.IsValid())
|
|
// {
|
|
// //
|
|
// ClearDraws();
|
|
// iFVG.To(cTime);
|
|
// if (IsBullish(setupDir) && iFVG.IsBullish())
|
|
// {
|
|
// //
|
|
// XCBullishFairValueGapObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateBullishFairValueGap(
|
|
// iFVG,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
// else if (IsBearish(setupDir) && iFVG.IsBearish())
|
|
// {
|
|
// //
|
|
// XCBearishFairValueGapObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateBearishFairValueGap(
|
|
// iFVG,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
//
|
|
// Detect Trigger Conditions ...
|
|
bool canTrigger = mXPVOBConditions.CanTrigger();
|
|
datetime triggerTime = mXPVOBConditions.triggerTime;
|
|
if (!canTrigger)
|
|
{
|
|
//
|
|
// Detect Signal Trigger ...
|
|
canTrigger = DetectX121SMCXPVOBSiganlTrigger(
|
|
mXPVOBConditions,
|
|
symbol,
|
|
period,
|
|
mTriggerCycleHelper,
|
|
mDecisionCycleHelper,
|
|
mAnalyseCycleHelper,
|
|
mVerificationCycleHelper,
|
|
mConsolidationCycleHelper,
|
|
mVisionCycleHelper //
|
|
);
|
|
|
|
//
|
|
result = canTrigger;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
triggerTime = mXPVOBConditions.triggerTime;
|
|
}
|
|
|
|
//
|
|
// Check Signal Direction ...
|
|
|
|
//
|
|
isBullish = IsBullish(setupDir);
|
|
isBearish = IsBearish(setupDir);
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Issues Signal on Conditions ...
|
|
conditions.signalDir = setupDir;
|
|
conditions.provider = providerStr;
|
|
conditions.sl = mXPVOBConditions.sl;
|
|
|
|
//
|
|
mXPVOBConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XPVDP Signal ...
|
|
X121SMCStrategyXPVDPSignalConditions mXPVDPConditions;
|
|
bool DetectXPVDPSignal(
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_XPVDP;
|
|
string providerStr = ToString(provider);
|
|
|
|
//
|
|
// Detect Setup Conditions ...
|
|
datetime setupTime = mXPVDPConditions.setupTime;
|
|
bool isSetuped = mXPVDPConditions.IsSetuped();
|
|
ENUM_X_DIRECTION setupDir = mXPVDPConditions.dir;
|
|
if (!isSetuped)
|
|
{
|
|
//
|
|
// Detect Signal Setup ...
|
|
isSetuped = DetectX121SMCXPVDPSiganlSetup(
|
|
symbol,
|
|
period,
|
|
mXPVDPConditions,
|
|
mTriggerCycleHelper,
|
|
mDecisionCycleHelper,
|
|
mAnalyseCycleHelper,
|
|
mVerificationCycleHelper,
|
|
mConsolidationCycleHelper,
|
|
mVisionCycleHelper //
|
|
);
|
|
|
|
//
|
|
setupDir = mXPVDPConditions.dir;
|
|
setupTime = mXPVDPConditions.setupTime;
|
|
}
|
|
result = isSetuped;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Trigger Conditions ...
|
|
bool canTrigger = mXPVDPConditions.CanTrigger();
|
|
datetime triggerTime = mXPVDPConditions.triggerTime;
|
|
if (!canTrigger)
|
|
{
|
|
//
|
|
// Detect Signal Trigger ...
|
|
canTrigger = DetectX121SMCXPVDPSiganlTrigger(
|
|
mXPVDPConditions,
|
|
symbol,
|
|
period,
|
|
mTriggerCycleHelper,
|
|
mDecisionCycleHelper,
|
|
mAnalyseCycleHelper,
|
|
mVerificationCycleHelper,
|
|
mConsolidationCycleHelper,
|
|
mVisionCycleHelper //
|
|
);
|
|
|
|
//
|
|
result = canTrigger;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
triggerTime = mXPVDPConditions.triggerTime;
|
|
}
|
|
|
|
//
|
|
// Check Signal Direction ...
|
|
|
|
//
|
|
isBullish = IsBullish(setupDir);
|
|
isBearish = IsBearish(setupDir);
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Issues Signal on Conditions ...
|
|
conditions.signalDir = setupDir;
|
|
conditions.provider = providerStr;
|
|
conditions.sl = mXPVDPConditions.sl;
|
|
|
|
//
|
|
mXPVDPConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// XPVSUPDEM Signal ...
|
|
X121SMCStrategyXPVSUPDEMSignalConditions mXPVSUPDEMConditions;
|
|
bool DetectXPVSUPDEMSignal(
|
|
X121SMCStrategyConditions &conditions //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_XPVSUPDEM;
|
|
string providerStr = ToString(provider);
|
|
|
|
//
|
|
// Detect Setup Conditions ...
|
|
datetime setupTime = mXPVSUPDEMConditions.setupTime;
|
|
bool isSetuped = mXPVSUPDEMConditions.IsSetuped();
|
|
ENUM_X_DIRECTION setupDir = mXPVSUPDEMConditions.dir;
|
|
if (!isSetuped)
|
|
{
|
|
//
|
|
// Detect Signal Setup ...
|
|
isSetuped = DetectX121SMCXPVSUPDEMSiganlSetup(
|
|
symbol,
|
|
period,
|
|
mXPVSUPDEMConditions,
|
|
mTriggerCycleHelper,
|
|
mDecisionCycleHelper,
|
|
mAnalyseCycleHelper,
|
|
mVerificationCycleHelper,
|
|
mConsolidationCycleHelper,
|
|
mVisionCycleHelper //
|
|
);
|
|
|
|
//
|
|
setupDir = mXPVSUPDEMConditions.dir;
|
|
setupTime = mXPVSUPDEMConditions.setupTime;
|
|
}
|
|
|
|
// ClearDraws();
|
|
// ENUM_X_DIRECTION activeZoneDir;
|
|
// bool hasTicksZone = mXPVSUPDEMConditions.HasTicksZone();
|
|
// bool hasActiveZone = mXPVSUPDEMConditions.HasActiveZone(activeZoneDir);
|
|
// if (hasActiveZone)
|
|
// {
|
|
// //
|
|
// if (IsBullish(activeZoneDir))
|
|
// {
|
|
// //
|
|
// mXPVSUPDEMConditions.activeDemandZone.To(cTime);
|
|
// XCDemandZoneObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateDemandZone(
|
|
// mXPVSUPDEMConditions.activeDemandZone,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// //
|
|
// mXPVSUPDEMConditions.activeSupplyZone.To(cTime);
|
|
// XCSupplyZoneObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateSupplyZone(
|
|
// mXPVSUPDEMConditions.activeSupplyZone,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
// }
|
|
// if (hasTicksZone)
|
|
// {
|
|
// //
|
|
// XCTicksZoneObject *iObj;
|
|
// bool isCreated = mPOIDrawer.CreateTicksZone(
|
|
// mXPVSUPDEMConditions.ticksZone,
|
|
// iObj //
|
|
// );
|
|
// if (isCreated)
|
|
// {
|
|
// AddObjectIfNotExists(iObj);
|
|
// }
|
|
// }
|
|
|
|
//
|
|
result = isSetuped;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Trigger Conditions ...
|
|
bool canTrigger = mXPVSUPDEMConditions.CanTrigger();
|
|
datetime triggerTime = mXPVSUPDEMConditions.triggerTime;
|
|
if (!canTrigger)
|
|
{
|
|
//
|
|
// Detect Signal Trigger ...
|
|
canTrigger = DetectX121SMCXPVSUPDEMSiganlTrigger(
|
|
mXPVSUPDEMConditions,
|
|
symbol,
|
|
period,
|
|
mTriggerCycleHelper,
|
|
mDecisionCycleHelper,
|
|
mAnalyseCycleHelper,
|
|
mVerificationCycleHelper,
|
|
mConsolidationCycleHelper,
|
|
mVisionCycleHelper //
|
|
);
|
|
|
|
//
|
|
result = canTrigger;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
triggerTime = mXPVSUPDEMConditions.triggerTime;
|
|
}
|
|
|
|
//
|
|
// Check Signal Direction ...
|
|
|
|
//
|
|
isBullish = IsBullish(setupDir);
|
|
isBearish = IsBearish(setupDir);
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Issues Signal on Conditions ...
|
|
conditions.signalDir = setupDir;
|
|
conditions.provider = providerStr;
|
|
conditions.sl = mXPVSUPDEMConditions.sl;
|
|
|
|
//
|
|
mXPVSUPDEMConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Private ...
|
|
private:
|
|
//
|
|
// Props ...
|
|
|
|
/**
|
|
* Initial Required Indicators Helper ...
|
|
*/
|
|
void InitialHelpers()
|
|
{
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
// Short ...
|
|
ENUM_X_PERIOD_METHOD scMethod = X_PERIOD_AUTO; // How to Find Period
|
|
ENUM_TIMEFRAMES scPeriod = NULL; // Time Period
|
|
|
|
//
|
|
// Medium ...
|
|
ENUM_X_PERIOD_METHOD mcMethod = X_PERIOD_AUTO; // How to Find Period
|
|
ENUM_TIMEFRAMES mcPeriod = NULL; // Time Period
|
|
|
|
//
|
|
// Long ...
|
|
ENUM_X_PERIOD_METHOD lcMethod = X_PERIOD_AUTO; // How to Find Period
|
|
ENUM_TIMEFRAMES lcPeriod = NULL; // Time Period
|
|
|
|
//
|
|
// Hind ...
|
|
ENUM_X_PERIOD_METHOD hcMethod = X_PERIOD_AUTO; // How to Find Period
|
|
ENUM_TIMEFRAMES hcPeriod = NULL; // Time Period
|
|
|
|
//
|
|
// XPV ...
|
|
X121Inputs x121Inputs;
|
|
|
|
//
|
|
x121Inputs.Default();
|
|
|
|
//
|
|
x121Inputs.scMethod = scMethod;
|
|
x121Inputs.scPeriod = scPeriod;
|
|
x121Inputs.mcMethod = mcMethod;
|
|
x121Inputs.mcPeriod = mcPeriod;
|
|
x121Inputs.lcMethod = lcMethod;
|
|
x121Inputs.lcPeriod = lcPeriod;
|
|
x121Inputs.hcMethod = hcMethod;
|
|
x121Inputs.hcPeriod = hcPeriod;
|
|
|
|
//
|
|
x121Inputs.showFibo2Levels = false;
|
|
x121Inputs.showFibo3Levels = true;
|
|
x121Inputs.showFibo4Levels = false;
|
|
|
|
//
|
|
// Initialize Cycle Helpers ...
|
|
|
|
//
|
|
mTriggerCycleHelper = new XC121SMCCycleHelper();
|
|
mTriggerCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_M1,
|
|
x121Inputs //
|
|
);
|
|
|
|
//
|
|
mDecisionCycleHelper = new XC121SMCCycleHelper();
|
|
mDecisionCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_M5,
|
|
x121Inputs //
|
|
);
|
|
|
|
//
|
|
mAnalyseCycleHelper = new XC121SMCCycleHelper();
|
|
mAnalyseCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_M15,
|
|
x121Inputs //
|
|
);
|
|
|
|
//
|
|
mVerificationCycleHelper = new XC121SMCCycleHelper();
|
|
mVerificationCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_M30,
|
|
x121Inputs //
|
|
);
|
|
|
|
//
|
|
mConsolidationCycleHelper = new XC121SMCCycleHelper();
|
|
mConsolidationCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_H1,
|
|
x121Inputs //
|
|
);
|
|
|
|
//
|
|
mVisionCycleHelper = new XC121SMCCycleHelper();
|
|
mVisionCycleHelper.Init(
|
|
symbol,
|
|
PERIOD_H4,
|
|
x121Inputs //
|
|
);
|
|
}
|
|
|
|
//
|
|
// SL Selector Methods ...
|
|
|
|
/**
|
|
* Select Specified Type of Stop Loss ...
|
|
*
|
|
* @param conditions: X121SMCStrategyConditions instance Reference ...
|
|
* @param forDir: ENUM_X_DIRECTION member, Signal Direction ...
|
|
* @param type: ENUM_X_121_SMC_SL_TYPES member, Specified Required SL Type ...
|
|
*
|
|
* @return ( double )
|
|
*/
|
|
double SelectSL(
|
|
X121SMCStrategyConditions &conditions,
|
|
ENUM_X_DIRECTION forDir,
|
|
ENUM_X_121_SMC_SL_TYPES type //
|
|
)
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
bool isValid =
|
|
//
|
|
HasDirection(forDir) &&
|
|
conditions.IsValid() &&
|
|
type != X_121_SMC_SL_TYPE_NONE
|
|
//
|
|
;
|
|
if (!isValid)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL zBar;
|
|
bool isInited = zBar.Init(
|
|
symbol,
|
|
period,
|
|
0 //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isBullish = IsBullish(forDir);
|
|
|
|
//
|
|
if (type == X_121_SMC_SL_TYPE_FIBO_LEVEL_3)
|
|
{
|
|
result = conditions.triggerConditions.x121Conditions.fl3Buffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_FIBO_LEVEL_1_5)
|
|
{
|
|
//
|
|
result =
|
|
isBullish
|
|
? conditions.triggerConditions.x121Conditions.fl1Buffer[0]
|
|
: conditions.triggerConditions.x121Conditions.fl5Buffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_DON_CLOSE_BOX)
|
|
{
|
|
//
|
|
result =
|
|
isBullish
|
|
? conditions.triggerConditions.x121Conditions.donCloseLowerBuffer[0]
|
|
: conditions.triggerConditions.x121Conditions.donCloseUpperBuffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_SWING)
|
|
{
|
|
//
|
|
int swingLowsCount = conditions.triggerConditions.state.CountSwingLows();
|
|
int swingHighsCount = conditions.triggerConditions.state.CountSwingHighs();
|
|
result =
|
|
isBullish
|
|
? conditions.triggerConditions.state.swingLows[swingLowsCount - 1].GetValue()
|
|
: conditions.triggerConditions.state.swingHighs[swingHighsCount - 1].GetValue();
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_REJECTION)
|
|
{
|
|
//
|
|
result =
|
|
isBullish
|
|
? conditions.triggerConditions.state.bullishRejectionBars[conditions.triggerConditions.state.CountBullishRejectionBars() - 1].Lower()
|
|
: conditions.triggerConditions.state.bearishRejectionBars[conditions.triggerConditions.state.CountBearishRejectionBars() - 1].Upper();
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_MOMENTUM)
|
|
{
|
|
//
|
|
result =
|
|
isBullish
|
|
? conditions.triggerConditions.state.bullishMomentumBars[conditions.triggerConditions.state.CountBullishMomentumBars() - 1].Lower()
|
|
: conditions.triggerConditions.state.bearishMomentumBars[conditions.triggerConditions.state.CountBearishMomentumBars() - 1].Upper();
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_VWAP_FAST)
|
|
{
|
|
result = conditions.triggerConditions.x121Conditions.vwapFastBuffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_VWAP_MID)
|
|
{
|
|
result = conditions.triggerConditions.x121Conditions.vwapMidBuffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_VWAP_SLOW)
|
|
{
|
|
result = conditions.triggerConditions.x121Conditions.vwapSlowBuffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_CURRENT_SAR)
|
|
{
|
|
result = conditions.triggerConditions.x121Conditions.sarBuffer[0];
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_TENKAN_SEN)
|
|
{
|
|
//
|
|
double hh = zBar.FindHighest(
|
|
9,
|
|
MODE_HIGH //
|
|
);
|
|
double ll = zBar.FindLowest(
|
|
9,
|
|
MODE_LOW //
|
|
);
|
|
double mid = (hh - ll) / 2;
|
|
result = isBullish
|
|
? ll - mid
|
|
: hh + mid;
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_CURRENT_SAR_BOX ||
|
|
type == X_121_SMC_SL_TYPE_LAST_SAR_CHANGED_BAR ||
|
|
type == X_121_SMC_SL_TYPE_LAST_DIRECTIONAL_SAR)
|
|
{
|
|
//
|
|
XOHCL cSarChangeBar;
|
|
XOHCL pSarChangeBar;
|
|
XValueChange cSarChange; // Current Sar Change (IsDirect) ...
|
|
XValueChange pSarChange; // Prev Sar Change (Direct) ...
|
|
XValueChange sarChanges[];
|
|
int sarChangesCount = mTriggerCycleHelper
|
|
.FillSarChanges(sarChanges);
|
|
if (!IsValidSize(sarChangesCount) || sarChangesCount < 2)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
//
|
|
cSarChange = sarChanges[sarChangesCount - 1];
|
|
pSarChange = sarChanges[sarChangesCount - 2];
|
|
|
|
//
|
|
bool isFilled = cSarChange.FillBar(
|
|
cSarChangeBar,
|
|
symbol,
|
|
period //
|
|
);
|
|
if (!isFilled)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
isFilled = pSarChange.FillBar(
|
|
pSarChangeBar,
|
|
symbol,
|
|
period //
|
|
);
|
|
if (!isFilled)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
if (type == X_121_SMC_SL_TYPE_LAST_SAR_CHANGED_BAR)
|
|
{
|
|
//
|
|
result = isBullish
|
|
? pSarChangeBar.low
|
|
: pSarChangeBar.high;
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_CURRENT_SAR_BOX)
|
|
{
|
|
//
|
|
result =
|
|
isBullish
|
|
? zBar.FindLowest(
|
|
MathAbs(cSarChangeBar.Index() - 1),
|
|
MODE_LOW //
|
|
)
|
|
: zBar.FindHighest(
|
|
MathAbs(cSarChangeBar.Index() - 1),
|
|
MODE_HIGH //
|
|
);
|
|
}
|
|
else if (type == X_121_SMC_SL_TYPE_LAST_DIRECTIONAL_SAR)
|
|
{
|
|
//
|
|
XOHCL prevBar;
|
|
bool isInited = cSarChangeBar.GetPreviousBar(prevBar);
|
|
if (!isInited)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = isBullish
|
|
? prevBar.low
|
|
: prevBar.high;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Drawing Functions ...
|
|
|
|
/**
|
|
* Custom Drawing State ...
|
|
*
|
|
* @param state: XPOIState instance reference, Specified Which state to Draw ...
|
|
* @param forceDrawSamePeriod: Boolean ...
|
|
*/
|
|
void CustomStateDrawing(
|
|
XPOIState &state,
|
|
bool filterByPrice = false,
|
|
bool forceDrawSamePeriod = false,
|
|
ENUM_X_DIRECTION forDir = X_DIRECTION_NONE,
|
|
//
|
|
// Ignores List ...
|
|
bool ignoreSwingHighs = false,
|
|
bool ignoreSwingLows = false,
|
|
bool ignoreSupportZones = false,
|
|
bool ignoreResistanceZones = false,
|
|
bool ignoreSupplyZones = false,
|
|
bool ignoreDemandZones = false,
|
|
bool ignoreBullishOrderBlocks = false,
|
|
bool ignoreBearishOrderBlocks = false,
|
|
bool ignoreBullishFairValueGaps = false,
|
|
bool ignoreBearishFairValueGaps = false,
|
|
bool ignoreBullishRejectionBars = false,
|
|
bool ignoreBearishRejectionBars = false,
|
|
bool ignoreBullishMomentumBars = false,
|
|
bool ignoreBearishMomentumBars = false //
|
|
)
|
|
{
|
|
//
|
|
XPOIState tmpState = state;
|
|
|
|
//
|
|
if (forceDrawSamePeriod)
|
|
{
|
|
//
|
|
int count = 0;
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
count = state.CountSwingHighs();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSwing iSwing = state.swingHighs[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iSwing.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.swingHighs,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountSwingLows();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSwing iSwing = state.swingLows[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iSwing.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.swingLows,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBullishMomentumBars();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCMomentumBar iMomentum = state.bullishMomentumBars[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iMomentum.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bullishMomentumBars,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBearishMomentumBars();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCMomentumBar iMomentum = state.bearishMomentumBars[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iMomentum.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bearishMomentumBars,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBullishRejectionBars();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCRejectionBar iRejection = state.bullishRejectionBars[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iRejection.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bullishRejectionBars,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBearishRejectionBars();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCRejectionBar iRejection = state.bearishRejectionBars[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iRejection.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bearishRejectionBars,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountSupportZones();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSupportZone iZone = state.supportZones[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.supportZones,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountResistanceZones();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCResistanceZone iZone = state.resistanceZones[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.resistanceZones,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountSupplyZones();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSupplyZone iZone = state.supplyZones[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.supplyZones,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountDemandZones();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCDemandZone iZone = state.demandZones[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.demandZones,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBullishOrderBlocks();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCOrderBlock iZone = state.bullishOrderBlocks[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bullishOrderBlocks,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBearishOrderBlocks();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCOrderBlock iZone = state.bearishOrderBlocks[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bearishOrderBlocks,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBullishFairValueGaps();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCFVG iZone = state.bullishFairValueGaps[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillStartBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bullishFairValueGaps,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
count = state.CountBearishFairValueGaps();
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCFVG iZone = state.bearishFairValueGaps[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isFilled = iZone.FillStartBar(iBar);
|
|
if (!isFilled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isSamePeriod = iBar.period == period;
|
|
if (!isSamePeriod)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
tmpState.bearishFairValueGaps,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
}
|
|
|
|
//
|
|
if (filterByPrice)
|
|
{
|
|
//
|
|
string symbol = GetSymbol();
|
|
ENUM_TIMEFRAMES period = GetPeriod();
|
|
|
|
//
|
|
XOHCL bar;
|
|
bool isInited = bar.Init(
|
|
symbol,
|
|
period,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
if (isInited)
|
|
{
|
|
//
|
|
// Support Zones ...
|
|
int supportZonesCount = ArraySize(tmpState.supportZones);
|
|
if (IsValidSize(supportZonesCount))
|
|
{
|
|
//
|
|
XCSupportZone *supports[];
|
|
for (int i = 0; i < supportZonesCount; i++)
|
|
{
|
|
//
|
|
XCSupportZone *iZone = tmpState.supportZones[i];
|
|
|
|
//
|
|
bool isValid =
|
|
//
|
|
(bar.low < iZone.Upper() &&
|
|
bar.high > iZone.Upper()) ||
|
|
(bar.high > iZone.Lower() &&
|
|
bar.low < iZone.Lower()) ||
|
|
(bar.low > iZone.Lower() &&
|
|
bar.high < iZone.Upper())
|
|
//
|
|
;
|
|
if (isValid)
|
|
{
|
|
Add(
|
|
iZone,
|
|
supports //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpState.supportZones);
|
|
Copy(
|
|
supports,
|
|
tmpState.supportZones //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Resistance Zones ...
|
|
int resistanceZonesCount = ArraySize(tmpState.resistanceZones);
|
|
if (IsValidSize(resistanceZonesCount))
|
|
{
|
|
//
|
|
XCResistanceZone *resistances[];
|
|
for (int i = 0; i < resistanceZonesCount; i++)
|
|
{
|
|
//
|
|
XCResistanceZone *iZone = tmpState.resistanceZones[i];
|
|
|
|
//
|
|
bool isValid =
|
|
//
|
|
(bar.low < iZone.Upper() &&
|
|
bar.high > iZone.Upper()) ||
|
|
(bar.high > iZone.Lower() &&
|
|
bar.low < iZone.Lower()) ||
|
|
(bar.low > iZone.Lower() &&
|
|
bar.high < iZone.Upper())
|
|
//
|
|
;
|
|
if (isValid)
|
|
{
|
|
Add(
|
|
iZone,
|
|
resistances //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpState.resistanceZones);
|
|
Copy(
|
|
resistances,
|
|
tmpState.resistanceZones //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Supply Zones ...
|
|
int supplyZonesCount = ArraySize(tmpState.supplyZones);
|
|
if (IsValidSize(supplyZonesCount))
|
|
{
|
|
//
|
|
XCSupplyZone *supplies[];
|
|
for (int i = 0; i < supplyZonesCount; i++)
|
|
{
|
|
//
|
|
XCSupplyZone *iZone = tmpState.supplyZones[i];
|
|
|
|
//
|
|
bool isValid =
|
|
//
|
|
(bar.low < iZone.Upper() &&
|
|
bar.high > iZone.Upper()) ||
|
|
(bar.high > iZone.Lower() &&
|
|
bar.low < iZone.Lower()) ||
|
|
(bar.low > iZone.Lower() &&
|
|
bar.high < iZone.Upper())
|
|
//
|
|
;
|
|
if (isValid)
|
|
{
|
|
Add(
|
|
iZone,
|
|
supplies //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpState.supplyZones);
|
|
Copy(
|
|
supplies,
|
|
tmpState.supplyZones //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Demand Zones ...
|
|
int demandZonesCount = ArraySize(tmpState.demandZones);
|
|
if (IsValidSize(demandZonesCount))
|
|
{
|
|
//
|
|
XCDemandZone *demands[];
|
|
for (int i = 0; i < demandZonesCount; i++)
|
|
{
|
|
//
|
|
XCDemandZone *iZone = tmpState.demandZones[i];
|
|
|
|
//
|
|
bool isValid =
|
|
//
|
|
(bar.low < iZone.Upper() &&
|
|
bar.high > iZone.Upper()) ||
|
|
(bar.high > iZone.Lower() &&
|
|
bar.low < iZone.Lower()) ||
|
|
(bar.low > iZone.Lower() &&
|
|
bar.high < iZone.Upper())
|
|
//
|
|
;
|
|
if (isValid)
|
|
{
|
|
Add(
|
|
iZone,
|
|
demands //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpState.demandZones);
|
|
Copy(
|
|
demands,
|
|
tmpState.demandZones //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Bullish Order Blocks ...
|
|
int bullishOrderBlocksCount = ArraySize(tmpState.bullishOrderBlocks);
|
|
if (IsValidSize(bullishOrderBlocksCount))
|
|
{
|
|
//
|
|
XCOrderBlock *obs[];
|
|
for (int i = 0; i < bullishOrderBlocksCount; i++)
|
|
{
|
|
//
|
|
XCOrderBlock *iZone = tmpState.bullishOrderBlocks[i];
|
|
|
|
//
|
|
bool isValid =
|
|
//
|
|
(bar.low < iZone.Upper() &&
|
|
bar.high > iZone.Upper()) ||
|
|
(bar.high > iZone.Lower() &&
|
|
bar.low < iZone.Lower()) ||
|
|
(bar.low > iZone.Lower() &&
|
|
bar.high < iZone.Upper())
|
|
//
|
|
;
|
|
if (isValid)
|
|
{
|
|
Add(
|
|
iZone,
|
|
obs //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpState.bullishOrderBlocks);
|
|
Copy(
|
|
obs,
|
|
tmpState.bullishOrderBlocks //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Bearish Order Blocks ...
|
|
int bearishOrderBlocksCount = ArraySize(tmpState.bearishOrderBlocks);
|
|
if (IsValidSize(bearishOrderBlocksCount))
|
|
{
|
|
//
|
|
XCOrderBlock *obs[];
|
|
for (int i = 0; i < bearishOrderBlocksCount; i++)
|
|
{
|
|
//
|
|
XCOrderBlock *iZone = tmpState.bearishOrderBlocks[i];
|
|
|
|
//
|
|
bool isValid =
|
|
//
|
|
(bar.low < iZone.Upper() &&
|
|
bar.high > iZone.Upper()) ||
|
|
(bar.high > iZone.Lower() &&
|
|
bar.low < iZone.Lower()) ||
|
|
(bar.low > iZone.Lower() &&
|
|
bar.high < iZone.Upper())
|
|
//
|
|
;
|
|
if (isValid)
|
|
{
|
|
Add(
|
|
iZone,
|
|
obs //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpState.bearishOrderBlocks);
|
|
Copy(
|
|
obs,
|
|
tmpState.bearishOrderBlocks //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Bullish Fair Value Gaps ...
|
|
int bullishFairValueGapsCount = ArraySize(tmpState.bullishFairValueGaps);
|
|
if (IsValidSize(bullishFairValueGapsCount))
|
|
{
|
|
//
|
|
XCFVG *obs[];
|
|
for (int i = 0; i < bullishFairValueGapsCount; i++)
|
|
{
|
|
//
|
|
XCFVG *iZone = tmpState.bullishFairValueGaps[i];
|
|
|
|
//
|
|
bool isValid =
|
|
//
|
|
(bar.low < iZone.Upper() &&
|
|
bar.high > iZone.Upper()) ||
|
|
(bar.high > iZone.Lower() &&
|
|
bar.low < iZone.Lower()) ||
|
|
(bar.low > iZone.Lower() &&
|
|
bar.high < iZone.Upper())
|
|
//
|
|
;
|
|
if (isValid)
|
|
{
|
|
Add(
|
|
iZone,
|
|
obs //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpState.bullishFairValueGaps);
|
|
Copy(
|
|
obs,
|
|
tmpState.bullishFairValueGaps //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Bearish Fair Value Gaps ...
|
|
int bearishFairValueGapsCount = ArraySize(tmpState.bearishFairValueGaps);
|
|
if (IsValidSize(bearishFairValueGapsCount))
|
|
{
|
|
//
|
|
XCFVG *obs[];
|
|
for (int i = 0; i < bearishFairValueGapsCount; i++)
|
|
{
|
|
//
|
|
XCFVG *iZone = tmpState.bearishFairValueGaps[i];
|
|
|
|
//
|
|
bool isValid =
|
|
//
|
|
(bar.low < iZone.Upper() &&
|
|
bar.high > iZone.Upper()) ||
|
|
(bar.high > iZone.Lower() &&
|
|
bar.low < iZone.Lower()) ||
|
|
(bar.low > iZone.Lower() &&
|
|
bar.high < iZone.Upper())
|
|
//
|
|
;
|
|
if (isValid)
|
|
{
|
|
Add(
|
|
iZone,
|
|
obs //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpState.bearishFairValueGaps);
|
|
Copy(
|
|
obs,
|
|
tmpState.bearishFairValueGaps //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
bool drawSwingHighs = true;
|
|
bool drawSwingLows = true;
|
|
bool drawSupportZones = true;
|
|
bool drawResistanceZones = true;
|
|
bool drawSupplyZones = true;
|
|
bool drawDemandZones = true;
|
|
bool drawBullishOrderBlocks = true;
|
|
bool drawBearishOrderBlocks = true;
|
|
bool drawBullishFairValueGaps = true;
|
|
bool drawBearishFairValueGaps = true;
|
|
bool drawBullishRejectionBars = true;
|
|
bool drawBearishRejectionBars = true;
|
|
bool drawBullishMomentumBars = true;
|
|
bool drawBearishMomentumBars = true;
|
|
|
|
//
|
|
// Change Drawing Specs Conditions based on
|
|
// Provided Direction ...
|
|
if (forDir == X_DIRECTION_BULLISH)
|
|
{
|
|
//
|
|
drawSwingLows = true;
|
|
drawDemandZones = true;
|
|
drawSupportZones = true;
|
|
drawBullishOrderBlocks = true;
|
|
drawBullishFairValueGaps = true;
|
|
drawBullishRejectionBars = true;
|
|
drawBullishMomentumBars = true;
|
|
|
|
//
|
|
drawSwingHighs = false;
|
|
drawSupplyZones = false;
|
|
drawResistanceZones = false;
|
|
drawBearishOrderBlocks = false;
|
|
drawBearishFairValueGaps = false;
|
|
drawBearishRejectionBars = false;
|
|
drawBearishMomentumBars = false;
|
|
}
|
|
else if (forDir == X_DIRECTION_BEARISH)
|
|
{
|
|
//
|
|
drawSwingLows = false;
|
|
drawDemandZones = false;
|
|
drawSupportZones = false;
|
|
drawBullishOrderBlocks = false;
|
|
drawBullishFairValueGaps = false;
|
|
drawBullishRejectionBars = false;
|
|
drawBullishMomentumBars = false;
|
|
|
|
//
|
|
drawSwingHighs = true;
|
|
drawSupplyZones = true;
|
|
drawResistanceZones = true;
|
|
drawBearishOrderBlocks = true;
|
|
drawBearishFairValueGaps = true;
|
|
drawBearishRejectionBars = true;
|
|
drawBearishMomentumBars = true;
|
|
}
|
|
|
|
//
|
|
// Apply Ignore List ...
|
|
|
|
//
|
|
if (ignoreSwingHighs)
|
|
{
|
|
drawSwingHighs = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreSwingLows)
|
|
{
|
|
drawSwingLows = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreSupportZones)
|
|
{
|
|
drawSupportZones = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreResistanceZones)
|
|
{
|
|
drawResistanceZones = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreSupplyZones)
|
|
{
|
|
drawSupplyZones = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreDemandZones)
|
|
{
|
|
drawDemandZones = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBullishOrderBlocks)
|
|
{
|
|
drawBullishOrderBlocks = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBearishOrderBlocks)
|
|
{
|
|
drawBearishOrderBlocks = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBullishFairValueGaps)
|
|
{
|
|
drawBullishFairValueGaps = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBearishFairValueGaps)
|
|
{
|
|
drawBearishFairValueGaps = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBullishRejectionBars)
|
|
{
|
|
drawBullishRejectionBars = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBearishRejectionBars)
|
|
{
|
|
drawBearishRejectionBars = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBullishMomentumBars)
|
|
{
|
|
drawBullishMomentumBars = false;
|
|
}
|
|
|
|
//
|
|
if (ignoreBearishMomentumBars)
|
|
{
|
|
drawBearishMomentumBars = false;
|
|
}
|
|
|
|
//
|
|
DrawState(
|
|
tmpState, // State ...
|
|
true, // Update To of all Drawings Till now ...
|
|
drawSwingHighs, // Draw SwingHighs ..
|
|
drawSwingLows, // Draw SwingLows ..
|
|
drawSupportZones, // Draw SupportZones ..
|
|
drawResistanceZones, // Draw ResistanceZones ..
|
|
drawSupplyZones, // Draw SupplyZones ..
|
|
drawDemandZones, // Draw DemandZones ..
|
|
drawBullishOrderBlocks, // Draw BullishOrderBlocks ..
|
|
drawBearishOrderBlocks, // Draw BearishOrderBlocks ..
|
|
drawBullishFairValueGaps, // Draw BullishFairValueGaps ..
|
|
drawBearishFairValueGaps, // Draw BearishFairValueGaps ..
|
|
drawBullishRejectionBars, // Draw BullishRejectionBars ..
|
|
drawBearishRejectionBars, // Draw BearishRejectionBars ..
|
|
drawBullishMomentumBars, // Draw BullishMomentumBars ..
|
|
drawBearishMomentumBars, // Draw BearishMomentumBars ..
|
|
true // Draw Ticks Zone ...
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Draw Specific Pivot ...
|
|
*
|
|
* @param pivot: XPVPivot instance Reference ...
|
|
* @param drawState: Boolean ...
|
|
* @param filterByPrice: Boolean ...
|
|
* @param ignoreSwingHighs: Boolean ...
|
|
* @param ignoreSwingLows: Boolean ...
|
|
* @param ignoreSupportZones: Boolean ...
|
|
* @param ignoreResistanceZones: Boolean ...
|
|
* @param ignoreSupplyZones: Boolean ...
|
|
* @param ignoreDemandZones: Boolean ...
|
|
* @param ignoreBullishOrderBlocks: Boolean ...
|
|
* @param ignoreBearishOrderBlocks: Boolean ...
|
|
* @param ignoreBullishFairValueGaps: Boolean ...
|
|
* @param ignoreBearishFairValueGaps: Boolean ...
|
|
* @param ignoreBullishRejectionBars: Boolean ...
|
|
* @param ignoreBearishRejectionBars: Boolean ...
|
|
* @param ignoreBullishMomentumBars: Boolean ...
|
|
* @param ignoreBearishMomentumBars: Boolean ...
|
|
*/
|
|
void DrawPivot(
|
|
XPVPivot &pivot,
|
|
bool drawState = true,
|
|
bool filterByPrice = false,
|
|
bool ignoreSwingHighs = false,
|
|
bool ignoreSwingLows = false,
|
|
bool ignoreSupportZones = false,
|
|
bool ignoreResistanceZones = false,
|
|
bool ignoreSupplyZones = false,
|
|
bool ignoreDemandZones = false,
|
|
bool ignoreBullishOrderBlocks = false,
|
|
bool ignoreBearishOrderBlocks = false,
|
|
bool ignoreBullishFairValueGaps = false,
|
|
bool ignoreBearishFairValueGaps = false,
|
|
bool ignoreBullishRejectionBars = false,
|
|
bool ignoreBearishRejectionBars = false,
|
|
bool ignoreBullishMomentumBars = false,
|
|
bool ignoreBearishMomentumBars = false //
|
|
)
|
|
{
|
|
//
|
|
if (!pivot.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Draw Pivot it self ...
|
|
XCXPVPivotObject *iPivotObj;
|
|
iPivotObj = new XCXPVPivotObject();
|
|
bool isCreated = iPivotObj.Create(
|
|
mPOIDrawer.ChartIdentification(),
|
|
mPOIDrawer.SubWindowIdentification(),
|
|
pivot //
|
|
);
|
|
if (!isCreated)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
color clrPivotColor = pivot.IsPeak()
|
|
? clrAqua
|
|
: clrMagenta;
|
|
iPivotObj.PivotColor(clrPivotColor);
|
|
iPivotObj.PivotWidth(2);
|
|
|
|
//
|
|
AddObjectIfNotExists(iPivotObj);
|
|
|
|
//
|
|
if (!drawState)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
if (!pivot.state.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
CustomStateDrawing(
|
|
pivot.state,
|
|
filterByPrice,
|
|
false, // forceDrawSamePeriod
|
|
X_DIRECTION_NONE, // forDir
|
|
ignoreSwingHighs,
|
|
ignoreSwingLows,
|
|
ignoreSupportZones,
|
|
ignoreResistanceZones,
|
|
ignoreSupplyZones,
|
|
ignoreDemandZones,
|
|
ignoreBullishOrderBlocks,
|
|
ignoreBearishOrderBlocks,
|
|
ignoreBullishFairValueGaps,
|
|
ignoreBearishFairValueGaps,
|
|
ignoreBullishRejectionBars,
|
|
ignoreBearishRejectionBars,
|
|
ignoreBullishMomentumBars,
|
|
ignoreBearishMomentumBars //
|
|
);
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
// |