1729 lines
37 KiB
Plaintext
1729 lines
37 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 X121 SMC Signal Class
|
|
// -------------------------------------------------
|
|
// Name: XOBS
|
|
// Description: provide all Signalling functions ...
|
|
//
|
|
//
|
|
// 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 "../../Libraries/x-trade.lib"
|
|
#include "../Classes/x-121.smc.market.cycle.helper.class.mq5"
|
|
#include "../Libraries/x-121.smc.guard.lib.mq5"
|
|
#include "../Libraries/x-121.smc.lib.mq5"
|
|
|
|
//
|
|
// Definitions ...
|
|
struct X121SMCStrategyXOBSSignalConditions
|
|
{
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
string symbol;
|
|
ENUM_TIMEFRAMES period;
|
|
|
|
//
|
|
double sl;
|
|
double target;
|
|
ENUM_X_DIRECTION dir;
|
|
ENUM_X_POSITION_TYPES type;
|
|
|
|
//
|
|
// Setup Props ...
|
|
|
|
//
|
|
datetime setupTime;
|
|
datetime triggerTime;
|
|
|
|
//
|
|
double pivot;
|
|
double point;
|
|
|
|
//
|
|
XCOrderBlock *validBullishOBs[];
|
|
XCOrderBlock *validBearishOBs[];
|
|
|
|
//
|
|
XCOrderBlock *youngestBullishOB;
|
|
XCOrderBlock *youngestBearishOB;
|
|
|
|
//
|
|
XSwingPoint swings[];
|
|
XCOrderBlock *insideOB;
|
|
|
|
//
|
|
// Constructor ...
|
|
X121SMCStrategyXOBSSignalConditions()
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Cleaning Up ...
|
|
*/
|
|
void Clean()
|
|
{
|
|
//
|
|
sl = 0;
|
|
target = 0;
|
|
|
|
//
|
|
dir = X_DIRECTION_NONE;
|
|
type = X_POSITION_TYPE_NONE;
|
|
|
|
//
|
|
symbol = NULL;
|
|
period = NULL;
|
|
setupTime = NULL;
|
|
triggerTime = NULL;
|
|
|
|
//
|
|
ExtensionClean();
|
|
|
|
//
|
|
ZeroMemory(this);
|
|
}
|
|
|
|
/**
|
|
* Check Condition is Setting Up ...
|
|
*
|
|
* @param dir: ENUM_X_DIRECTION member, Setting Up Direction ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsSetuped()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid(setupTime) &&
|
|
HasDirection(dir);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Calculate Setup Age ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int GetSetupAge()
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
if (!IsSetuped())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = (int)(TimeCurrent() - setupTime) / PeriodSeconds(period);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Detect How we Can Trigger Signal ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool CanTrigger()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
sl > 0 &&
|
|
IsValid(symbol) &&
|
|
IsValid(period) &&
|
|
IsValid(triggerTime) &&
|
|
type != X_POSITION_TYPE_ALL &&
|
|
type != X_POSITION_TYPE_NONE
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Extensions ...
|
|
|
|
/**
|
|
* Clean Additional Properties ...
|
|
*/
|
|
void ExtensionClean()
|
|
{
|
|
//
|
|
pivot = 0;
|
|
point = 0;
|
|
|
|
//
|
|
Clean(swings);
|
|
Clean(validBullishOBs);
|
|
Clean(validBearishOBs);
|
|
|
|
//
|
|
insideOB = NULL;
|
|
youngestBullishOB = NULL;
|
|
youngestBearishOB = NULL;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
bool HasInsideOB()
|
|
{
|
|
return insideOB != NULL &&
|
|
insideOB.IsValid();
|
|
}
|
|
|
|
//
|
|
bool HasValidBullishOBs()
|
|
{
|
|
return IsValidSize(CountValidBullishOBs());
|
|
}
|
|
|
|
//
|
|
int CountValidBullishOBs()
|
|
{
|
|
return ArraySize(validBullishOBs);
|
|
}
|
|
|
|
//
|
|
bool HasValidBearishOBs()
|
|
{
|
|
return IsValidSize(CountValidBearishOBs());
|
|
}
|
|
|
|
//
|
|
int CountValidBearishOBs()
|
|
{
|
|
return ArraySize(validBearishOBs);
|
|
}
|
|
|
|
//
|
|
bool HasYoungestBullishOB()
|
|
{
|
|
return youngestBullishOB != NULL &&
|
|
youngestBullishOB.IsValid();
|
|
}
|
|
|
|
//
|
|
bool HasYoungestBearishOB()
|
|
{
|
|
return youngestBearishOB != NULL &&
|
|
youngestBearishOB.IsValid();
|
|
}
|
|
|
|
//
|
|
bool HasOrderFlow(ENUM_X_DIRECTION &orderFlowDir)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
orderFlowDir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
bool hasValidBullishOBs = HasValidBullishOBs();
|
|
bool hasValidBearishOBs = HasValidBearishOBs();
|
|
int validBullishOBsCount = CountValidBullishOBs();
|
|
int validBearishOBsCount = CountValidBearishOBs();
|
|
bool hasYoungestBullishOB = HasYoungestBullishOB();
|
|
bool hasYoungestBearishOB = HasYoungestBearishOB();
|
|
|
|
//
|
|
bool hasBullish =
|
|
hasYoungestBullishOB &&
|
|
hasValidBullishOBs &&
|
|
validBullishOBsCount == 2;
|
|
|
|
//
|
|
bool hasBearish =
|
|
hasYoungestBearishOB &&
|
|
hasValidBearishOBs &&
|
|
validBearishOBsCount == 2;
|
|
|
|
//
|
|
result = (hasBullish &&
|
|
!hasBearish) ||
|
|
(!hasBullish &&
|
|
hasBearish);
|
|
if (result)
|
|
{
|
|
//
|
|
orderFlowDir =
|
|
hasBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int CountSwings()
|
|
{
|
|
return ArraySize(swings);
|
|
}
|
|
|
|
//
|
|
bool HasSwings()
|
|
{
|
|
return IsValidSize(CountSwings()) &&
|
|
CountSwings() >= 2;
|
|
}
|
|
|
|
//
|
|
ENUM_X_SWING_TYPE GetSwingType()
|
|
{
|
|
//
|
|
ENUM_X_SWING_TYPE result = X_NO_SWING;
|
|
|
|
//
|
|
if (!HasSwings())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = swings[0].type;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Signaller Data Sources ...
|
|
X121SMCStrategyXOBSSignalConditions mX121SMCXOBSConditions;
|
|
X121SMCStrategyXOBSSignalConditions mX121SMCXOBSConditionsCollection[];
|
|
CArrayObj mX121SMCXOBSObjects;
|
|
|
|
//
|
|
// Extension Functions ...
|
|
|
|
//
|
|
// Detect Setup Conditions ...
|
|
bool DetectX121SMCXOBSSignalSetup(
|
|
string _symbol,
|
|
ENUM_TIMEFRAMES _period,
|
|
//
|
|
X121SMCStrategyXOBSSignalConditions &conditions,
|
|
//
|
|
XC121SMCCycleHelper *triggerCycleHelper,
|
|
XC121SMCCycleHelper *decisionCycleHelper,
|
|
XC121SMCCycleHelper *analyseCycleHelper,
|
|
XC121SMCCycleHelper *verificationCycleHelper,
|
|
XC121SMCCycleHelper *consolidationCycleHelper,
|
|
XC121SMCCycleHelper *visionCycleHelper,
|
|
//
|
|
int resetAfterUnActedZoneInMinutes = 120
|
|
//
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
int loopback = 10;
|
|
|
|
//
|
|
string symbol = _symbol;
|
|
ENUM_TIMEFRAMES period = _period;
|
|
|
|
//
|
|
conditions.symbol = symbol;
|
|
conditions.period = period;
|
|
|
|
//
|
|
double ask = GetAsk(symbol);
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
double points = GetPoints(symbol);
|
|
|
|
//
|
|
// Cycles Conditions ...
|
|
|
|
//
|
|
// Trigger ...
|
|
ENUM_XPOI_EVENTS triggerPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS triggerCycleEvents[];
|
|
X121SMCCycleConditions triggerConditions;
|
|
result = triggerCycleHelper.GetConditions(
|
|
triggerCycleEvents,
|
|
triggerPoiEvents,
|
|
triggerConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Decision ...
|
|
ENUM_XPOI_EVENTS decisionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS decisionCycleEvents[];
|
|
X121SMCCycleConditions decisionConditions;
|
|
result = decisionCycleHelper.GetConditions(
|
|
decisionCycleEvents,
|
|
decisionPoiEvents,
|
|
decisionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Analyse ...
|
|
ENUM_XPOI_EVENTS analysePoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS analyseCycleEvents[];
|
|
X121SMCCycleConditions analyseConditions;
|
|
result = analyseCycleHelper.GetConditions(
|
|
analyseCycleEvents,
|
|
analysePoiEvents,
|
|
analyseConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Verification ...
|
|
ENUM_XPOI_EVENTS verificationPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS verificationCycleEvents[];
|
|
X121SMCCycleConditions verificationConditions;
|
|
result = verificationCycleHelper.GetConditions(
|
|
verificationCycleEvents,
|
|
verificationPoiEvents,
|
|
verificationConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Consolidation ...
|
|
ENUM_XPOI_EVENTS consolidationPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS consolidationCycleEvents[];
|
|
X121SMCCycleConditions consolidationConditions;
|
|
result = consolidationCycleHelper.GetConditions(
|
|
consolidationCycleEvents,
|
|
consolidationPoiEvents,
|
|
consolidationConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Vision ...
|
|
ENUM_XPOI_EVENTS visionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS visionCycleEvents[];
|
|
X121SMCCycleConditions visionConditions;
|
|
result = visionCycleHelper.GetConditions(
|
|
visionCycleEvents,
|
|
visionPoiEvents,
|
|
visionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cycles POI States ...
|
|
XPOIState triggerState = triggerConditions.state;
|
|
XPOIState decisionState = decisionConditions.state;
|
|
XPOIState analyseState = analyseConditions.state;
|
|
XPOIState verificationState = verificationConditions.state;
|
|
XPOIState consolidationState = consolidationConditions.state;
|
|
XPOIState visionState = visionConditions.state;
|
|
|
|
//
|
|
// Cycle X121Conditions ...
|
|
X121Conditions triggerXConditions = triggerConditions.x121Conditions;
|
|
X121Conditions decisionXConditions = decisionConditions.x121Conditions;
|
|
X121Conditions analyseXConditions = analyseConditions.x121Conditions;
|
|
X121Conditions verificationXConditions = verificationConditions.x121Conditions;
|
|
X121Conditions consolidationXConditions = consolidationConditions.x121Conditions;
|
|
X121Conditions visionXConditions = visionConditions.x121Conditions;
|
|
|
|
//
|
|
// Setup Conditions ...
|
|
mX121SMCXOBSObjects.Clear();
|
|
XCPOIDrawer *drawer = visionCycleHelper.mPOIDrawer;
|
|
|
|
//
|
|
bool hasInsideOB = conditions.HasInsideOB();
|
|
bool hasValidBullishOBs = conditions.HasValidBullishOBs();
|
|
int validBullishOBsCount = conditions.CountValidBullishOBs();
|
|
bool hasValidBearishOBs = conditions.HasValidBearishOBs();
|
|
int validBearishOBsCount = conditions.CountValidBearishOBs();
|
|
bool hasYoungestBullishOB = conditions.HasYoungestBullishOB();
|
|
bool hasYoungestBearishOB = conditions.HasYoungestBearishOB();
|
|
bool hasYoungestOB = hasYoungestBullishOB ||
|
|
hasYoungestBearishOB;
|
|
|
|
//
|
|
ENUM_X_DIRECTION orderFlowDir;
|
|
bool hasOrderFlow = conditions.HasOrderFlow(orderFlowDir);
|
|
bool hasBullishOrderFlow = IsBullish(orderFlowDir);
|
|
bool hasBearishOrderFlow = IsBearish(orderFlowDir);
|
|
|
|
//
|
|
bool isInsideZoneBullish = false;
|
|
bool isPriceInsideYoungestOB = false;
|
|
bool isPriceInsideYoungestBullishOB = false;
|
|
bool isPriceInsideYoungestBearishOB = false;
|
|
ENUM_X_DIRECTION insideOBDir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
bool hasSwings = conditions.HasSwings();
|
|
int swingsCount = conditions.CountSwings();
|
|
ENUM_X_SWING_TYPE swingType = conditions.GetSwingType();
|
|
bool isSwingLow = swingType == X_SWING_LOW;
|
|
|
|
//
|
|
XOHCL decisionZBar;
|
|
XOHCL decisionCBar;
|
|
XOHCL decisionPBar;
|
|
double decisionCBarBullishZoneChechValue = 0;
|
|
double decisionCBarBearishZoneChechValue = 0;
|
|
|
|
//
|
|
result = decisionZBar.Init(
|
|
decisionState.symbol,
|
|
decisionState.period,
|
|
0 //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = decisionZBar
|
|
.GetPreviousBar(decisionCBar);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = decisionCBar
|
|
.GetPreviousBar(decisionPBar);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
decisionCBarBullishZoneChechValue = decisionCBar
|
|
.GetZoneCheckValue(X_DIRECTION_BULLISH);
|
|
decisionCBarBearishZoneChechValue = decisionCBar
|
|
.GetZoneCheckValue(X_DIRECTION_BEARISH);
|
|
|
|
//
|
|
// Valid Ob, is the Un Activated Order Blocks
|
|
int validOBsCount = 0;
|
|
XCOrderBlock *validOBs[];
|
|
bool hasValidOBs = hasValidBullishOBs ||
|
|
hasValidBearishOBs;
|
|
|
|
//
|
|
if (!hasValidOBs)
|
|
{
|
|
//
|
|
int count = 0;
|
|
bool hasOBs = false;
|
|
|
|
//
|
|
XCOrderBlock *obs[];
|
|
|
|
//
|
|
// Check For Bullish ...
|
|
count = consolidationState.CountBullishOrderBlocks();
|
|
hasOBs = consolidationState.HasBullishOrderBlocks();
|
|
if (hasOBs)
|
|
{
|
|
//
|
|
Copy(
|
|
consolidationState.bullishOrderBlocks,
|
|
obs,
|
|
false //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Check For Bearish ...
|
|
count = consolidationState.CountBearishOrderBlocks();
|
|
hasOBs = consolidationState.HasBearishOrderBlocks();
|
|
if (hasOBs)
|
|
{
|
|
//
|
|
Copy(
|
|
consolidationState.bearishOrderBlocks,
|
|
obs,
|
|
false //
|
|
);
|
|
}
|
|
|
|
//
|
|
ExtractUnActivatedOrderBlocks(
|
|
obs,
|
|
validOBs //
|
|
);
|
|
|
|
//
|
|
validOBsCount = ArraySize(validOBs);
|
|
hasValidOBs = IsValidSize(validOBsCount);
|
|
|
|
//
|
|
// Extract Valid Directional Order Blocks ...
|
|
|
|
//
|
|
if (!hasValidBullishOBs)
|
|
{
|
|
//
|
|
validBullishOBsCount = ExtractDirectionalOrderBlocks(
|
|
X_DIRECTION_BULLISH,
|
|
validOBs,
|
|
conditions.validBullishOBs //
|
|
);
|
|
hasValidBullishOBs = IsValidSize(validBullishOBsCount);
|
|
}
|
|
|
|
//
|
|
if (!hasValidBearishOBs)
|
|
{
|
|
//
|
|
validBearishOBsCount = ExtractDirectionalOrderBlocks(
|
|
X_DIRECTION_BEARISH,
|
|
validOBs,
|
|
conditions.validBearishOBs //
|
|
);
|
|
hasValidBearishOBs = IsValidSize(validBearishOBsCount);
|
|
}
|
|
}
|
|
|
|
//
|
|
result = hasValidOBs;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
UpdateTo(validOBs);
|
|
UpdateTo(conditions.validBullishOBs);
|
|
UpdateTo(conditions.validBearishOBs);
|
|
|
|
//
|
|
// Extract Youngest Order Blocks ...
|
|
|
|
//
|
|
if (!hasYoungestBullishOB)
|
|
{
|
|
//
|
|
if (hasValidBullishOBs)
|
|
{
|
|
//
|
|
int idx = GetYoungest(conditions.validBullishOBs);
|
|
hasYoungestBullishOB = IsValidIndex(idx);
|
|
if (hasYoungestBullishOB)
|
|
{
|
|
//
|
|
conditions.youngestBullishOB = conditions.validBullishOBs[idx];
|
|
|
|
//
|
|
int vobIDX = -1;
|
|
bool hasVOB = FindIndex(
|
|
vobIDX,
|
|
conditions.youngestBullishOB,
|
|
validOBs //
|
|
);
|
|
if (hasVOB)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
validOBs,
|
|
vobIDX,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
validOBsCount = ArraySize(validOBs);
|
|
hasValidOBs = IsValidSize(validOBsCount);
|
|
}
|
|
|
|
//
|
|
int bullisVOBIDX = -1;
|
|
bool hasBullishVOB = FindIndex(
|
|
bullisVOBIDX,
|
|
conditions.youngestBullishOB,
|
|
conditions.validBullishOBs //
|
|
);
|
|
if (hasBullishVOB)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
conditions.validBullishOBs,
|
|
bullisVOBIDX,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
validBullishOBsCount = ArraySize(conditions.validBullishOBs);
|
|
hasValidBullishOBs = IsValidSize(validBullishOBsCount);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
if (!hasYoungestBearishOB)
|
|
{
|
|
//
|
|
if (hasValidBearishOBs)
|
|
{
|
|
//
|
|
int idx = GetYoungest(conditions.validBearishOBs);
|
|
hasYoungestBearishOB = IsValidIndex(idx);
|
|
if (hasYoungestBearishOB)
|
|
{
|
|
//
|
|
conditions.youngestBearishOB = conditions.validBearishOBs[idx];
|
|
|
|
//
|
|
int vobIDX = -1;
|
|
bool hasVOB = FindIndex(
|
|
vobIDX,
|
|
conditions.youngestBearishOB,
|
|
validOBs //
|
|
);
|
|
if (hasVOB)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
validOBs,
|
|
vobIDX,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
validOBsCount = ArraySize(validOBs);
|
|
hasValidOBs = IsValidSize(validOBsCount);
|
|
}
|
|
|
|
//
|
|
int bearishVOBIDX = -1;
|
|
bool hasBearishVOB = FindIndex(
|
|
bearishVOBIDX,
|
|
conditions.youngestBearishOB,
|
|
conditions.validBearishOBs //
|
|
);
|
|
if (hasBearishVOB)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
conditions.validBearishOBs,
|
|
bearishVOBIDX,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
validBearishOBsCount = ArraySize(conditions.validBearishOBs);
|
|
hasValidBearishOBs = IsValidSize(validBearishOBsCount);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
hasYoungestOB = hasYoungestBullishOB ||
|
|
hasYoungestBearishOB;
|
|
result = hasYoungestOB;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Sorting Valid Order Blocks based on Yungest ...
|
|
|
|
//
|
|
OrderedSortOrderBlocks(
|
|
conditions.youngestBullishOB,
|
|
conditions.validBullishOBs //
|
|
);
|
|
validBullishOBsCount = ArraySize(conditions.validBullishOBs);
|
|
hasValidBullishOBs = IsValidSize(validBullishOBsCount);
|
|
|
|
//
|
|
OrderedSortOrderBlocks(
|
|
conditions.youngestBearishOB,
|
|
conditions.validBearishOBs //
|
|
);
|
|
validBearishOBsCount = ArraySize(conditions.validBearishOBs);
|
|
hasValidBearishOBs = IsValidSize(validBearishOBsCount);
|
|
|
|
//
|
|
hasValidOBs = hasValidBullishOBs ||
|
|
hasValidBearishOBs;
|
|
result = hasValidOBs;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Extract Order Flow ...
|
|
|
|
//
|
|
hasBullishOrderFlow =
|
|
hasYoungestBullishOB &&
|
|
validBullishOBsCount >= 2;
|
|
|
|
//
|
|
hasBearishOrderFlow =
|
|
hasYoungestBearishOB &&
|
|
validBearishOBsCount >= 2;
|
|
|
|
//
|
|
hasOrderFlow = (hasBullishOrderFlow &&
|
|
!hasBearishOrderFlow) ||
|
|
(!hasBullishOrderFlow &&
|
|
hasBearishOrderFlow);
|
|
result = hasOrderFlow;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Extract Swing Points ...
|
|
|
|
//
|
|
XCOrderBlock *tmpSwings[];
|
|
if (hasBullishOrderFlow)
|
|
{
|
|
//
|
|
Copy(
|
|
conditions.validBullishOBs,
|
|
tmpSwings //
|
|
);
|
|
|
|
//
|
|
Add(
|
|
conditions.youngestBullishOB,
|
|
tmpSwings //
|
|
);
|
|
|
|
//
|
|
isSwingLow = true;
|
|
swingType = X_SWING_LOW;
|
|
swingsCount = ExtractSwingPoints(
|
|
swingType,
|
|
tmpSwings,
|
|
conditions.swings //
|
|
);
|
|
|
|
//
|
|
while (swingsCount > 2)
|
|
{
|
|
//
|
|
double tmpValues[];
|
|
int tmpValuesCount = ExtractSwings(
|
|
conditions.swings,
|
|
tmpValues //
|
|
);
|
|
|
|
//
|
|
int minIDX = -1;
|
|
double min = GetMin(
|
|
tmpValues,
|
|
minIDX,
|
|
0,
|
|
0 //
|
|
);
|
|
if (IsValidIndex(minIDX))
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
conditions.swings,
|
|
minIDX,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
swingsCount = ArraySize(conditions.swings);
|
|
hasSwings = IsValidSize(swingsCount);
|
|
}
|
|
|
|
//
|
|
Clean(tmpValues);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
Copy(
|
|
conditions.validBearishOBs,
|
|
tmpSwings //
|
|
);
|
|
|
|
//
|
|
Add(
|
|
conditions.youngestBearishOB,
|
|
tmpSwings //
|
|
);
|
|
|
|
//
|
|
isSwingLow = false;
|
|
swingType = X_SWING_LOW;
|
|
swingsCount = ExtractSwingPoints(
|
|
swingType,
|
|
tmpSwings,
|
|
conditions.swings //
|
|
);
|
|
|
|
//
|
|
while (swingsCount > 2)
|
|
{
|
|
//
|
|
double tmpValues[];
|
|
int tmpValuesCount = ExtractSwings(
|
|
conditions.swings,
|
|
tmpValues //
|
|
);
|
|
|
|
//
|
|
int maxIDX = -1;
|
|
double max = GetMin(
|
|
tmpValues,
|
|
maxIDX,
|
|
0,
|
|
0 //
|
|
);
|
|
if (IsValidIndex(maxIDX))
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
conditions.swings,
|
|
maxIDX,
|
|
1 //
|
|
);
|
|
|
|
//
|
|
swingsCount = ArraySize(conditions.swings);
|
|
hasSwings = IsValidSize(swingsCount);
|
|
}
|
|
|
|
//
|
|
Clean(tmpValues);
|
|
}
|
|
}
|
|
Clean(tmpSwings);
|
|
|
|
//
|
|
hasSwings = IsValidSize(swingsCount) &&
|
|
swingsCount >= 2;
|
|
result = hasSwings;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Price Inside Order Block ...
|
|
|
|
//
|
|
if (hasYoungestBullishOB)
|
|
{
|
|
//
|
|
isPriceInsideYoungestBullishOB = IsInside(
|
|
decisionCBarBullishZoneChechValue,
|
|
conditions.youngestBullishOB //
|
|
);
|
|
}
|
|
|
|
//
|
|
if (hasYoungestBearishOB)
|
|
{
|
|
//
|
|
isPriceInsideYoungestBearishOB = IsInside(
|
|
decisionCBarBearishZoneChechValue,
|
|
conditions.youngestBearishOB //
|
|
);
|
|
}
|
|
|
|
//
|
|
isPriceInsideYoungestOB =
|
|
(hasBullishOrderFlow &&
|
|
isPriceInsideYoungestBullishOB) ||
|
|
(hasBearishOrderFlow &&
|
|
isPriceInsideYoungestBearishOB);
|
|
result = isPriceInsideYoungestOB;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Draw ...
|
|
|
|
//
|
|
mX121SMCXOBSObjects.Clear();
|
|
|
|
//
|
|
// Youngests ...
|
|
|
|
//
|
|
if (hasYoungestBullishOB)
|
|
{
|
|
//
|
|
DrawX121SMCXOBSOrderBlock(
|
|
conditions.youngestBullishOB,
|
|
visionCycleHelper.mPOIDrawer //
|
|
);
|
|
}
|
|
|
|
//
|
|
if (hasYoungestBearishOB)
|
|
{
|
|
//
|
|
DrawX121SMCXOBSOrderBlock(
|
|
conditions.youngestBearishOB,
|
|
visionCycleHelper.mPOIDrawer //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Valids ...
|
|
if (hasValidOBs)
|
|
{
|
|
//
|
|
for (int i = 0; i < validOBsCount; i++)
|
|
{
|
|
//
|
|
DrawX121SMCXOBSOrderBlock(
|
|
validOBs[i],
|
|
visionCycleHelper.mPOIDrawer //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Trend Line ...
|
|
if (hasSwings)
|
|
{
|
|
//
|
|
XCTrendObject *iObj;
|
|
bool isCreated = visionCycleHelper
|
|
.mPOIDrawer
|
|
.CreateTrend(
|
|
conditions.swings,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
mX121SMCXOBSObjects.Add(iObj);
|
|
}
|
|
}
|
|
|
|
//
|
|
return false;
|
|
|
|
//
|
|
double upper = 0;
|
|
double lower = 0;
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
// Summarize Conditions ...
|
|
|
|
//
|
|
bool isCondition1Bullish =
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isCondition1Bearish =
|
|
//
|
|
false
|
|
//
|
|
;
|
|
|
|
//
|
|
bool hasCondition1 = isCondition1Bullish ||
|
|
isCondition1Bearish;
|
|
if (hasCondition1)
|
|
{
|
|
//
|
|
ENUM_X_DIRECTION pzDir =
|
|
isCondition1Bullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
double point = GetEntry(
|
|
conditions.symbol,
|
|
pzDir //
|
|
);
|
|
|
|
//
|
|
double longPivot = lower; // triggerXConditions.valesBuffer[1];
|
|
double shortPivot = upper; // triggerXConditions.peaksBuffer[1];
|
|
|
|
//
|
|
// Manipulate Conditions Point ...
|
|
|
|
//
|
|
conditions.point =
|
|
isCondition1Bullish
|
|
? shortPivot
|
|
: longPivot;
|
|
|
|
//
|
|
// Manipulate Conditions Pivot ...
|
|
|
|
//
|
|
conditions.pivot =
|
|
isCondition1Bullish
|
|
? longPivot
|
|
: shortPivot;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
//
|
|
isBullish =
|
|
//
|
|
isCondition1Bullish
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
isCondition1Bearish
|
|
//
|
|
;
|
|
|
|
//
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
//
|
|
// Detect PriceOB Lifetime Bars ...
|
|
|
|
//
|
|
// Cleanup Arrays ...
|
|
Clean(triggerPoiEvents);
|
|
Clean(triggerCycleEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
Clean(analysePoiEvents);
|
|
Clean(analyseCycleEvents);
|
|
Clean(verificationPoiEvents);
|
|
Clean(verificationCycleEvents);
|
|
Clean(consolidationPoiEvents);
|
|
Clean(consolidationCycleEvents);
|
|
Clean(visionPoiEvents);
|
|
Clean(visionCycleEvents);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
conditions.setupTime = cTime;
|
|
conditions.dir =
|
|
isBullish
|
|
? X_DIRECTION_BULLISH
|
|
: X_DIRECTION_BEARISH;
|
|
|
|
//
|
|
// Cleanup Arrays ...
|
|
Clean(triggerPoiEvents);
|
|
Clean(triggerCycleEvents);
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
Clean(analysePoiEvents);
|
|
Clean(analyseCycleEvents);
|
|
Clean(verificationPoiEvents);
|
|
Clean(verificationCycleEvents);
|
|
Clean(consolidationPoiEvents);
|
|
Clean(consolidationCycleEvents);
|
|
Clean(visionPoiEvents);
|
|
Clean(visionCycleEvents);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Trigger Conditions ...
|
|
bool DetectX121SMCXOBSSignalTrigger(
|
|
//
|
|
X121SMCStrategyXOBSSignalConditions &conditions,
|
|
//
|
|
string _symbol,
|
|
ENUM_TIMEFRAMES _period,
|
|
//
|
|
XC121SMCCycleHelper *triggerCycleHelper,
|
|
XC121SMCCycleHelper *decisionCycleHelper,
|
|
XC121SMCCycleHelper *analyseCycleHelper,
|
|
XC121SMCCycleHelper *verificationCycleHelper,
|
|
XC121SMCCycleHelper *consolidationCycleHelper,
|
|
XC121SMCCycleHelper *visionCycleHelper,
|
|
//
|
|
int maxAllowedSetupAge = 60 //
|
|
//
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = conditions.IsSetuped();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
datetime setupTime = conditions.setupTime;
|
|
ENUM_X_DIRECTION setupDir = conditions.dir;
|
|
|
|
//
|
|
bool isBullish = IsBullish(setupDir);
|
|
bool isBearish = IsBearish(setupDir);
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
int loopback = 10;
|
|
|
|
//
|
|
string symbol = _symbol;
|
|
ENUM_TIMEFRAMES period = _period;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
result = decisionCycleHelper.GetBar(
|
|
zBar,
|
|
zIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL cBar;
|
|
result = decisionCycleHelper.GetBar(
|
|
cBar,
|
|
cIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL pBar;
|
|
result = decisionCycleHelper.GetBar(
|
|
pBar,
|
|
pIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double ask = GetAsk(symbol);
|
|
double bid = GetBid(symbol);
|
|
datetime cTime = TimeCurrent();
|
|
double points = GetPoints(symbol);
|
|
|
|
//
|
|
int swingLoopback = 9;
|
|
double ll = cBar.FindLowest(swingLoopback, MODE_LOW);
|
|
double hh = cBar.FindHighest(swingLoopback, MODE_HIGH);
|
|
double llDown = cBar.FindLowesttDown(swingLoopback);
|
|
double hhUp = cBar.FindHighestUp(swingLoopback);
|
|
|
|
//
|
|
// Cycles Conditions ...
|
|
|
|
//
|
|
// Decision ...
|
|
ENUM_XPOI_EVENTS decisionPoiEvents[];
|
|
ENUM_X_CYCLE_EVENTS decisionCycleEvents[];
|
|
X121SMCCycleConditions decisionConditions;
|
|
result = decisionCycleHelper.GetConditions(
|
|
decisionCycleEvents,
|
|
decisionPoiEvents,
|
|
decisionConditions,
|
|
zIndex,
|
|
loopback //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cycles POI States ...
|
|
XPOIState decisionState = decisionConditions.state;
|
|
|
|
//
|
|
// Cycle X121Conditions ...
|
|
X121Conditions decisionXConditions = decisionConditions.x121Conditions;
|
|
|
|
//
|
|
// Trigger Conditions ...
|
|
|
|
//
|
|
// Slopes ...
|
|
|
|
//
|
|
bool isRsiSlopeBullish = decisionXConditions.isRsiSlopeBullish;
|
|
bool isStrSlopeBullish = decisionXConditions.isStrSlopeBullish;
|
|
bool isAtrUpperSlopeBullish = decisionXConditions.isAtrUpperSlopeBullish;
|
|
bool isAtrLowerSlopeBullish = decisionXConditions.isAtrLowerSlopeBullish;
|
|
bool isVwapFastSlopeBullish = decisionXConditions.isVwapFastSlopeBullish;
|
|
bool isVwapMidSlopeBullish = decisionXConditions.isVwapMidSlopeBullish;
|
|
bool isVwapSlowSlopeBullish = decisionXConditions.isVwapSlowSlopeBullish;
|
|
|
|
//
|
|
bool isRsiSlopeBearish = decisionXConditions.isRsiSlopeBearish;
|
|
bool isStrSlopeBearish = decisionXConditions.isStrSlopeBearish;
|
|
bool isAtrUpperSlopeBearish = decisionXConditions.isAtrUpperSlopeBearish;
|
|
bool isAtrLowerSlopeBearish = decisionXConditions.isAtrLowerSlopeBearish;
|
|
bool isVwapFastSlopeBearish = decisionXConditions.isVwapFastSlopeBearish;
|
|
bool isVwapMidSlopeBearish = decisionXConditions.isVwapMidSlopeBearish;
|
|
bool isVwapSlowSlopeBearish = decisionXConditions.isVwapSlowSlopeBearish;
|
|
|
|
//
|
|
bool isSlopesBullish =
|
|
isRsiSlopeBullish &&
|
|
isStrSlopeBullish &&
|
|
isAtrUpperSlopeBullish &&
|
|
isAtrLowerSlopeBullish &&
|
|
isVwapFastSlopeBullish &&
|
|
isVwapMidSlopeBullish &&
|
|
isVwapSlowSlopeBullish;
|
|
|
|
//
|
|
bool isSlopesBearish =
|
|
isRsiSlopeBearish &&
|
|
isStrSlopeBearish &&
|
|
isAtrUpperSlopeBearish &&
|
|
isAtrLowerSlopeBearish &&
|
|
isVwapFastSlopeBearish &&
|
|
isVwapMidSlopeBearish &&
|
|
isVwapSlowSlopeBearish;
|
|
|
|
//
|
|
double point = conditions.point;
|
|
bool isPointBreaked = IsBarBreak(
|
|
point,
|
|
setupDir,
|
|
cBar //
|
|
);
|
|
|
|
//
|
|
// Summary ...
|
|
|
|
//
|
|
isBullish =
|
|
//
|
|
isBullish &&
|
|
isPointBreaked &&
|
|
isSlopesBullish
|
|
//
|
|
;
|
|
|
|
//
|
|
isBearish =
|
|
//
|
|
isBearish &&
|
|
isPointBreaked &&
|
|
isSlopesBearish
|
|
//
|
|
;
|
|
|
|
//
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
//
|
|
// Cleanup Setup Conditions ...
|
|
int setupAge = conditions.GetSetupAge();
|
|
if (IsValidSize(setupAge) &&
|
|
IsValidSize(maxAllowedSetupAge) &&
|
|
setupAge >= maxAllowedSetupAge)
|
|
{
|
|
conditions.Clean();
|
|
}
|
|
|
|
//
|
|
// Cleanup Arrays ...
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Nearest Pivot Point ...
|
|
|
|
//
|
|
double entry = GetEntry(
|
|
conditions.symbol,
|
|
setupDir //
|
|
);
|
|
|
|
//
|
|
double sls[];
|
|
Add(
|
|
conditions.pivot,
|
|
sls //
|
|
);
|
|
|
|
//
|
|
double iAtr = decisionConditions.x121Conditions.atrBuffer[1];
|
|
iAtr *= 1.5;
|
|
|
|
//
|
|
double slsMin = GetMin(sls);
|
|
double slsMax = GetMax(sls);
|
|
|
|
//
|
|
double sl = isBullish
|
|
? slsMin - iAtr
|
|
: slsMax + iAtr;
|
|
double risk = MathAbs(entry - sl);
|
|
|
|
//
|
|
// Filling Conditions Props ...
|
|
conditions.sl = sl;
|
|
// conditions.target = target;
|
|
conditions.triggerTime = cTime;
|
|
conditions.type = isBullish
|
|
? X_POSITION_TYPE_LONG
|
|
: X_POSITION_TYPE_SHORT;
|
|
|
|
//
|
|
// Cleanup Arrays ...
|
|
Clean(decisionPoiEvents);
|
|
Clean(decisionCycleEvents);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Guards ...
|
|
bool DetectX121SMCXOBSGuards(
|
|
X121SMCGuard &guards[],
|
|
const XPosition &positions[],
|
|
XC121SMCCycleHelper *triggerCycleHelper,
|
|
XC121SMCCycleHelper *decisionCycleHelper,
|
|
XC121SMCCycleHelper *analyseCycleHelper,
|
|
XC121SMCCycleHelper *verificationCycleHelper,
|
|
XC121SMCCycleHelper *consolidationCycleHelper,
|
|
XC121SMCCycleHelper *visionCycleHelper //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
string provider = ToString(X_121_SMC_PROVIDER_X);
|
|
|
|
//
|
|
result = DetectX121SMCGuards(
|
|
provider,
|
|
guards,
|
|
positions,
|
|
triggerCycleHelper,
|
|
decisionCycleHelper,
|
|
analyseCycleHelper,
|
|
verificationCycleHelper,
|
|
consolidationCycleHelper,
|
|
visionCycleHelper,
|
|
//
|
|
true, // CloseOnTPNear Guard ...
|
|
true, // CloseLongsOnBearishTrend Guard ...
|
|
true, // CloseShortsOnBullishTrend Guard ...
|
|
true, // CloseAllWeekend Guard ...
|
|
true, // PartialCloseOnTrendChange Guard ...
|
|
true, // TrailStop Guard ...
|
|
true, // TrailTarget Guard ...
|
|
true // Hedge Guard ...
|
|
//
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Add Conditions to Conditions Collection ...
|
|
int AddX121SMCXOBSConditionsIfNotExists(
|
|
X121SMCStrategyXOBSSignalConditions &item,
|
|
X121SMCStrategyXOBSSignalConditions &items[],
|
|
int maxAllowed = 10 //
|
|
)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
bool isSetuped = IsValid(item.setupTime) &&
|
|
HasDirection(item.dir);
|
|
if (!isSetuped)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(items);
|
|
if (IsValidSize(count))
|
|
{
|
|
//
|
|
// Copy Original Items ...
|
|
X121SMCStrategyXOBSSignalConditions tmpItems[];
|
|
Copy(
|
|
items,
|
|
tmpItems //
|
|
);
|
|
|
|
//
|
|
// Prese Item Data ...
|
|
bool isBullish = IsBullish(item.dir);
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
X121SMCStrategyXOBSSignalConditions iItem = tmpItems[i];
|
|
|
|
//
|
|
bool canRemove = item.dir == iItem.dir &&
|
|
item.pivot == iItem.pivot;
|
|
if (canRemove)
|
|
{
|
|
//
|
|
ArrayRemove(
|
|
items,
|
|
i,
|
|
1 //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Clean(tmpItems);
|
|
}
|
|
|
|
//
|
|
AddRef(
|
|
item,
|
|
items //
|
|
);
|
|
|
|
//
|
|
// Remove Olds ...
|
|
CleanupArray(
|
|
items,
|
|
maxAllowed //
|
|
);
|
|
|
|
//
|
|
result = ArraySize(items);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
void DrawX121SMCXOBSOrderBlock(
|
|
XCOrderBlock *ob,
|
|
XCPOIDrawer *drawer //
|
|
)
|
|
{
|
|
//
|
|
if (ob == NULL ||
|
|
drawer == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
ENUM_X_DIRECTION forDir = ob.GetDirection();
|
|
|
|
//
|
|
color bullishColor = drawer.BarBullishColor();
|
|
color bearishColor = drawer.BarBearishColor();
|
|
color forColor = IsBullish(forDir)
|
|
? bullishColor
|
|
: bearishColor;
|
|
|
|
//
|
|
// Draw Order Block ...
|
|
XCBaseObject *obj;
|
|
bool isCreated = drawer.CreateOrderBlock(
|
|
ob,
|
|
obj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
mX121SMCXOBSObjects.Add(obj);
|
|
}
|
|
|
|
//
|
|
ulong chartID = drawer.ChartIdentification();
|
|
int subWindow = drawer.SubWindowIdentification();
|
|
|
|
//
|
|
XOHCL startedBar;
|
|
ENUM_X_DIRECTION startedDir;
|
|
bool isStarted = ob.IsStarted(
|
|
forDir,
|
|
startedBar,
|
|
startedDir //
|
|
);
|
|
if (isStarted)
|
|
{
|
|
//
|
|
datetime to = startedBar.time + (PeriodSeconds(startedBar.period));
|
|
|
|
//
|
|
XCOHCLObject *obj;
|
|
bool isCreated = drawer.CreateBar(
|
|
startedBar,
|
|
obj,
|
|
to //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
//
|
|
obj.BodyColor(clrYellow);
|
|
obj.HighShadowColor(clrYellow);
|
|
obj.LowShadowColor(clrYellow);
|
|
|
|
//
|
|
obj.BodyStyle(STYLE_SOLID);
|
|
obj.HighShadowStyle(STYLE_SOLID);
|
|
obj.LowShadowStyle(STYLE_SOLID);
|
|
|
|
//
|
|
mX121SMCXOBSObjects.Add(obj);
|
|
}
|
|
|
|
//
|
|
string startVLineName = "Start_" + ob.GetTag();
|
|
|
|
//
|
|
CChartObjectVLine *startVLine;
|
|
startVLine = new CChartObjectVLine();
|
|
isCreated = startVLine.Create(
|
|
chartID,
|
|
startVLineName,
|
|
subWindow,
|
|
startedBar.time //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
//
|
|
startVLine.Color(forColor);
|
|
|
|
//
|
|
mX121SMCXOBSObjects.Add(startVLine);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|