3394 lines
55 KiB
Plaintext
3394 lines
55 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Seriallize Library
|
|
// ---------------------------------------
|
|
// Name: XPOILib
|
|
// Description: All models related to POIs ...
|
|
//
|
|
//
|
|
// 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.base.class.mq5"
|
|
#include <Arrays/ArrayObj.mqh>
|
|
|
|
//
|
|
// Definitions ...
|
|
|
|
//
|
|
// Definitions ...
|
|
|
|
//
|
|
// All Available POI(s) ...
|
|
enum ENUM_XPOIS
|
|
{
|
|
//
|
|
X_POI_NONE,
|
|
//
|
|
X_POI_TICKS_ZONES, // Ticks Zone ...
|
|
//
|
|
// Trading Day ...
|
|
X_POI_TRADING_DAY, // Trading Day ...
|
|
//
|
|
// Market Session ...
|
|
X_POI_MARKET_SESSION, // Market Session ...
|
|
//
|
|
// Momentum Bar ...
|
|
X_POI_MOMENTUM_BAR, // Momentum Bar ...
|
|
//
|
|
// Rejection Bar ...
|
|
X_POI_REJECTION_BAR, // Rejection Bar ...
|
|
//
|
|
// Swings ...
|
|
X_POI_SWING_HIGH, // Simple Swing High ...
|
|
X_POI_SWING_LOW, // Simple Swing Low ...
|
|
//
|
|
// Support nad Resistance ...
|
|
X_POI_SUPPORT_ZONE, // Support Zone ...
|
|
X_POI_RESISTANCE_ZONE, // Resistance Zone ...
|
|
//
|
|
// Supply and Demand Zones ...
|
|
X_POI_SUPPLY_ZONE, // Supply Zone ...
|
|
X_POI_DEMAND_ZONE, // Demand Zone ...
|
|
//
|
|
// Order Blocks ...
|
|
X_POI_BULLISH_ORDERBLOCK, // Bullish Order Block ...
|
|
X_POI_BEARISH_ORDERBLOCK, // Bearish Order Block ...
|
|
//
|
|
// Fair Value Gaps ...
|
|
X_POI_BULLISH_FVG, // Bullish Order Block ...
|
|
X_POI_BEARISH_FVG, // Bearish Order Block ...
|
|
};
|
|
|
|
//
|
|
// Event Types ...
|
|
enum ENUM_XPOI_EVENTS
|
|
{
|
|
//
|
|
// Trading Days ...
|
|
X_TRADE_DAY_FIRST_BAR, // Trading Day First Bar ...
|
|
X_TRADE_DAY_LAST_BAR, // Trading Day Last Bar ...
|
|
//
|
|
// Session ...
|
|
X_SESSION_FIRST_BAR, // Session First Bar ...
|
|
X_SESSION_LAST_BAR, // Session Last Bar ...
|
|
//
|
|
// Momentum Bar ...
|
|
X_BULLISH_MOMENTUM_BAR_DETECTED,
|
|
X_BEARISH_MOMENTUM_BAR_DETECTED,
|
|
//
|
|
// Rejection Bar ...
|
|
X_BULLISH_REJECTION_BAR_DETECTED,
|
|
X_BEARISH_REJECTION_BAR_DETECTED,
|
|
//
|
|
// Swings ...
|
|
X_SWING_HIGH_DETECTED,
|
|
X_SWING_LOW_DETECTED,
|
|
//
|
|
// Support nad Resistance ...
|
|
X_SUPPORT_ZONE_DETECTED, // Support Zone ...
|
|
X_RESISTANCE_ZONE_DETECTED, // Resistance Zone ...
|
|
//
|
|
// Supply nad Demand ...
|
|
X_SUPPLY_ZONE_DETECTED, // Supply Zone ...
|
|
X_DEMAND_ZONE_DETECTED, // Demand Zone ...
|
|
//
|
|
// Order Blocks ...
|
|
X_BULLISH_ORDERBLOCK_DETECTED, // Bullish Order Block ...
|
|
X_BEARISH_ORDERBLOCK_DETECTED, // Bearish Order Block ...
|
|
//
|
|
// Fair Value Gaps ...
|
|
X_BULLISH_FVG_DETECTED, // Bullish Fair Value Gapّ ...
|
|
X_BEARISH_FVG_DETECTED, // Bearish Fair Value Gapّ ...
|
|
};
|
|
|
|
//
|
|
// Forext Sessions ...
|
|
enum ENUM_XSESSION
|
|
{
|
|
X_TOKYO,
|
|
X_SYDNEY,
|
|
X_LONDON,
|
|
X_NEW_YORK,
|
|
X_FRANKFORT,
|
|
};
|
|
|
|
//
|
|
// Implementation ...
|
|
|
|
//
|
|
// Base POI Model Class ...
|
|
class XCBasePOI : public XCBase
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCBasePOI()
|
|
{
|
|
//
|
|
Clean();
|
|
|
|
//
|
|
mSep = "_";
|
|
mLineSep = "\n";
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCBasePOI()
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
//
|
|
// Virtual ...
|
|
|
|
/**
|
|
* Cleanup ...
|
|
*/
|
|
virtual void Clean()
|
|
{
|
|
mType = X_POI_NONE;
|
|
}
|
|
|
|
/**
|
|
* Validate ...
|
|
*
|
|
* @return ( virtual bool )
|
|
*/
|
|
virtual bool IsValid()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Retrieve POI Type ...
|
|
*
|
|
* @return ( virtual ENUM_XPOIS member )
|
|
*/
|
|
virtual ENUM_XPOIS Type()
|
|
{
|
|
return mType;
|
|
}
|
|
|
|
/**
|
|
* Retrieve POI Type ...
|
|
*
|
|
* @return ( virtual string )
|
|
*/
|
|
virtual string TypeAsString()
|
|
{
|
|
return ToString(mType);
|
|
}
|
|
|
|
/**
|
|
* Retrieve POI Tag ...
|
|
*
|
|
* @return ( virtual string )
|
|
*/
|
|
virtual string GetTag()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Retrieve POI Tooltip ...
|
|
*
|
|
* @return ( virtual string )
|
|
*/
|
|
virtual string GetTooltip()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
// Props ...
|
|
string mSep; // Separator ...
|
|
string mLineSep; // Line Separator ...
|
|
ENUM_XPOIS mType; // Type ...
|
|
|
|
//
|
|
private:
|
|
//
|
|
};
|
|
|
|
//
|
|
// Zone POI Class ...
|
|
class XCZone : public XCBasePOI
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Get Zone Upper Boundary ...
|
|
*
|
|
* @return ( double )
|
|
*/
|
|
double Upper()
|
|
{
|
|
return mUpper;
|
|
}
|
|
|
|
/**
|
|
* Get Zone Lower Boundary ...
|
|
*
|
|
* @return ( double )
|
|
*/
|
|
double Lower()
|
|
{
|
|
return mLower;
|
|
}
|
|
|
|
//
|
|
// Virtuals ...
|
|
|
|
/**
|
|
* Get Zone Start Date ...
|
|
*
|
|
* @return ( virtual datetime )
|
|
*/
|
|
virtual datetime From()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* Get Zone End Date ...
|
|
*
|
|
* @return ( virtual datetime )
|
|
*/
|
|
virtual datetime To()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
//
|
|
// Validators ...
|
|
|
|
/**
|
|
* Validate Upper and Lower of Zone ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsValidBoundary()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
mUpper > 0 &&
|
|
mLower > 0 &&
|
|
mUpper >= mLower
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check From Date of Zone is Valid ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsValidFrom()
|
|
{
|
|
return IsSpecifiedValid(From());
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
// Props ...
|
|
double mUpper; // Zone Upper ...
|
|
double mLower; // Zone Lower ...
|
|
|
|
//
|
|
private:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// From To Zone ...
|
|
class XCFromToZone : public XCBasePOI
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCFromToZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCFromToZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
bool InitFromTo(
|
|
ENUM_XPOIS type,
|
|
string title,
|
|
datetime from //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = type != X_POI_NONE &&
|
|
IsSpecifiedValid(from) &&
|
|
IsSpecifiedValid(title);
|
|
|
|
//
|
|
mType = type;
|
|
mFrom = from;
|
|
mTitle = title;
|
|
mTo = TimeCurrent();
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
bool InitFromTo(
|
|
ENUM_XPOIS type,
|
|
string title,
|
|
datetime from,
|
|
datetime to //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
result = InitFromTo(
|
|
type,
|
|
title,
|
|
from //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
to = NormalizeTime(to);
|
|
mTo = to;
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Get Zone Start Time ...
|
|
*
|
|
* @return ( datetime )
|
|
*/
|
|
datetime From()
|
|
{
|
|
return mFrom;
|
|
}
|
|
|
|
/**
|
|
* Set Zone Start Time ...
|
|
*
|
|
* @param value: Datetime
|
|
*/
|
|
void From(datetime value)
|
|
{
|
|
//
|
|
value = NormalizeTime(value);
|
|
|
|
//
|
|
mFrom = value;
|
|
}
|
|
|
|
/**
|
|
* Get Zone End Time ...
|
|
*
|
|
* @return ( datetime )
|
|
*/
|
|
datetime To()
|
|
{
|
|
return mTo;
|
|
}
|
|
|
|
/**
|
|
* Set Zone End Time ...
|
|
*
|
|
* @param value: Datetime
|
|
*/
|
|
void To(datetime value)
|
|
{
|
|
//
|
|
value = NormalizeTime(value);
|
|
|
|
//
|
|
mTo = value;
|
|
}
|
|
|
|
/**
|
|
* Get Title ...
|
|
*
|
|
* @return ( string )
|
|
*/
|
|
string Title()
|
|
{
|
|
return mTitle;
|
|
}
|
|
|
|
/**
|
|
* Set Title ...
|
|
*
|
|
* @param value: String ...
|
|
*/
|
|
// void Title(string value)
|
|
// {
|
|
// mTitle = value;
|
|
// }
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
void Clean() override
|
|
{
|
|
//
|
|
mTo = NULL;
|
|
mFrom = NULL;
|
|
mType = X_POI_NONE;
|
|
}
|
|
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
mType != X_POI_NONE &&
|
|
IsSpecifiedValid(mTo) &&
|
|
IsSpecifiedValid(mFrom) &&
|
|
IsSpecifiedValid(mTitle)
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
string GetTag() override
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
if (!IsValid())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string hash = TypeAsString() + mSep + ToString(From()) + mSep + Title();
|
|
hash = ToMD5(hash);
|
|
|
|
//
|
|
result = TypeAsString() + "[" + Title() + "]" + mSep + hash;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
// Props ...
|
|
datetime mFrom; // Start Date
|
|
datetime mTo; // End Date
|
|
string mTitle; // Zone Title
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Bar Zone ...
|
|
class XCBarZone : public XCZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCBarZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCBarZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param type: ENUM_XPOIS member ...
|
|
* @param upperPrice: ENUM_X_PRICE member ...
|
|
* @param lowerPrice: ENUM_X_PRICE member ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool InitBarZone(
|
|
XOHCL &bar,
|
|
ENUM_XPOIS type,
|
|
ENUM_X_PRICE upperPrice,
|
|
ENUM_X_PRICE lowerPrice //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = bar.IsValid() &&
|
|
type != X_POI_NONE &&
|
|
upperPrice != lowerPrice;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mBar = bar;
|
|
mType = type;
|
|
mUpperPrice = upperPrice;
|
|
mLowerPrice = lowerPrice;
|
|
mUpper = bar.GetPrice(upperPrice);
|
|
mLower = bar.GetPrice(lowerPrice);
|
|
|
|
//
|
|
result = IsValidBarZone();
|
|
if (result)
|
|
{
|
|
//
|
|
From(bar.time);
|
|
To(TimeCurrent());
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Fill Bar as XOHCL struct ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool FillBar(
|
|
XOHCL &bar //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bar = mBar;
|
|
result = mBar.IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Set From Date ...
|
|
*
|
|
* @param value: DateTime ...
|
|
*/
|
|
void From(datetime value)
|
|
{
|
|
//
|
|
if (!IsValidBarZone())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
value = NormalizeTime(value);
|
|
|
|
//
|
|
mFrom = value;
|
|
}
|
|
|
|
/**
|
|
* Set To Date ...
|
|
*
|
|
* @param value: DateTime ...
|
|
*/
|
|
void To(datetime value)
|
|
{
|
|
//
|
|
if (!IsValidBarZone())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
value = NormalizeTime(value);
|
|
|
|
//
|
|
mTo = value;
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
void Clean() override
|
|
{
|
|
//
|
|
mBar.Clean();
|
|
mUpper = 0;
|
|
mLower = 0;
|
|
mType = X_POI_NONE;
|
|
}
|
|
|
|
datetime From() override
|
|
{
|
|
return mFrom;
|
|
}
|
|
|
|
datetime To() override
|
|
{
|
|
return mTo;
|
|
}
|
|
|
|
string GetTag() override
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
if (!IsValidBarZone())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string hash = ToMD5(mBar.GetTag());
|
|
|
|
//
|
|
result =
|
|
//
|
|
TypeAsString() + mSep +
|
|
ToString(mBar.period) + mSep +
|
|
hash
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
string GetTooltip() override
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
if (!IsValidBarZone())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
// Props ...
|
|
XOHCL mBar; // Bar ...
|
|
ENUM_X_PRICE mUpperPrice; // Upper Price Selection
|
|
ENUM_X_PRICE mLowerPrice; // Lower Price Selection
|
|
|
|
/**
|
|
* Check Bar Zone Validation ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsValidBarZone()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = mBar.IsValid() &&
|
|
mType != X_POI_NONE &&
|
|
IsValidBoundary();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
private:
|
|
//
|
|
// Props ...
|
|
datetime mFrom;
|
|
datetime mTo;
|
|
|
|
//
|
|
};
|
|
class XCTwoBarZone : public XCZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCTwoBarZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCTwoBarZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param type: ENUM_XPOIS member ...
|
|
* @param upperPrice: ENUM_X_PRICE member ...
|
|
* @param lowerPrice: ENUM_X_PRICE member ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool InitTwoBarZone(
|
|
XOHCL &startBar,
|
|
XOHCL &endBar,
|
|
ENUM_XPOIS type,
|
|
bool useStartBarForUpper,
|
|
ENUM_X_PRICE upperPrice,
|
|
ENUM_X_PRICE lowerPrice //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = startBar.IsValid() &&
|
|
endBar.IsValid() &&
|
|
startBar.symbol == endBar.symbol &&
|
|
startBar.period == endBar.period &&
|
|
startBar.time < endBar.time &&
|
|
type != X_POI_NONE;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mType = type;
|
|
mEndBar = endBar;
|
|
mStartBar = startBar;
|
|
mUpperPrice = upperPrice;
|
|
mLowerPrice = lowerPrice;
|
|
mUseStartBarForUpper = useStartBarForUpper;
|
|
|
|
mUpper =
|
|
useStartBarForUpper
|
|
? startBar.GetPrice(upperPrice)
|
|
: endBar.GetPrice(upperPrice);
|
|
mLower =
|
|
useStartBarForUpper
|
|
? endBar.GetPrice(lowerPrice)
|
|
: startBar.GetPrice(lowerPrice);
|
|
|
|
//
|
|
result = IsValidTwoBarZone();
|
|
if (result)
|
|
{
|
|
//
|
|
From(startBar.time);
|
|
To(endBar.time);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Set From Date ...
|
|
*
|
|
* @param value: DateTime ...
|
|
*/
|
|
void From(datetime value)
|
|
{
|
|
//
|
|
if (!IsValidTwoBarZone())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
value = NormalizeTime(value);
|
|
|
|
//
|
|
mFrom = value;
|
|
}
|
|
|
|
/**
|
|
* Set To Date ...
|
|
*
|
|
* @param value: DateTime ...
|
|
*/
|
|
void To(datetime value)
|
|
{
|
|
//
|
|
if (!IsValidTwoBarZone())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
value = NormalizeTime(value);
|
|
|
|
//
|
|
mTo = value;
|
|
}
|
|
|
|
/**
|
|
* Fill Start Bar ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool FillStartBar(XOHCL &bar)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValidTwoBarZone();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bar = mStartBar;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Fill End Bar ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool FillEndBar(XOHCL &bar)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValidTwoBarZone();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bar = mEndBar;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
void Clean() override
|
|
{
|
|
//
|
|
mStartBar.Clean();
|
|
mEndBar.Clean();
|
|
mUpper = 0;
|
|
mLower = 0;
|
|
mUseStartBarForUpper = false;
|
|
mType = X_POI_NONE;
|
|
}
|
|
|
|
datetime From() override
|
|
{
|
|
return mFrom;
|
|
}
|
|
|
|
datetime To() override
|
|
{
|
|
return mTo;
|
|
}
|
|
|
|
string GetTag() override
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
if (!IsValidTwoBarZone())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string hash = ToMD5(mStartBar.GetTag() + mSep + mEndBar.GetTag());
|
|
|
|
//
|
|
result =
|
|
//
|
|
TypeAsString() + mSep +
|
|
ToString(mStartBar.period) + mSep +
|
|
hash
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
string GetTooltip() override
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
if (!IsValidTwoBarZone())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
// Props ...
|
|
XOHCL mStartBar; // Start (Oldest) Bar ...
|
|
XOHCL mEndBar; // End (Newest) Bar ...
|
|
bool mUseStartBarForUpper; // Use Start Bar for Upper Calculation ...
|
|
ENUM_X_PRICE mUpperPrice; // Upper Price Selection
|
|
ENUM_X_PRICE mLowerPrice; // Lower Price Selection
|
|
|
|
/**
|
|
* Check Two Bar Zone Validation ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsValidTwoBarZone()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = mStartBar.IsValid() &&
|
|
mEndBar.IsValid() &&
|
|
mStartBar.symbol == mEndBar.symbol &&
|
|
mStartBar.period == mEndBar.period &&
|
|
mStartBar.time < mEndBar.time &&
|
|
mType != X_POI_NONE &&
|
|
IsValidBoundary();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
private:
|
|
//
|
|
// Props ...
|
|
datetime mFrom;
|
|
datetime mTo;
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Swing Class ...
|
|
class XCSwing : public XCBasePOI
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCSwing()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCSwing()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param type: ENUM_XPOIS member ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
XOHCL &bar,
|
|
ENUM_XPOIS type //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = bar.IsValid() &&
|
|
(type == X_POI_SWING_HIGH ||
|
|
type == X_POI_SWING_LOW);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mBar = bar;
|
|
mType = type;
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Fill Bar as XOHCL struct ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool FillBar(
|
|
XOHCL &bar //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bar = mBar;
|
|
result = mBar.IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check Swing High or not ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsSwingHigh()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result =
|
|
Type() == X_POI_SWING_HIGH;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check Swing Low or not ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsSwingLow()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result =
|
|
Type() == X_POI_SWING_LOW;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
void Clean() override
|
|
{
|
|
//
|
|
mBar.Clean();
|
|
mType = X_POI_NONE;
|
|
}
|
|
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = mBar.IsValid() &&
|
|
(mType == X_POI_SWING_HIGH ||
|
|
mType == X_POI_SWING_LOW);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
string GetTag() override
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
if (!IsValid())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
string hash = ToMD5(mBar.GetTag());
|
|
|
|
//
|
|
string subType = IsSwingHigh()
|
|
? "High"
|
|
: "Low";
|
|
|
|
//
|
|
result =
|
|
//
|
|
TypeAsString() + mSep +
|
|
subType + mSep +
|
|
ToString(mBar.period) + mSep +
|
|
hash
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
string GetTooltip() override
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
if (!IsValid())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
// Props ...
|
|
XOHCL mBar; // Swing Bar ...
|
|
|
|
//
|
|
private:
|
|
//
|
|
};
|
|
|
|
//
|
|
// Supply Zone ...
|
|
class XCSupplyZone : public XCBarZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCSupplyZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCSupplyZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param range: Integer, Detection Range ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
XOHCL &bar,
|
|
int range = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = bar.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = InitBarZone(
|
|
bar,
|
|
X_POI_SUPPLY_ZONE,
|
|
X_PRICE_HIGH,
|
|
X_PRICE_LOW //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = IsValid();
|
|
if (result &&
|
|
range > 0)
|
|
{
|
|
//
|
|
datetime time = bar.time;
|
|
int periodSeconds = PeriodSeconds(bar.period);
|
|
|
|
//
|
|
datetime from = (datetime)((int)time - (range * periodSeconds));
|
|
datetime to = (datetime)((int)time + (range * periodSeconds));
|
|
|
|
//
|
|
From(from);
|
|
To(to);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValidBarZone() &&
|
|
mType == X_POI_SUPPLY_ZONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Demand Zone ...
|
|
class XCDemandZone : public XCBarZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCDemandZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCDemandZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param range: Integer, Detection Range ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
XOHCL &bar,
|
|
int range = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = bar.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = InitBarZone(
|
|
bar,
|
|
X_POI_DEMAND_ZONE,
|
|
X_PRICE_HIGH,
|
|
X_PRICE_LOW //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = IsValid();
|
|
if (result &&
|
|
range > 0)
|
|
{
|
|
//
|
|
datetime time = bar.time;
|
|
int periodSeconds = PeriodSeconds(bar.period);
|
|
|
|
//
|
|
datetime from = (datetime)((int)time - (range * periodSeconds));
|
|
datetime to = (datetime)((int)time + (range * periodSeconds));
|
|
|
|
//
|
|
From(from);
|
|
To(to);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValidBarZone() &&
|
|
mType == X_POI_DEMAND_ZONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Support Zone ...
|
|
class XCSupportZone : public XCBarZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCSupportZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCSupportZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param range: Integer, Detection Range ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
XOHCL &bar,
|
|
int range = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = bar.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = InitBarZone(
|
|
bar,
|
|
X_POI_SUPPORT_ZONE,
|
|
X_PRICE_DOWN,
|
|
X_PRICE_LOW //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = IsValid();
|
|
if (result &&
|
|
range > 0)
|
|
{
|
|
//
|
|
datetime time = bar.time;
|
|
int periodSeconds = PeriodSeconds(bar.period);
|
|
|
|
//
|
|
datetime from = (datetime)((int)time - (range * periodSeconds));
|
|
datetime to = (datetime)((int)time + (range * periodSeconds));
|
|
|
|
//
|
|
From(from);
|
|
To(to);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValidBarZone() &&
|
|
mType == X_POI_SUPPORT_ZONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Resistance Zone ...
|
|
class XCResistanceZone : public XCBarZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCResistanceZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCResistanceZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param range: Integer, Detection Range ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
XOHCL &bar,
|
|
int range = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = bar.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = InitBarZone(
|
|
bar,
|
|
X_POI_RESISTANCE_ZONE,
|
|
X_PRICE_HIGH,
|
|
X_PRICE_UP //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = IsValid();
|
|
if (result &&
|
|
range > 0)
|
|
{
|
|
//
|
|
datetime time = bar.time;
|
|
int periodSeconds = PeriodSeconds(bar.period);
|
|
|
|
//
|
|
datetime from = (datetime)((int)time - (range * periodSeconds));
|
|
datetime to = (datetime)((int)time + (range * periodSeconds));
|
|
|
|
//
|
|
From(from);
|
|
To(to);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValidBarZone() &&
|
|
mType == X_POI_RESISTANCE_ZONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Order Block ...
|
|
class XCOrderBlock : public XCBarZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCOrderBlock()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCOrderBlock()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param dir: ENUM_X_DIRECTION member ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
XOHCL &bar,
|
|
ENUM_X_DIRECTION dir //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = bar.IsValid() &&
|
|
(dir == X_DIRECTION_BULLISH ||
|
|
dir == X_DIRECTION_BEARISH);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
ENUM_XPOIS mTT =
|
|
IsSpecifiedBullish(dir)
|
|
? X_POI_BULLISH_ORDERBLOCK
|
|
: X_POI_BEARISH_ORDERBLOCK;
|
|
|
|
//
|
|
result = InitBarZone(
|
|
bar,
|
|
mTT,
|
|
X_PRICE_HIGH,
|
|
X_PRICE_LOW //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Check is Bullish ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsBullish()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid() &&
|
|
Type() == X_POI_BULLISH_ORDERBLOCK;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check is Bearish ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsBearish()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid() &&
|
|
Type() == X_POI_BEARISH_ORDERBLOCK;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValidBarZone() &&
|
|
(mType == X_POI_BULLISH_ORDERBLOCK ||
|
|
mType == X_POI_BEARISH_ORDERBLOCK);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Rejection Bar ...
|
|
class XCRejectionBar : public XCBarZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCRejectionBar()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCRejectionBar()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
XOHCL &bar //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = bar.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isBullish =
|
|
bar.GetLowShadow() > bar.GetHighShadow();
|
|
bool isBearish =
|
|
bar.GetHighShadow() > bar.GetLowShadow();
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
ENUM_X_PRICE upPrice = isBullish
|
|
? X_PRICE_HIGH
|
|
: X_PRICE_DOWN;
|
|
//
|
|
ENUM_X_PRICE loPrice = isBullish
|
|
? X_PRICE_UP
|
|
: X_PRICE_LOW;
|
|
|
|
//
|
|
result = InitBarZone(
|
|
bar,
|
|
X_POI_REJECTION_BAR,
|
|
upPrice,
|
|
loPrice //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Check is Bullish ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsBullish()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid() &&
|
|
Type() == X_POI_REJECTION_BAR &&
|
|
mBar.GetLowShadow() > mBar.GetHighShadow();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check is Bearish ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsBearish()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid() &&
|
|
Type() == X_POI_REJECTION_BAR &&
|
|
mBar.GetHighShadow() > mBar.GetLowShadow();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValidBarZone() &&
|
|
mType == X_POI_REJECTION_BAR;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Momentum Bar ...
|
|
class XCMomentumBar : public XCBarZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCMomentumBar()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCMomentumBar()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
XOHCL &bar //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = bar.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isBullish = bar.IsBullish();
|
|
bool isBearish = bar.IsBearish();
|
|
result = isBullish ||
|
|
isBearish;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = InitBarZone(
|
|
bar,
|
|
X_POI_MOMENTUM_BAR,
|
|
X_PRICE_HIGH,
|
|
X_PRICE_LOW //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Check is Bullish ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsBullish()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid() &&
|
|
mBar.IsBullish() &&
|
|
Type() == X_POI_MOMENTUM_BAR;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check is Bearish ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsBearish()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid() &&
|
|
mBar.IsBearish() &&
|
|
Type() == X_POI_MOMENTUM_BAR;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValidBarZone() &&
|
|
mType == X_POI_MOMENTUM_BAR;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Fair Value Gap ...
|
|
class XCFVG : public XCTwoBarZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCFVG()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCFVG()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param startBar: XOHCL instance ...
|
|
* @param endBar: XOHCL instance ...
|
|
* @param dir: ENUM_X_DIRECTION member ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
XOHCL &startBar,
|
|
XOHCL &endBar,
|
|
ENUM_X_DIRECTION dir //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = endBar.IsValid() &&
|
|
startBar.IsValid() &&
|
|
(dir == X_DIRECTION_BULLISH ||
|
|
dir == X_DIRECTION_BEARISH);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool isDirBullish = IsSpecifiedBullish(dir);
|
|
ENUM_XPOIS mTT =
|
|
isDirBullish
|
|
? X_POI_BULLISH_FVG
|
|
: X_POI_BEARISH_FVG;
|
|
|
|
//
|
|
bool useFistForUpper = isDirBullish
|
|
? false
|
|
: true;
|
|
ENUM_X_PRICE upPrice = isDirBullish
|
|
? X_PRICE_LOW
|
|
: X_PRICE_HIGH;
|
|
ENUM_X_PRICE loPrice = isDirBullish
|
|
? X_PRICE_HIGH
|
|
: X_PRICE_LOW;
|
|
|
|
//
|
|
result = InitTwoBarZone(
|
|
startBar,
|
|
endBar,
|
|
mTT,
|
|
useFistForUpper,
|
|
upPrice,
|
|
loPrice //
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Check is Bullish ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsBullish()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid() &&
|
|
Type() == X_POI_BULLISH_FVG;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Check is Bearish ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsBearish()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid() &&
|
|
Type() == X_POI_BEARISH_FVG;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValidTwoBarZone() &&
|
|
(mType == X_POI_BULLISH_FVG ||
|
|
mType == X_POI_BEARISH_FVG);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Ticks Zones ...
|
|
|
|
//
|
|
class XCTickZone : public CObject
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Props ...
|
|
double high;
|
|
double low;
|
|
int ticks;
|
|
double percent;
|
|
|
|
//
|
|
// Compare Two Zone With Each Other ...
|
|
virtual int Compare(
|
|
const CObject *node,
|
|
const int mode = 0 //
|
|
) const
|
|
{
|
|
//
|
|
const XCTickZone *other = (XCTickZone *)node;
|
|
|
|
//
|
|
return other.ticks - ticks;
|
|
}
|
|
|
|
//
|
|
bool IsValid()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = high > 0 &&
|
|
low > 0 &&
|
|
high > low &&
|
|
ticks > 0 &&
|
|
percent > 0;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Protected ...
|
|
protected:
|
|
//
|
|
// Private ...
|
|
private:
|
|
//
|
|
};
|
|
|
|
//
|
|
class XCTicksZone : public XCTwoBarZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCTicksZone()
|
|
{
|
|
Default();
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCTicksZone()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Get Number of Ticks Levels ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int Levels()
|
|
{
|
|
return mLevels;
|
|
}
|
|
|
|
/**
|
|
* Set Number of Ticks Levels ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
void Levels(int value)
|
|
{
|
|
//
|
|
if (value < 2)
|
|
{
|
|
value = 2;
|
|
}
|
|
|
|
//
|
|
mLevels = value;
|
|
}
|
|
|
|
/**
|
|
* Apply Default Config ...
|
|
*/
|
|
virtual void Default()
|
|
{
|
|
//
|
|
Levels(10);
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @param startBar: XOHCL instance ...
|
|
* @param endBar: XOHCL instance ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
XOHCL &startBar,
|
|
XOHCL &endBar //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = endBar.IsValid() &&
|
|
startBar.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Calculate Start and End Time ...
|
|
datetime from = startBar.time;
|
|
datetime to = endBar.time;
|
|
ulong fromM = ((ulong)startBar.time * 1000);
|
|
ulong toM = ((ulong)endBar.time * 1000);
|
|
|
|
//
|
|
// Symbol and Period ...
|
|
string symbol = startBar.symbol;
|
|
ENUM_TIMEFRAMES period = startBar.period;
|
|
|
|
//
|
|
// Prepare Zones Array ...
|
|
mZones.Clear();
|
|
|
|
//
|
|
// Retrieve Ticks between Times ...
|
|
SpecificClean(mTicks);
|
|
CopyTicksRange(
|
|
symbol,
|
|
mTicks,
|
|
COPY_TICKS_ALL,
|
|
fromM,
|
|
toM //
|
|
);
|
|
|
|
//
|
|
// Retrieve Highs ...
|
|
SpecificClean(mHighs);
|
|
CopyHigh(
|
|
symbol,
|
|
period,
|
|
from,
|
|
to,
|
|
mHighs //
|
|
);
|
|
|
|
//
|
|
// Retrieve Lows ...
|
|
SpecificClean(mLows);
|
|
CopyLow(
|
|
symbol,
|
|
period,
|
|
from,
|
|
to,
|
|
mLows //
|
|
);
|
|
|
|
//
|
|
// Find Highest Value in Range ...
|
|
int highIDX = ArrayMaximum(mHighs);
|
|
mRangeHigh = mHighs[highIDX];
|
|
|
|
//
|
|
// Find Lowest Value in Range ...
|
|
int lowIDX = ArrayMinimum(mLows);
|
|
mRangeLow = mLows[lowIDX];
|
|
|
|
//
|
|
datetime mTimes[];
|
|
CopyTime(
|
|
symbol,
|
|
period,
|
|
from,
|
|
to,
|
|
mTimes //
|
|
);
|
|
mRangeHighTime = mTimes[highIDX];
|
|
mRangeLowTime = mTimes[lowIDX];
|
|
|
|
//
|
|
double mRangeSize = mRangeHigh - mRangeLow;
|
|
|
|
//
|
|
// Create Zones ...
|
|
for (int i = 0; i < Levels(); i++)
|
|
{
|
|
//
|
|
// Instance a New Zone ...
|
|
XCTickZone *iZone = new XCTickZone();
|
|
|
|
//
|
|
// Calculate Each Zones High / Low based on Range ...
|
|
double iH = mRangeHigh - mRangeSize * i / Levels();
|
|
double iL = mRangeHigh - mRangeSize * (i + 1) / Levels();
|
|
|
|
//
|
|
// Set Zone High Low Properties ...
|
|
iZone.low = iL;
|
|
iZone.high = iH;
|
|
|
|
//
|
|
// Add Zone to Zone Array Objects ...
|
|
mZones.Add(iZone);
|
|
}
|
|
|
|
//
|
|
// Calculate Each Zone Ticks ...
|
|
int ticksCount = ArraySize(mTicks);
|
|
for (int i = 0; i < ticksCount; i++)
|
|
{
|
|
//
|
|
// Retrieve Tick ...
|
|
MqlTick iTick = mTicks[i];
|
|
|
|
//
|
|
// Loop through Zones ...
|
|
for (int j = 0; j < Levels(); j++)
|
|
{
|
|
//
|
|
// Rejrieve j indexed Zone Object ...
|
|
XCTickZone *jZone = mZones.At(j);
|
|
|
|
//
|
|
bool isInRange = IsTickInZoneRange(
|
|
iTick,
|
|
jZone //
|
|
);
|
|
if (isInRange)
|
|
{
|
|
//
|
|
jZone.ticks++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Calculating Zone Percents ...
|
|
for (int i = 0; i < Levels(); i++)
|
|
{
|
|
//
|
|
XCTickZone *iZone = mZones.At(i);
|
|
|
|
//
|
|
double percent = CalculateZoneTickPercent(iZone);
|
|
iZone.percent = percent;
|
|
}
|
|
|
|
//
|
|
// Sort Zones Based on Percents ...
|
|
mZones.Sort();
|
|
|
|
//
|
|
mUpper = mRangeHigh;
|
|
mLower = mRangeLow;
|
|
mType = X_POI_TICKS_ZONES;
|
|
mEndBar = endBar;
|
|
mStartBar = startBar;
|
|
From(startBar.time);
|
|
To(endBar.time);
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Retrieve Zones Count ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int Count()
|
|
{
|
|
return mZones.Total();
|
|
}
|
|
|
|
/**
|
|
* Retrieve Specified Sorted Zones ...
|
|
*
|
|
* @param index: Integer ...
|
|
*
|
|
* @return ( XCTickZone * )
|
|
*/
|
|
XCTickZone *GetZone(int index)
|
|
{
|
|
//
|
|
if (!IsValidIndex(index))
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
return mZones.At(index);
|
|
}
|
|
|
|
//
|
|
// Overrides ...
|
|
bool IsValid() override
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
IsValidFrom() &&
|
|
IsValidTwoBarZone() &&
|
|
Levels() > 0 &&
|
|
mZones.Total() == Levels() &&
|
|
mRangeHigh > 0 &&
|
|
mRangeLow > 0;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
MqlTick mTicks[];
|
|
double mHighs[];
|
|
double mLows[];
|
|
double mRangeHigh;
|
|
datetime mRangeHighTime;
|
|
double mRangeLow;
|
|
datetime mRangeLowTime;
|
|
|
|
//
|
|
int mLevels; // Number of Ticks Levels ...
|
|
|
|
//
|
|
CArrayObj mZones;
|
|
|
|
/**
|
|
* Check a Tick is in a Zone rage or not ...
|
|
*
|
|
* @param tick: MqlTick instance ...
|
|
* @param zone: XCTickZone instance ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsTickInZoneRange(
|
|
MqlTick &tick,
|
|
XCTickZone *zone //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
tick.bid >= zone.low &&
|
|
tick.bid <= zone.high
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Calculate Zone Tick Percent ...
|
|
*
|
|
* @param zone: XCTickZone instance ...
|
|
* @param normalizationDigits: Integer ...
|
|
*
|
|
* @return ( double )
|
|
*/
|
|
double CalculateZoneTickPercent(
|
|
XCTickZone *zone,
|
|
int normalizationDigits = 2 //
|
|
)
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
if (normalizationDigits < 2 || normalizationDigits > 5)
|
|
{
|
|
normalizationDigits = 2;
|
|
}
|
|
|
|
//
|
|
int ticksCount = ArraySize(mTicks);
|
|
if (ticksCount <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = (double)zone.ticks / ticksCount * 100;
|
|
result = NormalizeDouble(result, normalizationDigits);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Trading Day ...
|
|
class XCDay : public XCFromToZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCDay()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCDay()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Trading Session ...
|
|
class XCSession : public XCFromToZone
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
void XCSession()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCSession()
|
|
{
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize POI ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
//
|
|
// Overrides ...
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
//
|
|
// Model Exists Founded POIs ...
|
|
struct XPOIState
|
|
{
|
|
//
|
|
string symbol;
|
|
ENUM_TIMEFRAMES period;
|
|
datetime time;
|
|
|
|
//
|
|
XCTicksZone *ticksZone; // Ticks Zone ...
|
|
|
|
//
|
|
XCSwing *swingHighs[]; // Holds Founded Swing Highs ...
|
|
XCSwing *swingLows[]; // Holds Founded Swing Lows ...
|
|
XCMomentumBar *bullishMomentumBars[]; // Holds Founded Bullish Momentum Bars ...
|
|
XCMomentumBar *bearishMomentumBars[]; // Holds Founded Bearish Momentum Bars ...
|
|
XCRejectionBar *bullishRejectionBars[]; // Holds Founded Bullish Rejection Bars ...
|
|
XCRejectionBar *bearishRejectionBars[]; // Holds Founded Bearish Rejection Bars ...
|
|
XCSupportZone *supportZones[]; // Holds Founded Support Zones ...
|
|
XCResistanceZone *resistanceZones[]; // Holds Founded Resistance Zones ...
|
|
XCSupplyZone *supplyZones[]; // Holds Founded Supply Zones ...
|
|
XCDemandZone *demandZones[]; // Holds Founded Demand Zones ...
|
|
XCOrderBlock *bullishOrderBlocks[]; // Holds Founded Bullish Order Blocks ...
|
|
XCOrderBlock *bearishOrderBlocks[]; // Holds Founded Bearish Order Blocks ...
|
|
XCFVG *bullishFairValueGaps[]; // Holds Founded Bullish Fair Value Gaps ...
|
|
XCFVG *bearishFairValueGaps[]; // Holds Founded Bearish Fair Value Gaps ...
|
|
|
|
//
|
|
// Constructor ...
|
|
void XPOIState()
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
//
|
|
// Actions ...
|
|
|
|
/**
|
|
* Cleanup all props ...
|
|
*/
|
|
void Clean()
|
|
{
|
|
//
|
|
symbol = NULL;
|
|
period = NULL;
|
|
time = NULL;
|
|
|
|
//
|
|
ticksZone = NULL;
|
|
|
|
//
|
|
Clean(swingHighs);
|
|
Clean(swingLows);
|
|
Clean(bullishMomentumBars);
|
|
Clean(bearishMomentumBars);
|
|
Clean(bullishRejectionBars);
|
|
Clean(bearishRejectionBars);
|
|
Clean(supportZones);
|
|
Clean(resistanceZones);
|
|
Clean(supplyZones);
|
|
Clean(demandZones);
|
|
Clean(bullishOrderBlocks);
|
|
Clean(bearishOrderBlocks);
|
|
Clean(bullishFairValueGaps);
|
|
Clean(bearishFairValueGaps);
|
|
}
|
|
|
|
//
|
|
};
|
|
|
|
//
|
|
// Extensions ...
|
|
|
|
/**
|
|
* Converts ENUM_XPOI value to String Representation ...
|
|
*
|
|
* @param value: ENUM_XPOI member ...
|
|
*
|
|
* @return ( string )
|
|
*/
|
|
string ToString(ENUM_XPOIS value)
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
switch (value)
|
|
{
|
|
//
|
|
case X_POI_TRADING_DAY:
|
|
result = "XTDAY";
|
|
break;
|
|
|
|
//
|
|
case X_POI_MARKET_SESSION:
|
|
result = "XMSESS";
|
|
break;
|
|
|
|
//
|
|
case X_POI_MOMENTUM_BAR:
|
|
result = "XMNTMB";
|
|
break;
|
|
|
|
//
|
|
case X_POI_REJECTION_BAR:
|
|
result = "XRJCTB";
|
|
break;
|
|
|
|
//
|
|
case X_POI_SWING_HIGH:
|
|
result = "XSPH";
|
|
break;
|
|
|
|
//
|
|
case X_POI_SWING_LOW:
|
|
result = "XSPL";
|
|
break;
|
|
|
|
//
|
|
case X_POI_SUPPORT_ZONE:
|
|
result = "XSUP";
|
|
break;
|
|
|
|
//
|
|
case X_POI_RESISTANCE_ZONE:
|
|
result = "XRES";
|
|
break;
|
|
|
|
//
|
|
case X_POI_SUPPLY_ZONE:
|
|
result = "XSUPPLY";
|
|
break;
|
|
|
|
//
|
|
case X_POI_DEMAND_ZONE:
|
|
result = "XDEMAND";
|
|
break;
|
|
|
|
//
|
|
case X_POI_BULLISH_ORDERBLOCK:
|
|
result = "XBULLOB";
|
|
break;
|
|
|
|
//
|
|
case X_POI_BEARISH_ORDERBLOCK:
|
|
result = "XBEAROB";
|
|
break;
|
|
|
|
//
|
|
case X_POI_BULLISH_FVG:
|
|
result = "XBULLFVG";
|
|
break;
|
|
|
|
//
|
|
case X_POI_BEARISH_FVG:
|
|
result = "XBEARFVG";
|
|
break;
|
|
|
|
//
|
|
case X_POI_TICKS_ZONES:
|
|
result = "XTKSZ";
|
|
break;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Converts ENUM_XSESSION value to String Representation ...
|
|
*
|
|
* @param value: ENUM_XSESSION member ...
|
|
*
|
|
* @return ( string )
|
|
*/
|
|
string ToString(ENUM_XSESSION value)
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
switch (value)
|
|
{
|
|
//
|
|
case X_SYDNEY:
|
|
result = "Sydney";
|
|
break;
|
|
|
|
//
|
|
case X_TOKYO:
|
|
result = "Tokyo";
|
|
break;
|
|
|
|
//
|
|
case X_FRANKFORT:
|
|
result = "FrankGurt";
|
|
break;
|
|
|
|
//
|
|
case X_LONDON:
|
|
result = "London";
|
|
break;
|
|
|
|
//
|
|
case X_NEW_YORK:
|
|
result = "NewYork";
|
|
break;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Generate General Event Messages ...
|
|
*
|
|
* @param value: ENUM_XPOI_EVENTS member ...
|
|
*
|
|
* @return ( string )
|
|
*/
|
|
string ToString(ENUM_XPOI_EVENTS value)
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
switch (value)
|
|
{
|
|
//
|
|
case X_TRADE_DAY_FIRST_BAR:
|
|
result = "First Bar of Day";
|
|
break;
|
|
|
|
//
|
|
case X_TRADE_DAY_LAST_BAR:
|
|
result = "Last Bar of Day";
|
|
break;
|
|
|
|
//
|
|
case X_SESSION_FIRST_BAR:
|
|
result = "First Bar of Session";
|
|
break;
|
|
|
|
//
|
|
case X_SESSION_LAST_BAR:
|
|
result = "Last Bar of Session";
|
|
break;
|
|
|
|
//
|
|
case X_BULLISH_MOMENTUM_BAR_DETECTED:
|
|
result = "Bullish Momentum Bar Detected";
|
|
break;
|
|
|
|
//
|
|
case X_BEARISH_MOMENTUM_BAR_DETECTED:
|
|
result = "Bearish Momentum Bar Detected";
|
|
break;
|
|
|
|
//
|
|
case X_BULLISH_REJECTION_BAR_DETECTED:
|
|
result = "Bullish Rejection Bar Detected";
|
|
break;
|
|
|
|
//
|
|
case X_BEARISH_REJECTION_BAR_DETECTED:
|
|
result = "Bearish Rejection Bar Detected";
|
|
break;
|
|
|
|
//
|
|
case X_SWING_HIGH_DETECTED:
|
|
result = "Swing High Detected";
|
|
break;
|
|
|
|
//
|
|
case X_SWING_LOW_DETECTED:
|
|
result = "Swing Low Detected";
|
|
break;
|
|
|
|
//
|
|
case X_SUPPORT_ZONE_DETECTED:
|
|
result = "Support Zone Detected";
|
|
break;
|
|
|
|
//
|
|
case X_RESISTANCE_ZONE_DETECTED:
|
|
result = "Resistance Zone Detected";
|
|
break;
|
|
|
|
//
|
|
case X_SUPPLY_ZONE_DETECTED:
|
|
result = "Supply Zone Detected";
|
|
break;
|
|
|
|
//
|
|
case X_DEMAND_ZONE_DETECTED:
|
|
result = "Demand Zone Detected";
|
|
break;
|
|
|
|
//
|
|
case X_BULLISH_ORDERBLOCK_DETECTED:
|
|
result = "Bullish Order Block Detected";
|
|
break;
|
|
|
|
//
|
|
case X_BEARISH_ORDERBLOCK_DETECTED:
|
|
result = "Bearish Orer Block Detected";
|
|
break;
|
|
|
|
//
|
|
case X_BULLISH_FVG_DETECTED:
|
|
result = "Bullish FVG Detected";
|
|
break;
|
|
|
|
//
|
|
case X_BEARISH_FVG_DETECTED:
|
|
result = "Bearish FVg Detected";
|
|
break;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Combine a Collection of States into dest ...
|
|
*
|
|
* @param dest: XPOIState instance ...
|
|
* @param source: XPOIState Collection ...
|
|
*/
|
|
void CombineStates(
|
|
XPOIState &dest,
|
|
XPOIState &source[] //
|
|
)
|
|
{
|
|
//
|
|
dest.Clean();
|
|
|
|
//
|
|
int count = ArraySize(source);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XPOIState iState = source[i];
|
|
|
|
//
|
|
if (dest.ticksZone == NULL)
|
|
{
|
|
dest.ticksZone = iState.ticksZone;
|
|
}
|
|
|
|
//
|
|
Copy(
|
|
iState.swingHighs,
|
|
dest.swingHighs,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.swingLows,
|
|
dest.swingLows,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.bullishMomentumBars,
|
|
dest.bullishMomentumBars,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.bearishMomentumBars,
|
|
dest.bearishMomentumBars,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.bullishRejectionBars,
|
|
dest.bullishRejectionBars,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.bearishRejectionBars,
|
|
dest.bearishRejectionBars,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.supportZones,
|
|
dest.supportZones,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.resistanceZones,
|
|
dest.resistanceZones,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.supplyZones,
|
|
dest.supplyZones,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.demandZones,
|
|
dest.demandZones,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.bullishOrderBlocks,
|
|
dest.bullishOrderBlocks,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.bearishOrderBlocks,
|
|
dest.bearishOrderBlocks,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.bullishFairValueGaps,
|
|
dest.bullishFairValueGaps,
|
|
false //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
iState.bearishFairValueGaps,
|
|
dest.bearishFairValueGaps,
|
|
false //
|
|
);
|
|
|
|
//
|
|
}
|
|
}
|
|
|
|
//
|
|
typedef void (*TOnPOIEvent)(ENUM_XPOI_EVENTS event,
|
|
XCBasePOI *param //
|
|
);
|
|
|
|
// |