3303 lines
70 KiB
Plaintext
3303 lines
70 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Class Library
|
|
// --------------------------------------
|
|
// Name: XPOI
|
|
// Description: Provides Point of Interests ...
|
|
// - Swing Highs;
|
|
// - Swing Lows;
|
|
//
|
|
// 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-saherelm.x-chart-objects.class.mq5"
|
|
#include "../Classes/x-saherelm.xalert.class.mq5"
|
|
|
|
//
|
|
#include <Arrays/ArrayObj.mqh>
|
|
#include <ChartObjects/ChartObject.mqh>
|
|
#include <ChartObjects/ChartObjectsArrows.mqh>
|
|
#include <ChartObjects/ChartObjectsLines.mqh>
|
|
|
|
//
|
|
// Implementation ...
|
|
|
|
//
|
|
class XCPOI : public XSCBaseAlert
|
|
{
|
|
//
|
|
public:
|
|
//
|
|
|
|
//
|
|
// Constructors ...
|
|
/**
|
|
* Create an Instance ...
|
|
*
|
|
* @param symbol: String ...
|
|
* @param period: ENUM_TIMEFRAMES member ...
|
|
*/
|
|
void XCPOI(
|
|
string symbol,
|
|
ENUM_TIMEFRAMES period //
|
|
)
|
|
{
|
|
//
|
|
// Attach Required Properties ...
|
|
mSymbol = symbol;
|
|
mPeriod = period;
|
|
|
|
//
|
|
// Initialize Bar Tracker ...
|
|
mBarTracker.Init(
|
|
mSymbol,
|
|
mPeriod //
|
|
);
|
|
|
|
//
|
|
// Apply Default Configurations ...
|
|
ApplyDefaultConfig();
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
void ~XCPOI()
|
|
{
|
|
//
|
|
DestroyPOIs();
|
|
DestroyObjects();
|
|
DestroySessions();
|
|
DestroyEventListeners();
|
|
}
|
|
|
|
//
|
|
// Getter(s) / Setter(s) ...
|
|
|
|
/**
|
|
* Get Chart ID ...
|
|
*
|
|
* @return ( long )
|
|
*/
|
|
long ChartID()
|
|
{
|
|
return mChartID;
|
|
}
|
|
|
|
/**
|
|
* Set Chart ID ...
|
|
*
|
|
* @param value: Long
|
|
*/
|
|
void ChartID(long value)
|
|
{
|
|
//
|
|
if (value < 0)
|
|
{
|
|
value = 0;
|
|
}
|
|
|
|
//
|
|
mChartID = value;
|
|
}
|
|
|
|
/**
|
|
* Get Sub Window Number ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int Window()
|
|
{
|
|
return mWindow;
|
|
}
|
|
|
|
/**
|
|
* Get Sub Window Number ...
|
|
*
|
|
* @param value: Integer ...
|
|
*/
|
|
void Window(int value)
|
|
{
|
|
//
|
|
if (value < 0)
|
|
{
|
|
value = 0;
|
|
}
|
|
|
|
//
|
|
mWindow = value;
|
|
}
|
|
|
|
/**
|
|
* Get Max Number of POIs which holds ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int MaxNumberOfPOIs()
|
|
{
|
|
return mMaxNumberOfPOIs;
|
|
}
|
|
|
|
/**
|
|
* Set Max Number of POIs which holds ...
|
|
* 0 => Infinity ...
|
|
*
|
|
* @param value: Integer ...
|
|
*/
|
|
void MaxNumberOfPOIs(int value)
|
|
{
|
|
//
|
|
if (value < 0)
|
|
{
|
|
value = 0;
|
|
}
|
|
|
|
//
|
|
mMaxNumberOfPOIs = value;
|
|
}
|
|
|
|
/**
|
|
* Get Number of POI(s) which must Find at Initializations ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int MaxNumberOfRequiredPOIs()
|
|
{
|
|
return mMaxNumberOfRequiredPOIs;
|
|
}
|
|
|
|
/**
|
|
* Set Number of POI(s) which must Find at Initializations ...
|
|
* 2 is Default ...
|
|
*
|
|
* @param value: Integer ...
|
|
*/
|
|
void MaxNumberOfRequiredPOIs(int value)
|
|
{
|
|
//
|
|
if (value < 2)
|
|
{
|
|
value = 2;
|
|
}
|
|
|
|
//
|
|
mMaxNumberOfRequiredPOIs = value;
|
|
}
|
|
|
|
/**
|
|
* Check Is Locked or not ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsLocked()
|
|
{
|
|
return mLock;
|
|
}
|
|
|
|
//
|
|
// POI(s) Configs ...
|
|
|
|
//
|
|
// Trading Days ...
|
|
|
|
/**
|
|
* Get Draw Trading Days State ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool AllowDrawTradingDays()
|
|
{
|
|
return mAllowDrawTradingDays;
|
|
}
|
|
|
|
/**
|
|
* Set Draw Trading Days State ...
|
|
*
|
|
* @param value: Boolean ...
|
|
*/
|
|
void AllowDrawTradingDays(bool value)
|
|
{
|
|
mAllowDrawTradingDays = value;
|
|
}
|
|
|
|
/**
|
|
* Get Trading Days Start Color ...
|
|
*
|
|
* @return ( color )
|
|
*/
|
|
color TradingDaysStartColor()
|
|
{
|
|
return mTradingDaysStartColor;
|
|
}
|
|
|
|
/**
|
|
* Set Trading Days Start Color ...
|
|
*
|
|
* @param value: Argument 1
|
|
*/
|
|
void TradingDaysStartColor(color value)
|
|
{
|
|
mTradingDaysStartColor = value;
|
|
}
|
|
|
|
/**
|
|
* Get Trading Days Start Style ...
|
|
*
|
|
* @return ( ENUM_LINE_STYLE )
|
|
*/
|
|
ENUM_LINE_STYLE TradingDaysStartStyle()
|
|
{
|
|
return mTradingDaysStartStyle;
|
|
}
|
|
|
|
/**
|
|
* Set Trading Days Start Style ...
|
|
*
|
|
* @param value: ENUM_LINE_STYLE member ...
|
|
*/
|
|
void TradingDaysStartStyle(ENUM_LINE_STYLE value)
|
|
{
|
|
mTradingDaysStartStyle = value;
|
|
}
|
|
|
|
/**
|
|
* Get Trading Days End Color ...
|
|
*
|
|
* @return ( color )
|
|
*/
|
|
color TradingDaysEndColor()
|
|
{
|
|
return mTradingDaysEndColor;
|
|
}
|
|
|
|
/**
|
|
* Set Trading Days End Color ...
|
|
*
|
|
* @param value: Argument 1
|
|
*/
|
|
void TradingDaysEndColor(color value)
|
|
{
|
|
mTradingDaysEndColor = value;
|
|
}
|
|
|
|
/**
|
|
* Get Trading Days End Style ...
|
|
*
|
|
* @return ( ENUM_LINE_STYLE )
|
|
*/
|
|
ENUM_LINE_STYLE TradingDaysEndStyle()
|
|
{
|
|
return mTradingDaysEndStyle;
|
|
}
|
|
|
|
/**
|
|
* Set Trading Days End Style ...
|
|
*
|
|
* @param value: ENUM_LINE_STYLE member ...
|
|
*/
|
|
void TradingDaysEndStyle(ENUM_LINE_STYLE value)
|
|
{
|
|
mTradingDaysEndStyle = value;
|
|
}
|
|
|
|
//
|
|
// Sessions ...
|
|
|
|
/**
|
|
* Get Draw Market Sessions State ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool AllowDrawMarketSessions()
|
|
{
|
|
return mAllowDrawMarketSessions;
|
|
}
|
|
|
|
/**
|
|
* Set Draw Market Sessions State ...
|
|
*
|
|
* @param value: Boolean ...
|
|
*/
|
|
void AllowDrawMarketSessions(bool value)
|
|
{
|
|
mAllowDrawMarketSessions = value;
|
|
}
|
|
|
|
/**
|
|
* Get Session Working Hors ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int SessionOpenHours()
|
|
{
|
|
return mSessionOpenHours;
|
|
}
|
|
|
|
/**
|
|
* Set Session Working Hors ...
|
|
*
|
|
* @param value: Integer ...
|
|
*/
|
|
void SessionOpenHours(int value)
|
|
{
|
|
//
|
|
if (value <= 0)
|
|
{
|
|
value = 9;
|
|
}
|
|
|
|
//
|
|
mSessionOpenHours = value;
|
|
}
|
|
|
|
//
|
|
// Swing High ...
|
|
|
|
/**
|
|
* Get Draw Swing Highs State ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool AllowDrawSwingHighs()
|
|
{
|
|
return mAllowDrawSwingHighs;
|
|
}
|
|
|
|
/**
|
|
* Set Draw Swing Highs State ...
|
|
*
|
|
* @param value: Boolean
|
|
*/
|
|
void AllowDrawSwingHighs(bool value)
|
|
{
|
|
mAllowDrawSwingHighs = value;
|
|
}
|
|
|
|
/**
|
|
* Get Threshold Required for Swing High Detection ...
|
|
*
|
|
* @return ( double )
|
|
*/
|
|
double SwingHighThreshold()
|
|
{
|
|
return mSwingHighThreshold;
|
|
}
|
|
|
|
/**
|
|
* Set Threshold Required for Swing High Detection ...
|
|
*
|
|
* @param value: Double ...
|
|
*/
|
|
void SwingHighThreshold(double value)
|
|
{
|
|
//
|
|
if (value < 0)
|
|
{
|
|
value = 0;
|
|
}
|
|
|
|
//
|
|
mSwingHighThreshold = value;
|
|
}
|
|
|
|
/**
|
|
* Get Swing High Arrow Code ...
|
|
*
|
|
* @return ( char )
|
|
*/
|
|
char SwingHighArrowCode()
|
|
{
|
|
return mSwingHighArrowCode;
|
|
}
|
|
|
|
/**
|
|
* Set Swing High Arrow Code ...
|
|
*
|
|
* @param value: Char ...
|
|
*/
|
|
void SwingHighArrowCode(char value)
|
|
{
|
|
mSwingHighArrowCode = value;
|
|
}
|
|
|
|
/**
|
|
* Get Swing High Color ...
|
|
*
|
|
* @return ( color )
|
|
*/
|
|
color SwingHighColor()
|
|
{
|
|
return mSwingHighColor;
|
|
}
|
|
|
|
/**
|
|
* Get Swing High Color ...
|
|
*
|
|
* @param value: Color
|
|
*/
|
|
void SwingHighColor(color value)
|
|
{
|
|
mSwingHighColor = value;
|
|
}
|
|
|
|
/**
|
|
* Get Swing High Width ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int SwingHighWidth()
|
|
{
|
|
return mSwingHighWidth;
|
|
}
|
|
|
|
/**
|
|
* Set Swing High Width ...
|
|
*
|
|
* @param value: Integer ...
|
|
*/
|
|
void SwingHighWidth(int value)
|
|
{
|
|
//
|
|
if (value < 1)
|
|
{
|
|
value = 1;
|
|
}
|
|
|
|
//
|
|
mSwingHighWidth = value;
|
|
}
|
|
|
|
//
|
|
// Swing Low ...
|
|
|
|
/**
|
|
* Get Draw Swing Lows State ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool AllowDrawSwingLows()
|
|
{
|
|
return mAllowDrawSwingLows;
|
|
}
|
|
|
|
/**
|
|
* Set Draw Swing Lows State ...
|
|
*
|
|
* @param value: Boolean
|
|
*/
|
|
void AllowDrawSwingLows(bool value)
|
|
{
|
|
mAllowDrawSwingLows = value;
|
|
}
|
|
|
|
/**
|
|
* Get Threshold Required for Swing Low Detection ...
|
|
*
|
|
* @return ( double )
|
|
*/
|
|
double SwingLowThreshold()
|
|
{
|
|
return mSwingLowThreshold;
|
|
}
|
|
|
|
/**
|
|
* Set Threshold Required for Swing Low Detection ...
|
|
*
|
|
* @param value: Double ...
|
|
*/
|
|
void SwingLowThreshold(double value)
|
|
{
|
|
//
|
|
if (value < 0)
|
|
{
|
|
value = 0;
|
|
}
|
|
|
|
//
|
|
mSwingLowThreshold = value;
|
|
}
|
|
|
|
/**
|
|
* Get Swing Low Arrow Code ...
|
|
*
|
|
* @return ( char )
|
|
*/
|
|
char SwingLowArrowCode()
|
|
{
|
|
return mSwingLowArrowCode;
|
|
}
|
|
|
|
/**
|
|
* Set Swing Low Arrow Code ...
|
|
*
|
|
* @param value: Char ...
|
|
*/
|
|
void SwingLowArrowCode(char value)
|
|
{
|
|
mSwingLowArrowCode = value;
|
|
}
|
|
|
|
/**
|
|
* Get Swing Low Color ...
|
|
*
|
|
* @return ( color )
|
|
*/
|
|
color SwingLowColor()
|
|
{
|
|
return mSwingLowColor;
|
|
}
|
|
|
|
/**
|
|
* Get Swing Low Color ...
|
|
*
|
|
* @param value: Color
|
|
*/
|
|
void SwingLowColor(color value)
|
|
{
|
|
mSwingLowColor = value;
|
|
}
|
|
|
|
/**
|
|
* Get Swing Low Width ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int SwingLowWidth()
|
|
{
|
|
return mSwingLowWidth;
|
|
}
|
|
|
|
/**
|
|
* Set Swing Low Width ...
|
|
*
|
|
* @param value: Integer ...
|
|
*/
|
|
void SwingLowWidth(int value)
|
|
{
|
|
//
|
|
if (value < 1)
|
|
{
|
|
value = 1;
|
|
}
|
|
|
|
//
|
|
mSwingLowWidth = value;
|
|
}
|
|
|
|
//
|
|
// Momentum Bars ...
|
|
|
|
/**
|
|
* Get Draw Momentum Bars State ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool AllowDrawMomentumBars()
|
|
{
|
|
return mAllowDrawMomentumBars;
|
|
}
|
|
|
|
/**
|
|
* Set Draw Momentum Bars State ...
|
|
*
|
|
* @param value: Boolean
|
|
*/
|
|
void AllowDrawMomentumBars(bool value)
|
|
{
|
|
mAllowDrawMomentumBars = value;
|
|
}
|
|
|
|
/**
|
|
* Get Momentum Bar Percent ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int MomentumBarPercent()
|
|
{
|
|
return mMomentumBarPercent;
|
|
}
|
|
|
|
/**
|
|
* Set Momentum Bar Percent ...
|
|
*
|
|
* @param value: Integer
|
|
*/
|
|
void MomentumBarPercent(int value)
|
|
{
|
|
//
|
|
if (value < 0)
|
|
{
|
|
value = 0;
|
|
}
|
|
|
|
//
|
|
mMomentumBarPercent = value;
|
|
}
|
|
|
|
/**
|
|
* Get Momentum Bar Sharp Ratio ...
|
|
*
|
|
* @return ( double )
|
|
*/
|
|
double MomentumBarSharpRatio()
|
|
{
|
|
return mMomentumBarSharpRatio;
|
|
}
|
|
|
|
/**
|
|
* Set Momentum Bar Sharp Ratio ...
|
|
*
|
|
* @param value: Double ...
|
|
*/
|
|
void MomentumBarSharpRatio(double value)
|
|
{
|
|
//
|
|
if (value < 0)
|
|
{
|
|
value = 0;
|
|
}
|
|
|
|
//
|
|
mMomentumBarSharpRatio = value;
|
|
}
|
|
|
|
/**
|
|
* Get Momentum Bar Loopback ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int MomentumBarLoopBack()
|
|
{
|
|
return mMomentumBarLoopBack;
|
|
}
|
|
|
|
/**
|
|
* Set Momentum Bar Loopback ...
|
|
*
|
|
* @param value: Integer ...
|
|
*/
|
|
void MomentumBarLoopBack(int value)
|
|
{
|
|
//
|
|
if (value < 0)
|
|
{
|
|
value = 0;
|
|
}
|
|
|
|
//
|
|
mMomentumBarLoopBack = value;
|
|
}
|
|
|
|
/**
|
|
* Get Momentum Bar Width ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int MomentumBarWidth()
|
|
{
|
|
return mMomentumBarWidth;
|
|
}
|
|
|
|
/**
|
|
* Set Momentum Bar Width ...
|
|
*
|
|
* @param value: Integer ...
|
|
*/
|
|
void MomentumBarWidth(int value)
|
|
{
|
|
mMomentumBarWidth = value;
|
|
}
|
|
|
|
/**
|
|
* Get Bullish Momentum Bar Arrow Code ...
|
|
*
|
|
* @return ( char )
|
|
*/
|
|
char MomentumBarBullishArrowCode()
|
|
{
|
|
return mMomentumBarBullishArrowCode;
|
|
}
|
|
|
|
/**
|
|
* Set Bullish Momentum Bar Arrow Code ...
|
|
*
|
|
* @param value: Char ...
|
|
*/
|
|
void MomentumBarBullishArrowCode(char value)
|
|
{
|
|
mMomentumBarBullishArrowCode = value;
|
|
}
|
|
|
|
/**
|
|
* Get Bullish Momentum Bar Color ...
|
|
*
|
|
* @return ( char )
|
|
*/
|
|
char MomentumBarBearishArrowCode()
|
|
{
|
|
return mMomentumBarBearishArrowCode;
|
|
}
|
|
|
|
/**
|
|
* Set Bullish Momentum Bar Color ...
|
|
*
|
|
* @param value: Color ...
|
|
*/
|
|
void MomentumBarBearishArrowCode(char value)
|
|
{
|
|
mMomentumBarBearishArrowCode = value;
|
|
}
|
|
|
|
/**
|
|
* Get Bearish Momentum Bar Arrow Code ...
|
|
*
|
|
* @return ( color )
|
|
*/
|
|
color MomentumBarBullishColor()
|
|
{
|
|
return mMomentumBarBullishColor;
|
|
}
|
|
|
|
/**
|
|
* Set Bearish Momentum Bar Arrow Code ...
|
|
*
|
|
* @param value: Color ...
|
|
*/
|
|
void MomentumBarBullishColor(color value)
|
|
{
|
|
mMomentumBarBullishColor = value;
|
|
}
|
|
|
|
/**
|
|
* Get Bearish Momentum Bar Color ...
|
|
*
|
|
* @return ( color )
|
|
*/
|
|
color MomentumBarBearishColor()
|
|
{
|
|
return mMomentumBarBearishColor;
|
|
}
|
|
|
|
/**
|
|
* Set Bearish Momentum Bar Color ...
|
|
*
|
|
* @param value: Color ...
|
|
*/
|
|
void MomentumBarBearishColor(color value)
|
|
{
|
|
mMomentumBarBearishColor = value;
|
|
}
|
|
|
|
//
|
|
// Rejection Bars ...
|
|
|
|
/**
|
|
* Get Draw Rejection Bars State ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool AllowDrawRejectionBars()
|
|
{
|
|
return mAllowDrawRejectionBars;
|
|
}
|
|
|
|
/**
|
|
* Set Draw Rejection Bars State ...
|
|
*
|
|
* @param value: Boolean ...
|
|
*/
|
|
void AllowDrawRejectionBars(bool value)
|
|
{
|
|
mAllowDrawRejectionBars = value;
|
|
}
|
|
|
|
/**
|
|
* Get Rejection Bar Percent ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int RejectionBarPercent()
|
|
{
|
|
return mRejectionBarPercent;
|
|
}
|
|
|
|
/**
|
|
* Set Rejection Bar Percent ...
|
|
*
|
|
* @param value: Integer
|
|
*/
|
|
void RejectionBarPercent(int value)
|
|
{
|
|
mRejectionBarPercent = value;
|
|
}
|
|
|
|
/**
|
|
* Get Rejection Bar Sharp Ratio ...
|
|
*
|
|
* @return ( double )
|
|
*/
|
|
double RejectionBarSharpRatio()
|
|
{
|
|
return mRejectionBarSharpRatio;
|
|
}
|
|
|
|
/**
|
|
* Set Rejection Bar Sharp Ratio ...
|
|
*
|
|
* @param value: Double ...
|
|
*/
|
|
void RejectionBarSharpRatio(double value)
|
|
{
|
|
mRejectionBarSharpRatio = value;
|
|
}
|
|
|
|
/**
|
|
* Get Rejection Bar Loopback ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int RejectionBarLoopBack()
|
|
{
|
|
return mRejectionBarLoopBack;
|
|
}
|
|
|
|
/**
|
|
* Set Rejection Bar Loopback ...
|
|
*
|
|
* @param value: Integer ...
|
|
*/
|
|
void RejectionBarLoopBack(int value)
|
|
{
|
|
mRejectionBarLoopBack = value;
|
|
}
|
|
|
|
/**
|
|
* Get Rejection Bar Width ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int RejectionBarWidth()
|
|
{
|
|
return mRejectionBarWidth;
|
|
}
|
|
|
|
/**
|
|
* Set Rejection Bar Width ...
|
|
*
|
|
* @param value: Integer ...
|
|
*/
|
|
void RejectionBarWidth(int value)
|
|
{
|
|
mRejectionBarWidth = value;
|
|
}
|
|
|
|
/**
|
|
* Get Bullish Rejection Bar Arrow Code ...
|
|
*
|
|
* @return ( char )
|
|
*/
|
|
char RejectionBarBullishArrowCode()
|
|
{
|
|
return mRejectionBarBullishArrowCode;
|
|
}
|
|
|
|
/**
|
|
* Set Bullish Rejection Bar Arrow Code ...
|
|
*
|
|
* @param value: Char ...
|
|
*/
|
|
void RejectionBarBullishArrowCode(char value)
|
|
{
|
|
mRejectionBarBullishArrowCode = value;
|
|
}
|
|
|
|
/**
|
|
* Get Bullish Rejection Bar Color ...
|
|
*
|
|
* @return ( char )
|
|
*/
|
|
char RejectionBarBearishArrowCode()
|
|
{
|
|
return mRejectionBarBearishArrowCode;
|
|
}
|
|
|
|
/**
|
|
* Set Bullish Rejection Bar Color ...
|
|
*
|
|
* @param value: Color ...
|
|
*/
|
|
void RejectionBarBearishArrowCode(char value)
|
|
{
|
|
mRejectionBarBearishArrowCode = value;
|
|
}
|
|
|
|
/**
|
|
* Get Bearish Rejection Bar Arrow Code ...
|
|
*
|
|
* @return ( color )
|
|
*/
|
|
color RejectionBarBullishColor()
|
|
{
|
|
return mRejectionBarBullishColor;
|
|
}
|
|
|
|
/**
|
|
* Set Bearish Rejection Bar Arrow Code ...
|
|
*
|
|
* @param value: Color ...
|
|
*/
|
|
void RejectionBarBullishColor(color value)
|
|
{
|
|
mRejectionBarBullishColor = value;
|
|
}
|
|
|
|
/**
|
|
* Get Bearish Rejection Bar Color ...
|
|
*
|
|
* @return ( color )
|
|
*/
|
|
color RejectionBarBearishColor()
|
|
{
|
|
return mRejectionBarBearishColor;
|
|
}
|
|
|
|
/**
|
|
* Set Bearish Rejection Bar Color ...
|
|
*
|
|
* @param value: Color ...
|
|
*/
|
|
void RejectionBarBearishColor(color value)
|
|
{
|
|
mRejectionBarBearishColor = value;
|
|
}
|
|
|
|
//
|
|
// Actions ...
|
|
|
|
/**
|
|
* Initialize POI Detector ...
|
|
*/
|
|
void Init()
|
|
{
|
|
//
|
|
// Detect Previous POI(s) ...
|
|
DetectRequiredPOIs();
|
|
}
|
|
|
|
/**
|
|
* Update POI(s) ...
|
|
*
|
|
* @param state: an Array Refrence of ENUM_XPOI_EVENTS members ...
|
|
*/
|
|
int Update(
|
|
ENUM_XPOI_EVENTS &state[] //
|
|
)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
Clean(state);
|
|
|
|
//
|
|
// Check Bar Tracker if Waits ...
|
|
if (!mBarTracker.IsNewBar())
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int zIndex = 0;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
|
|
//
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
XOHCL zBar;
|
|
bool isInited = zBar.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
zIndex //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL cBar;
|
|
isInited = cBar.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
cIndex //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL pBar;
|
|
isInited = pBar.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
pIndex //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
XOHCL zDayBar;
|
|
isInited = zDayBar.Init(
|
|
mSymbol,
|
|
PERIOD_D1,
|
|
zIndex //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Trading Days ...
|
|
int tradingDaysCount = ArraySize(mTradingDays);
|
|
int tradingDayIDX = HasTradeDay(zDayBar.time);
|
|
if (IsValidIndex(tradingDayIDX))
|
|
{
|
|
//
|
|
if (zBar.time == mTradingDays[tradingDayIDX].to)
|
|
{
|
|
//
|
|
Add(
|
|
X_TRADE_DAY_LAST_BAR,
|
|
state //
|
|
);
|
|
OnTradingDayEvent(X_TRADE_DAY_LAST_BAR);
|
|
NotifyTradingDayEventListeners(X_TRADE_DAY_LAST_BAR);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// there isn't any Trading Day ...
|
|
// create one ...
|
|
|
|
//
|
|
XTradeDay tradeDay;
|
|
tradeDay.from = zDayBar.time;
|
|
tradeDay.to = zDayBar.GetLastBarTimeOfPeriod(mPeriod);
|
|
|
|
//
|
|
AddRef(
|
|
tradeDay,
|
|
mTradingDays //
|
|
);
|
|
|
|
//
|
|
DrawTradingDays();
|
|
|
|
//
|
|
// Notfy Day Started ...
|
|
if (zBar.time == zDayBar.time)
|
|
{
|
|
//
|
|
Add(
|
|
X_TRADE_DAY_FIRST_BAR,
|
|
state //
|
|
);
|
|
OnTradingDayEvent(X_TRADE_DAY_FIRST_BAR);
|
|
NotifyTradingDayEventListeners(X_TRADE_DAY_FIRST_BAR);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Market Session ...
|
|
int marketSessionsCount = ArraySize(mMarketSessions);
|
|
int sessionsCount = ArraySize(mSessions);
|
|
bool isSessionFound = false;
|
|
if (IsValidSize(sessionsCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < sessionsCount; i++)
|
|
{
|
|
//
|
|
XSession iSession = mSessions[i];
|
|
int marketSessionIDX = HasMarketSessionByStartTime(
|
|
iSession.session,
|
|
zBar.time //
|
|
);
|
|
|
|
//
|
|
if (!IsValidIndex(marketSessionIDX))
|
|
{
|
|
//
|
|
datetime zTimeGMT = GetUTCTime(zBar.time);
|
|
string zTimeString = GetTimeString(zTimeGMT);
|
|
|
|
//
|
|
bool isStarted = iSession.start == zTimeString;
|
|
|
|
//
|
|
if (isStarted)
|
|
{
|
|
//
|
|
XMarketSession iMarketSession;
|
|
iMarketSession.session = iSession.session;
|
|
iMarketSession.from = zBar.time;
|
|
|
|
//
|
|
int iSessionWorkingHoure = SessionOpenHours();
|
|
int iSessionWorkingSeconds = iSessionWorkingHoure * 60 * 60;
|
|
iMarketSession.to = (datetime)((int)zBar.time + iSessionWorkingSeconds);
|
|
|
|
//
|
|
isSessionFound = AddRef(
|
|
iMarketSession,
|
|
mMarketSessions //
|
|
);
|
|
|
|
//
|
|
marketSessionsCount = ArraySize(mMarketSessions);
|
|
|
|
//
|
|
DrawMarketSessions();
|
|
|
|
//
|
|
Add(
|
|
X_SESSION_FIRST_BAR,
|
|
state //
|
|
);
|
|
OnMarketSessionEvent(
|
|
iMarketSession.session,
|
|
X_SESSION_FIRST_BAR //
|
|
);
|
|
NotifyMarketSessionEventListeners(
|
|
iMarketSession.session,
|
|
X_SESSION_FIRST_BAR //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check End Time for Last Bar ...
|
|
for (int i = 0; i < marketSessionsCount; i++)
|
|
{
|
|
//
|
|
XMarketSession iMarketSession = mMarketSessions[i];
|
|
|
|
//
|
|
// Calculate Last Bar Time ...
|
|
datetime endTime = iMarketSession.to;
|
|
datetime lastBarTime = (datetime)((int)endTime - PeriodSeconds(mPeriod));
|
|
if (zBar.time == lastBarTime)
|
|
{
|
|
//
|
|
Add(
|
|
X_SESSION_LAST_BAR,
|
|
state //
|
|
);
|
|
OnMarketSessionEvent(
|
|
iMarketSession.session,
|
|
X_SESSION_LAST_BAR //
|
|
);
|
|
NotifyMarketSessionEventListeners(
|
|
iMarketSession.session,
|
|
X_SESSION_LAST_BAR //
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Detect Swing High ...
|
|
int swingHighsCount = ArraySize(mSwingHighs);
|
|
bool isSingHigh = pBar.IsSimpleSwingHigh(SwingHighThreshold());
|
|
if (isSingHigh)
|
|
{
|
|
//
|
|
AddRef(
|
|
pBar,
|
|
mSwingHighs //
|
|
);
|
|
swingHighsCount = ArraySize(mSwingHighs);
|
|
|
|
//
|
|
DrawSwingHighs();
|
|
|
|
//
|
|
Add(
|
|
X_SWING_HIGH_DETECTED,
|
|
state //
|
|
);
|
|
OnSwingHighDetected(pBar);
|
|
NotifySwingHighEventListeners(pBar);
|
|
}
|
|
|
|
//
|
|
// Detect Swing Low ...
|
|
int swingLowsCount = ArraySize(mSwingLows);
|
|
bool isSingLow = pBar.IsSimpleSwingLow(SwingLowThreshold());
|
|
if (isSingLow)
|
|
{
|
|
//
|
|
AddRef(
|
|
pBar,
|
|
mSwingLows //
|
|
);
|
|
swingLowsCount = ArraySize(mSwingLows);
|
|
|
|
//
|
|
DrawSwingLows();
|
|
|
|
//
|
|
Add(
|
|
X_SWING_LOW_DETECTED,
|
|
state //
|
|
);
|
|
OnSwingLowDetected(pBar);
|
|
NotifySwingLowEventListeners(pBar);
|
|
}
|
|
|
|
//
|
|
// Detect Momentum Bar ...
|
|
int momentumBarsCount = ArraySize(mMomentumBars);
|
|
bool isStrongBar = cBar.IsStrong(MomentumBarPercent());
|
|
bool isSharpBullish = cBar.IsSharpBullish(
|
|
MomentumBarLoopBack(),
|
|
MomentumBarSharpRatio() //
|
|
);
|
|
bool isSharpBearish = cBar.IsSharpBearish(
|
|
MomentumBarLoopBack(),
|
|
MomentumBarSharpRatio() //
|
|
);
|
|
bool isMomentumBar =
|
|
isStrongBar &&
|
|
(isSharpBearish ||
|
|
isSharpBullish);
|
|
if (isMomentumBar)
|
|
{
|
|
//
|
|
AddRef(
|
|
cBar,
|
|
mMomentumBars //
|
|
);
|
|
momentumBarsCount = ArraySize(mMomentumBars);
|
|
|
|
//
|
|
DrawMomentumBars();
|
|
|
|
//
|
|
Add(
|
|
X_MOMENTUM_BAR_DETECTED,
|
|
state //
|
|
);
|
|
OnMomentumBarDetected(pBar);
|
|
NotifyMomentumBarEventListeners(pBar);
|
|
}
|
|
|
|
//
|
|
mBarTracker.Waits();
|
|
|
|
//
|
|
result = ArraySize(state);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Enable Draw All POI(s) ...
|
|
*/
|
|
void EnableDrawPOIs()
|
|
{
|
|
//
|
|
bool state = true;
|
|
|
|
//
|
|
AllowDrawSwingLows(state);
|
|
AllowDrawSwingHighs(state);
|
|
AllowDrawTradingDays(state);
|
|
AllowDrawMomentumBars(state);
|
|
AllowDrawRejectionBars(state);
|
|
AllowDrawMarketSessions(state);
|
|
|
|
//
|
|
// Sessions ...
|
|
int sessionsCount = ArraySize(mSessions);
|
|
if (IsValidSize(sessionsCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < sessionsCount; i++)
|
|
{
|
|
//
|
|
mSessions[i].allowDraw = state;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Disable Draw All POI(s) ...
|
|
*/
|
|
void DisableDrawPOIs()
|
|
{
|
|
//
|
|
bool state = false;
|
|
|
|
//
|
|
AllowDrawSwingLows(state);
|
|
AllowDrawSwingHighs(state);
|
|
AllowDrawTradingDays(state);
|
|
AllowDrawMomentumBars(state);
|
|
AllowDrawRejectionBars(state);
|
|
AllowDrawMarketSessions(state);
|
|
|
|
//
|
|
// Sessions ...
|
|
int sessionsCount = ArraySize(mSessions);
|
|
if (IsValidSize(sessionsCount))
|
|
{
|
|
//
|
|
for (int i = 0; i < sessionsCount; i++)
|
|
{
|
|
//
|
|
mSessions[i].allowDraw = state;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Virtual Actions ...
|
|
|
|
/**
|
|
* Apply Default Configurations ...
|
|
*/
|
|
virtual void ApplyDefaultConfig()
|
|
{
|
|
//
|
|
ChartID(0);
|
|
Window(0);
|
|
|
|
//
|
|
// Trading Days ...
|
|
TradingDaysStartColor(clrYellow);
|
|
TradingDaysStartStyle(STYLE_DASHDOT);
|
|
TradingDaysEndColor(clrGray);
|
|
TradingDaysEndStyle(STYLE_DASHDOT);
|
|
|
|
//
|
|
// Sessions ...
|
|
|
|
//
|
|
// SYDNEY ...
|
|
// Start: (UTC) 21:00
|
|
// End: (UTC) 06:00
|
|
XSession mSyndeySession;
|
|
mSyndeySession.Init(
|
|
X_SYDNEY,
|
|
"20:00", // Start ...
|
|
"05:00" // End Next Day ...
|
|
);
|
|
mSyndeySession.startColor = clrFireBrick;
|
|
mSyndeySession.endColor = clrFireBrick;
|
|
mSyndeySession.allowDraw = true;
|
|
AddSession(mSyndeySession);
|
|
|
|
//
|
|
// TOKYO ...
|
|
// Start: (UTC) 12:00
|
|
// End: (UTC) 09:00
|
|
XSession mTokyoSession;
|
|
mTokyoSession.Init(
|
|
X_TOKYO,
|
|
"00:00", // Start ...
|
|
"09:00" // End Next Day ...
|
|
);
|
|
mTokyoSession.startColor = clrBlueViolet;
|
|
mTokyoSession.endColor = clrBlueViolet;
|
|
mTokyoSession.allowDraw = true;
|
|
AddSession(mTokyoSession);
|
|
|
|
//
|
|
// LONDON ...
|
|
// Start: (UTC) 07:00
|
|
// End: (UTC) 16:00
|
|
XSession mLondonSession;
|
|
mLondonSession.Init(
|
|
X_LONDON,
|
|
"07:00", // Start ...
|
|
"16:00" // End ...
|
|
);
|
|
mLondonSession.startColor = clrLime;
|
|
mLondonSession.endColor = clrLime;
|
|
mLondonSession.allowDraw = true;
|
|
AddSession(mLondonSession);
|
|
|
|
//
|
|
// NEWYORK ...
|
|
// Start: (UTC) 13:00
|
|
// End: (UTC) 22:00
|
|
XSession mNewYorkSession;
|
|
mNewYorkSession.Init(
|
|
X_NEW_YORK,
|
|
"12:00", // Start ...
|
|
"21:00" // End ...
|
|
);
|
|
mNewYorkSession.startColor = clrAqua;
|
|
mNewYorkSession.endColor = clrAqua;
|
|
mNewYorkSession.allowDraw = true;
|
|
AddSession(mNewYorkSession);
|
|
|
|
//
|
|
SessionOpenHours(9);
|
|
|
|
//
|
|
MaxNumberOfPOIs(10);
|
|
MaxNumberOfRequiredPOIs(2);
|
|
|
|
//
|
|
SwingHighWidth(5);
|
|
SwingHighThreshold(3);
|
|
SwingHighArrowCode(108);
|
|
SwingHighColor(clrMagenta);
|
|
|
|
//
|
|
SwingLowWidth(5);
|
|
SwingLowThreshold(3);
|
|
SwingLowArrowCode(108);
|
|
SwingLowColor(clrAqua);
|
|
|
|
//
|
|
MomentumBarPercent(55);
|
|
MomentumBarLoopBack(3);
|
|
MomentumBarSharpRatio(1.2);
|
|
MomentumBarWidth(5);
|
|
MomentumBarBullishArrowCode((char)225);
|
|
MomentumBarBearishArrowCode((char)226);
|
|
MomentumBarBullishColor(clrAqua);
|
|
MomentumBarBearishColor(clrMagenta);
|
|
|
|
//
|
|
RejectionBarPercent(55);
|
|
RejectionBarLoopBack(5);
|
|
RejectionBarSharpRatio(1.5);
|
|
RejectionBarWidth(5);
|
|
RejectionBarBullishArrowCode((char)217);
|
|
RejectionBarBearishArrowCode((char)218);
|
|
RejectionBarBullishColor(clrAqua);
|
|
RejectionBarBearishColor(clrMagenta);
|
|
|
|
//
|
|
}
|
|
|
|
//
|
|
// Session Configurations ...
|
|
|
|
/**
|
|
* Add Sepcific Session to Supported Sessions ...
|
|
*
|
|
* @param session: XSession instance ...
|
|
*/
|
|
void AddSession(XSession &session)
|
|
{
|
|
//
|
|
if (!session.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
AddRef(
|
|
session,
|
|
mSessions //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Event Listeners ...
|
|
|
|
/**
|
|
* Calls When new Trading Day Event Happens ...
|
|
*
|
|
* @param event: ENUM_XPOI_EVENTS member ...
|
|
*/
|
|
virtual void OnTradingDayEvent(
|
|
ENUM_XPOI_EVENTS event //
|
|
)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Register an Event Listener for New Trading Day Events ...
|
|
*
|
|
* @param listener: TXPOIEventHandler instance ...
|
|
*/
|
|
void AddTradingDayEventListener(TXPOIEventHandler listener)
|
|
{
|
|
//
|
|
Add(
|
|
listener,
|
|
mTradingDayEventListeners //
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Calls When new Market Session Event Happens ...
|
|
*
|
|
* @param session: ENUM_XSESSION member ...
|
|
* @param event: ENUM_XPOI_EVENTS member ...
|
|
*/
|
|
virtual void OnMarketSessionEvent(
|
|
ENUM_XSESSION session,
|
|
ENUM_XPOI_EVENTS event //
|
|
)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Register an Event Listener for New Market Session Events ...
|
|
*
|
|
* @param listener: TXSessionEventHandler instance ...
|
|
*/
|
|
void AddMarketSessionEventListener(TXSessionEventHandler listener)
|
|
{
|
|
//
|
|
Add(
|
|
listener,
|
|
mMarketSessionEventListeners //
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Calls When new Swing High Detected ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*/
|
|
virtual void OnSwingHighDetected(XOHCL &bar)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Register an Event Listener for New Swing High Detected ...
|
|
*
|
|
* @param listener: TXOHCLEventHandler instance ...
|
|
*/
|
|
void AddSwingHighEventListener(TXOHCLEventHandler listener)
|
|
{
|
|
//
|
|
Add(
|
|
listener,
|
|
mSwingHighEventListeners //
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Calls When new Swing Low Detected ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*/
|
|
virtual void OnSwingLowDetected(XOHCL &bar)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Register an Event Listener for New Swing Low Detected ...
|
|
*
|
|
* @param listener: TXOHCLEventHandler instance ...
|
|
*/
|
|
void AddSwingLowEventListener(TXOHCLEventHandler listener)
|
|
{
|
|
//
|
|
Add(
|
|
listener,
|
|
mSwingLowEventListeners //
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Calls When new Momentum Bar Detected ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*/
|
|
virtual void OnMomentumBarDetected(XOHCL &bar)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Register an Event Listener for New Momentum Bar Detected ...
|
|
*
|
|
* @param listener: TXOHCLEventHandler instance ...
|
|
*/
|
|
void AddMomentumBarEventListener(TXOHCLEventHandler listener)
|
|
{
|
|
//
|
|
Add(
|
|
listener,
|
|
mMomentumBarEventListeners //
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Calls When new Rejection Bar Detected ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*/
|
|
virtual void OnRejectionBarDetected(XOHCL &bar)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Register an Event Listener for New Rejection Bar Detected ...
|
|
*
|
|
* @param listener: XOHCL instance ...
|
|
*/
|
|
void AddRejectionBarEventListener(TXOHCLEventHandler listener)
|
|
{
|
|
//
|
|
Add(
|
|
listener,
|
|
mRejectionBarEventListeners //
|
|
);
|
|
}
|
|
|
|
//
|
|
protected:
|
|
//
|
|
|
|
//
|
|
// Actions ...
|
|
|
|
/**
|
|
* Lock ...
|
|
*/
|
|
void Lock()
|
|
{
|
|
mLock = true;
|
|
}
|
|
|
|
/**
|
|
* Unlock ...
|
|
*/
|
|
void Unlock()
|
|
{
|
|
mLock = false;
|
|
}
|
|
|
|
/**
|
|
* Detect Required POI(s) ...
|
|
*
|
|
* @param barIndex: Integer Start bar index ...
|
|
* 0 is Default ...
|
|
*/
|
|
void DetectRequiredPOIs(int barIndex = 0)
|
|
{
|
|
//
|
|
// Validate Reuired POI(s) ...
|
|
int requiredPOIs = MaxNumberOfRequiredPOIs();
|
|
if (requiredPOIs <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
Lock();
|
|
|
|
//
|
|
// Normalize Bar Index ...
|
|
if (barIndex < 0)
|
|
{
|
|
barIndex = 0;
|
|
}
|
|
|
|
//
|
|
bool canContinue = true;
|
|
int maxAllowedScanPrevBars = 2000;
|
|
while (canContinue)
|
|
{
|
|
//
|
|
// Define Index of Bars ...
|
|
int zIndex = barIndex;
|
|
int cIndex = zIndex + 1;
|
|
|
|
//
|
|
datetime cTime = TimeCurrent();
|
|
|
|
//
|
|
XOHCL zBar;
|
|
bool isRetrieved = mBarTracker.GetBar(zBar, zIndex);
|
|
if (!isRetrieved)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XOHCL cBar;
|
|
isRetrieved = mBarTracker.GetBar(cBar, cIndex);
|
|
if (!isRetrieved)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Detect POI(s) based On Current Bar ...
|
|
|
|
//
|
|
// XTradeDays ...
|
|
int daysCount = ArraySize(mTradingDays);
|
|
if (daysCount < requiredPOIs)
|
|
{
|
|
//
|
|
XOHCL zDayBar;
|
|
isRetrieved = zDayBar.Init(
|
|
mSymbol,
|
|
PERIOD_D1,
|
|
zIndex //
|
|
);
|
|
if (!isRetrieved)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XOHCL cDayBar;
|
|
isRetrieved = cDayBar.Init(
|
|
mSymbol,
|
|
PERIOD_D1,
|
|
cIndex //
|
|
);
|
|
if (!isRetrieved)
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
XTradeDay tradeDay;
|
|
tradeDay.from = zDayBar.time;
|
|
|
|
//
|
|
datetime lastBarTime = zDayBar.GetLastBarTimeOfPeriod(mPeriod);
|
|
tradeDay.to = lastBarTime;
|
|
|
|
//
|
|
int idx = HasTradeDay(tradeDay.from);
|
|
if (!IsValidIndex(idx))
|
|
{
|
|
//
|
|
AddRef(
|
|
tradeDay,
|
|
mTradingDays //
|
|
);
|
|
|
|
//
|
|
daysCount = ArraySize(mTradingDays);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Session ...
|
|
int sessionsCount = ArraySize(mSessions);
|
|
int marketSessionsCount = ArraySize(mMarketSessions);
|
|
if (IsValidSize(sessionsCount) &&
|
|
marketSessionsCount < sessionsCount * requiredPOIs)
|
|
{
|
|
//
|
|
for (int i = 0; i < sessionsCount; i++)
|
|
{
|
|
//
|
|
XSession iSession = mSessions[i];
|
|
int iCount = CountMarketSessions(iSession.session);
|
|
if (iCount >= requiredPOIs)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
datetime zTimeGMT = GetUTCTime(zBar.time);
|
|
string zTimeString = GetTimeString(zTimeGMT);
|
|
|
|
//
|
|
bool isStarted = iSession.start == zTimeString;
|
|
bool isEnded = iSession.end == zTimeString;
|
|
|
|
//
|
|
// Detect Sessions Based on Time ...
|
|
// Since All Session Close Times Related to Current Date and
|
|
// in Required POIs we Moving Back from Current Date ...
|
|
if (isEnded && iCount < requiredPOIs)
|
|
{
|
|
//
|
|
// Check Market Session Doesnt Exists by End Time ...
|
|
int iIDX = HasMarketSessionByEndTime(
|
|
iSession.session,
|
|
zBar.time //
|
|
);
|
|
if (!IsValidIndex(iIDX))
|
|
{
|
|
//
|
|
XMarketSession iMarketSession;
|
|
iMarketSession.session = iSession.session;
|
|
iMarketSession.to = zBar.time;
|
|
|
|
//
|
|
int iSessionWorkingHoure = SessionOpenHours();
|
|
int iSessionWorkingSeconds = iSessionWorkingHoure * 60 * 60;
|
|
iMarketSession.from = (datetime)((int)zBar.time - iSessionWorkingSeconds);
|
|
|
|
//
|
|
AddRef(
|
|
iMarketSession,
|
|
mMarketSessions //
|
|
);
|
|
|
|
//
|
|
marketSessionsCount = ArraySize(mMarketSessions);
|
|
}
|
|
}
|
|
|
|
//
|
|
}
|
|
}
|
|
|
|
//
|
|
// Swing Highs ...
|
|
int swingHighsCount = ArraySize(mSwingHighs);
|
|
if (swingHighsCount < requiredPOIs)
|
|
{
|
|
//
|
|
bool isSwingHigh = cBar.IsSimpleSwingHigh(SwingHighThreshold());
|
|
if (isSwingHigh)
|
|
{
|
|
//
|
|
AddRef(
|
|
cBar,
|
|
mSwingHighs //
|
|
);
|
|
|
|
//
|
|
swingHighsCount = ArraySize(mSwingHighs);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Swing Low ...
|
|
int swingLowsCount = ArraySize(mSwingLows);
|
|
if (swingLowsCount < requiredPOIs)
|
|
{
|
|
//
|
|
bool isSwingLow = cBar.IsSimpleSwingLow(SwingLowThreshold());
|
|
if (isSwingLow)
|
|
{
|
|
//
|
|
AddRef(
|
|
cBar,
|
|
mSwingLows //
|
|
);
|
|
|
|
//
|
|
swingLowsCount = ArraySize(mSwingLows);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Momentum Bars ...
|
|
int momentumBarsCount = ArraySize(mMomentumBars);
|
|
if (momentumBarsCount < requiredPOIs)
|
|
{
|
|
//
|
|
bool isStrongBar = cBar.IsStrong(MomentumBarPercent());
|
|
|
|
//
|
|
// Bullish ...
|
|
bool isSharpBullish = cBar.IsSharpBullish(
|
|
MomentumBarLoopBack(),
|
|
MomentumBarSharpRatio() //
|
|
);
|
|
|
|
//
|
|
// Bearish ...
|
|
bool isSharpBearish = cBar.IsSharpBearish(
|
|
MomentumBarLoopBack(),
|
|
MomentumBarSharpRatio() //
|
|
);
|
|
|
|
//
|
|
bool isMomentumBar =
|
|
isStrongBar &&
|
|
(isSharpBearish ||
|
|
isSharpBullish);
|
|
if (isMomentumBar)
|
|
{
|
|
//
|
|
AddRef(
|
|
cBar,
|
|
mMomentumBars //
|
|
);
|
|
|
|
//
|
|
momentumBarsCount = ArraySize(mMomentumBars);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Rejection Bars ...
|
|
int rejectionBarsCount = ArraySize(mRejectionBars);
|
|
if (rejectionBarsCount < requiredPOIs)
|
|
{
|
|
//
|
|
}
|
|
|
|
//
|
|
bool isNeedMoreMarketSessions = (!IsValidSize(sessionsCount)
|
|
? true
|
|
: marketSessionsCount < (sessionsCount * requiredPOIs));
|
|
canContinue =
|
|
//
|
|
daysCount < requiredPOIs ||
|
|
//
|
|
isNeedMoreMarketSessions ||
|
|
//
|
|
swingHighsCount < requiredPOIs ||
|
|
swingLowsCount < requiredPOIs ||
|
|
//
|
|
momentumBarsCount < requiredPOIs
|
|
//
|
|
;
|
|
if (canContinue)
|
|
{
|
|
barIndex++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Complete Calculations ...
|
|
|
|
//
|
|
// Reverse Trading Days ...
|
|
XTradeDay tmpDays[];
|
|
Copy(
|
|
mTradingDays,
|
|
tmpDays //
|
|
);
|
|
Clean(mTradingDays);
|
|
ArrayReverse(tmpDays);
|
|
Copy(
|
|
tmpDays,
|
|
mTradingDays //
|
|
);
|
|
Clean(tmpDays);
|
|
|
|
//
|
|
// Reverse Market Sessions ...
|
|
XMarketSession tmpSessions[];
|
|
Copy(
|
|
mMarketSessions,
|
|
tmpSessions //
|
|
);
|
|
Clean(mMarketSessions);
|
|
ArrayReverse(tmpSessions);
|
|
Copy(
|
|
tmpSessions,
|
|
mMarketSessions //
|
|
);
|
|
|
|
//
|
|
XOHCL tmpBars[];
|
|
|
|
//
|
|
// Reverse Swing Highs ...
|
|
Copy(
|
|
mSwingHighs,
|
|
tmpBars //
|
|
);
|
|
Clean(mSwingHighs);
|
|
ArrayReverse(tmpBars);
|
|
Copy(
|
|
tmpBars,
|
|
mSwingHighs //
|
|
);
|
|
Clean(tmpBars);
|
|
|
|
//
|
|
// Reverse Swing Lows ...
|
|
Copy(
|
|
mSwingLows,
|
|
tmpBars //
|
|
);
|
|
Clean(mSwingLows);
|
|
ArrayReverse(tmpBars);
|
|
Copy(
|
|
tmpBars,
|
|
mSwingLows //
|
|
);
|
|
Clean(tmpBars);
|
|
|
|
//
|
|
// Reverse Momentum Bars ...
|
|
Copy(
|
|
mMomentumBars,
|
|
tmpBars //
|
|
);
|
|
Clean(mMomentumBars);
|
|
ArrayReverse(tmpBars);
|
|
Copy(
|
|
tmpBars,
|
|
mMomentumBars //
|
|
);
|
|
Clean(tmpBars);
|
|
|
|
//
|
|
Unlock();
|
|
DrawPOIs();
|
|
}
|
|
|
|
//
|
|
// Destroy POIs ...
|
|
|
|
/**
|
|
* Destroy All POI(s) ...
|
|
*/
|
|
void DestroyPOIs()
|
|
{
|
|
//
|
|
DestroyTradingDays();
|
|
|
|
//
|
|
DestroyMarketSessions();
|
|
|
|
//
|
|
DestroySwingHighs();
|
|
DestroySwingLows();
|
|
|
|
//
|
|
DestroyMomentumBars();
|
|
|
|
//
|
|
DestroyRejectionBars();
|
|
}
|
|
|
|
/**
|
|
* Destroy Trading Days ...
|
|
*/
|
|
void DestroyTradingDays()
|
|
{
|
|
Clean(mTradingDays);
|
|
}
|
|
|
|
/**
|
|
* Destroy Swing Highs ...
|
|
*/
|
|
void DestroySwingHighs()
|
|
{
|
|
Clean(mSwingHighs);
|
|
}
|
|
|
|
/**
|
|
* Destroy Swing Lows ...
|
|
*/
|
|
void DestroySwingLows()
|
|
{
|
|
Clean(mSwingLows);
|
|
}
|
|
|
|
/**
|
|
* Destroy Momentum Bars ...
|
|
*/
|
|
void DestroyMomentumBars()
|
|
{
|
|
Clean(mMomentumBars);
|
|
}
|
|
|
|
/**
|
|
* Destroy Rejection Bars ...
|
|
*/
|
|
void DestroyRejectionBars()
|
|
{
|
|
Clean(mRejectionBars);
|
|
}
|
|
|
|
/**
|
|
* Destroy Market Sessions ...
|
|
*/
|
|
void DestroyMarketSessions()
|
|
{
|
|
Clean(mMarketSessions);
|
|
}
|
|
|
|
//
|
|
// Draw Actions ...
|
|
|
|
/**
|
|
* Draw All POI(s) ...
|
|
*/
|
|
void DrawPOIs()
|
|
{
|
|
//
|
|
DrawTradingDays();
|
|
|
|
//
|
|
DrawMarketSessions();
|
|
|
|
//
|
|
DrawSwingHighs();
|
|
DrawSwingLows();
|
|
|
|
//
|
|
DrawMomentumBars();
|
|
|
|
//
|
|
DrawRejectionBars();
|
|
}
|
|
|
|
/**
|
|
* Draw Trading Days ...
|
|
*/
|
|
void DrawTradingDays()
|
|
{
|
|
//
|
|
bool allow = AllowDrawTradingDays();
|
|
if (!allow)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mTradingDays);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XTradeDay iDay = mTradingDays[i];
|
|
|
|
//
|
|
string iName = iDay.GetTag();
|
|
int iIDX = HasObject(
|
|
iName,
|
|
mTradingDayObjects //
|
|
);
|
|
if (IsValidIndex(iIDX))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
CreateTradingDayObject(iDay, iName);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Draw Swing Highs ...
|
|
*/
|
|
void DrawSwingHighs()
|
|
{
|
|
//
|
|
bool allow = AllowDrawSwingHighs();
|
|
if (!allow)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mSwingHighs);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XOHCL iSwing = mSwingHighs[i];
|
|
|
|
//
|
|
string iName = iSwing.GetTag(ToString(X_POI_SWING_HIGH));
|
|
int iIDX = HasObject(
|
|
iName,
|
|
mSwingHighObjects //
|
|
);
|
|
if (IsValidIndex(iIDX))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
CreateSwingHighObject(iSwing, iName);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Draw Swing Lows ...
|
|
*/
|
|
void DrawSwingLows()
|
|
{
|
|
//
|
|
bool allow = AllowDrawSwingLows();
|
|
if (!allow)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mSwingLows);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XOHCL iSwing = mSwingLows[i];
|
|
|
|
//
|
|
string iName = iSwing.GetTag(ToString(X_POI_SWING_LOW));
|
|
int iIDX = HasObject(
|
|
iName,
|
|
mSwingLowObjects //
|
|
);
|
|
if (IsValidIndex(iIDX))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
CreateSwingLowObject(iSwing, iName);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Draw Momentum Bars ...
|
|
*/
|
|
void DrawMomentumBars()
|
|
{
|
|
//
|
|
bool allow = AllowDrawMomentumBars();
|
|
if (!allow)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mMomentumBars);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XOHCL iBar = mMomentumBars[i];
|
|
|
|
//
|
|
string iName = iBar.GetTag(ToString(X_POI_MOMENTUM_BAR));
|
|
int iIDX = HasObject(
|
|
iName,
|
|
mMomentumBarObjects //
|
|
);
|
|
if (IsValidIndex(iIDX))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
CreateMomentumBarObject(iBar, iName);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Draw Rejection Bars ...
|
|
*/
|
|
void DrawRejectionBars()
|
|
{
|
|
//
|
|
// TODO: Implement Rejection Bars ...
|
|
}
|
|
|
|
/**
|
|
* Draw Market Sessions ...
|
|
*/
|
|
void DrawMarketSessions()
|
|
{
|
|
//
|
|
bool allow = AllowDrawMarketSessions();
|
|
if (!allow)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mMarketSessions);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XMarketSession iMarketSession = mMarketSessions[i];
|
|
|
|
//
|
|
string iName = iMarketSession.GetTag();
|
|
int iIDX = HasObject(
|
|
iName,
|
|
mMarketSessionObjects //
|
|
);
|
|
if (IsValidIndex(iIDX))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
CreateMarketSessionObject(iMarketSession, iName);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
/**
|
|
* Clean All Drawn Objects ...
|
|
*/
|
|
void DestroyObjects()
|
|
{
|
|
//
|
|
DestroySwingLowObjects();
|
|
DestroySwingHighObjects();
|
|
DestroyTradingTradingDayObjects();
|
|
DestroyMomentumBarObjects();
|
|
DestroyRejectionBarObjects();
|
|
DestroyMarketSessionObjects();
|
|
}
|
|
|
|
/**
|
|
* Clean Swing Highs Drawn Objects ...
|
|
*/
|
|
void DestroySwingHighObjects()
|
|
{
|
|
mSwingHighObjects.Clear();
|
|
}
|
|
|
|
/**
|
|
* Clean Swing Lows Drawn Objects ...
|
|
*/
|
|
void DestroySwingLowObjects()
|
|
{
|
|
mSwingLowObjects.Clear();
|
|
}
|
|
|
|
/**
|
|
* Clean Momentum Bars Drawn Objects ...
|
|
*/
|
|
void DestroyMomentumBarObjects()
|
|
{
|
|
mMomentumBarObjects.Clear();
|
|
}
|
|
|
|
/**
|
|
* Clean Rejection Bars Drawn Objects ...
|
|
*/
|
|
void DestroyRejectionBarObjects()
|
|
{
|
|
mRejectionBarObjects.Clear();
|
|
}
|
|
|
|
/**
|
|
* Clean Trading Day Drawn Objects ...
|
|
*/
|
|
void DestroyTradingTradingDayObjects()
|
|
{
|
|
mTradingDayObjects.Clear();
|
|
}
|
|
|
|
/**
|
|
* Destroy Market Sessions Drawn Objects ...
|
|
*/
|
|
void DestroyMarketSessionObjects()
|
|
{
|
|
mMarketSessionObjects.Clear();
|
|
}
|
|
|
|
//
|
|
|
|
/**
|
|
* Detect an Object Exists in Array or not ...
|
|
*
|
|
* @param name: String ...
|
|
* @param array: CArrayObj instance ...
|
|
*
|
|
* @return ( int ): index of Object ...
|
|
*/
|
|
int HasObject(
|
|
string name,
|
|
CArrayObj &array //
|
|
)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
if (!IsValid(name))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int count = array.Total();
|
|
if (!IsValidSize(count))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
CChartObject iObj = array.At(i);
|
|
|
|
//
|
|
if (iObj.Name() == name)
|
|
{
|
|
//
|
|
result = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Event Handler Notifiers ...
|
|
|
|
/**
|
|
* Notify New Trading Day Event Handlers ...
|
|
*
|
|
* @param event: ENUM_XPOI_EVENTS member ...
|
|
*/
|
|
void NotifyTradingDayEventListeners(
|
|
ENUM_XPOI_EVENTS event //
|
|
)
|
|
{
|
|
//
|
|
int count = ArraySize(mTradingDayEventListeners);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
TXPOIEventHandler iListener = mTradingDayEventListeners[i];
|
|
iListener(event);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notify New Market Session Event Handlers ...
|
|
*
|
|
* @param session: ENUM_XSESSION member ...
|
|
* @param event: ENUM_XPOI_EVENTS member ...
|
|
*/
|
|
void NotifyMarketSessionEventListeners(
|
|
ENUM_XSESSION session,
|
|
ENUM_XPOI_EVENTS event //
|
|
)
|
|
{
|
|
//
|
|
int count = ArraySize(mMarketSessionEventListeners);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
TXSessionEventHandler iListener = mMarketSessionEventListeners[i];
|
|
iListener(session, event);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notify New Swing High Point Event Handlers ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*/
|
|
void NotifySwingHighEventListeners(XOHCL &bar)
|
|
{
|
|
//
|
|
if (!bar.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mSwingHighEventListeners);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
TXOHCLEventHandler iListener = mSwingHighEventListeners[i];
|
|
iListener(bar);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notify New Swing Low Point Event Handlers ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*/
|
|
void NotifySwingLowEventListeners(XOHCL &bar)
|
|
{
|
|
//
|
|
if (!bar.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mSwingLowEventListeners);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
TXOHCLEventHandler iListener = mSwingLowEventListeners[i];
|
|
iListener(bar);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notify New Momentum Bar Event Handlers ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*/
|
|
void NotifyMomentumBarEventListeners(XOHCL &bar)
|
|
{
|
|
//
|
|
if (!bar.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mMomentumBarEventListeners);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
TXOHCLEventHandler iListener = mMomentumBarEventListeners[i];
|
|
iListener(bar);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notify New Rejection Bar Event Handlers ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
*/
|
|
void NotifyRejectionBarEventListeners(XOHCL &bar)
|
|
{
|
|
//
|
|
if (!bar.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mRejectionBarEventListeners);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
TXOHCLEventHandler iListener = mRejectionBarEventListeners[i];
|
|
iListener(bar);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Destroy all Registered Event Listeners ...
|
|
*/
|
|
void DestroyEventListeners()
|
|
{
|
|
//
|
|
Clean(mSwingLowEventListeners);
|
|
Clean(mSwingHighEventListeners);
|
|
Clean(mTradingDayEventListeners);
|
|
Clean(mMomentumBarEventListeners);
|
|
Clean(mRejectionBarEventListeners);
|
|
Clean(mMarketSessionEventListeners);
|
|
}
|
|
|
|
//
|
|
// Session ...
|
|
|
|
/**
|
|
* Find Specific Session Index ...
|
|
*
|
|
* @param session: ENUM_XSESSION member ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int FindSession(ENUM_XSESSION session)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
int count = ArraySize(mSessions);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XSession iSession = mSessions[i];
|
|
|
|
//
|
|
if (iSession.session == session)
|
|
{
|
|
//
|
|
result = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Destroy Sessions ...
|
|
*/
|
|
void DestroySessions()
|
|
{
|
|
Clean(mSessions);
|
|
}
|
|
|
|
//
|
|
|
|
/**
|
|
* Find Specified Trade Day based on Start Time ...
|
|
*
|
|
* @param start: DateTime ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int HasTradeDay(datetime start)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
if (!IsValid(start))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mTradingDays);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XTradeDay iDay = mTradingDays[i];
|
|
|
|
//
|
|
if (iDay.from == start)
|
|
{
|
|
//
|
|
result = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Find Specified Trade Day based on End Time ...
|
|
*
|
|
* @param start: DateTime ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int HasTradeDayBayEndTime(datetime end)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
if (!IsValid(end))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mTradingDays);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XTradeDay iDay = mTradingDays[i];
|
|
|
|
//
|
|
if (iDay.to == end)
|
|
{
|
|
//
|
|
result = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
|
|
/**
|
|
* Find Market Session by Providing Start Time ...
|
|
*
|
|
* @param session: ENUM_XSESSION member ...
|
|
* @param start: DateTime ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int HasMarketSessionByStartTime(
|
|
ENUM_XSESSION session,
|
|
datetime start //
|
|
)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
if (!IsValid(start))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mMarketSessions);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XMarketSession iMarketSession = mMarketSessions[i];
|
|
|
|
//
|
|
if (iMarketSession.session == session &&
|
|
iMarketSession.from == start)
|
|
{
|
|
//
|
|
result = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Find Market Session by Providing Start Time ...
|
|
*
|
|
* @param session: ENUM_XSESSION member ...
|
|
* @param end: DateTime ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int HasMarketSessionByEndTime(
|
|
ENUM_XSESSION session,
|
|
datetime end //
|
|
)
|
|
{
|
|
//
|
|
int result = -1;
|
|
|
|
//
|
|
if (!IsValid(end))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int count = ArraySize(mMarketSessions);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XMarketSession iMarketSession = mMarketSessions[i];
|
|
|
|
//
|
|
if (iMarketSession.session == session &&
|
|
iMarketSession.to == end)
|
|
{
|
|
//
|
|
result = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Count Specified Market Sessions ...
|
|
*
|
|
* @param session: ENUM_XSESSION member ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int CountMarketSessions(ENUM_XSESSION session)
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
int count = ArraySize(mMarketSessions);
|
|
if (!IsValidSize(count))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XMarketSession iMarketSession = mMarketSessions[i];
|
|
|
|
//
|
|
if (iMarketSession.session == session)
|
|
{
|
|
result++;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
private:
|
|
//
|
|
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
bool mLock; // Lock State ...
|
|
string mSymbol; // Market Symbol ...
|
|
ENUM_TIMEFRAMES mPeriod; // Market Period ...
|
|
long mChartID; // Chart ID ...
|
|
int mWindow; // Window ID ...
|
|
int mMaxNumberOfPOIs; // Max Allowed Number of POI(s) which Can Holds ...
|
|
int mMaxNumberOfRequiredPOIs; // Max Allowed Number of POI(s) which Must Find at Initializion Time ...
|
|
|
|
//
|
|
XBarTracker mBarTracker; // Market Bar Tracker ...
|
|
|
|
//
|
|
bool mAllowDrawTradingDays; // Draw Trading Days ...
|
|
color mTradingDaysStartColor; // Trading Days Start Color ...
|
|
ENUM_LINE_STYLE mTradingDaysStartStyle; // Trading Days Start Style ...
|
|
color mTradingDaysEndColor; // Trading Days End Color ...
|
|
ENUM_LINE_STYLE mTradingDaysEndStyle; // Trading Days End Style ...
|
|
XTradeDay mTradingDays[]; // Trading Days ...
|
|
CArrayObj mTradingDayObjects; // Trading Day Chart Objects ...
|
|
TXPOIEventHandler mTradingDayEventListeners[]; // Trading Day Event Listeners ...
|
|
|
|
/**
|
|
* Create an Object to Represent Trading Day on Chart ...
|
|
*
|
|
* @param day: XTradeDay instance ...
|
|
* @param name: String ...
|
|
*/
|
|
void CreateTradingDayObject(
|
|
XTradeDay &day,
|
|
string name //
|
|
)
|
|
{
|
|
//
|
|
if (!day.IsValid() ||
|
|
!IsValid(name))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
XCTardeDayObject *iObj;
|
|
iObj = new XCTardeDayObject();
|
|
bool isCreated = iObj.CreateByDay(
|
|
ChartID(),
|
|
name,
|
|
Window(),
|
|
day //
|
|
);
|
|
if (!isCreated)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
iObj.FromColor(TradingDaysStartColor());
|
|
iObj.FromStyle(TradingDaysStartStyle());
|
|
|
|
//
|
|
iObj.ToColor(TradingDaysEndColor());
|
|
iObj.ToStyle(TradingDaysEndStyle());
|
|
|
|
//
|
|
mTradingDayObjects.Add(iObj);
|
|
}
|
|
|
|
//
|
|
// Configure Sessions ...
|
|
bool mAllowDrawMarketSessions; // Draw Market Sessions ...
|
|
int mSessionOpenHours; // How many Hours a Session is Open
|
|
XSession mSessions[]; // Forex Sessions
|
|
XMarketSession mMarketSessions[]; // Founded Market Sessions ...
|
|
CArrayObj mMarketSessionObjects; // Founded Market Session Chart Ojects ...
|
|
TXSessionEventHandler mMarketSessionEventListeners[]; // Market Sessions Event Listeners ...
|
|
|
|
/**
|
|
* Create an Object to Represent Market Session on Chart ...
|
|
*
|
|
* @param session: XMarketSession instance ...
|
|
* @param name: String ...
|
|
*/
|
|
void CreateMarketSessionObject(
|
|
XMarketSession &session,
|
|
string name //
|
|
)
|
|
{
|
|
//
|
|
if (!session.IsValid() ||
|
|
!IsValid(name))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Find XSession Instance ...
|
|
int sessionIDX = FindSession(session.session);
|
|
if (!IsValidIndex(sessionIDX) ||
|
|
!mSessions[sessionIDX].allowDraw)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
XCMarketSessionObject *iObj;
|
|
iObj = new XCMarketSessionObject();
|
|
bool isCreated = iObj.CreateByMarketSession(
|
|
ChartID(),
|
|
name,
|
|
Window(),
|
|
session //
|
|
);
|
|
if (!isCreated)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
iObj.FromColor(mSessions[sessionIDX].startColor);
|
|
iObj.FromStyle(mSessions[sessionIDX].startStyle);
|
|
|
|
//
|
|
iObj.ToColor(mSessions[sessionIDX].endColor);
|
|
iObj.ToStyle(mSessions[sessionIDX].endStyle);
|
|
|
|
//
|
|
mMarketSessionObjects.Add(iObj);
|
|
}
|
|
|
|
//
|
|
// POI Holders ...
|
|
|
|
//
|
|
// Swing Highs ...
|
|
|
|
bool mAllowDrawSwingHighs; // Draw Swing Highs ...
|
|
char mSwingHighArrowCode; // Swing High Arrow Code ...
|
|
color mSwingHighColor; // Swing High Color ...
|
|
int mSwingHighWidth; // Swing High Width ...
|
|
double mSwingHighThreshold; // Threshold Required for Swing High Detection ...
|
|
XOHCL mSwingHighs[]; // Swing Highs ...
|
|
CArrayObj mSwingHighObjects; // Swing High Chart Objects ...
|
|
TXOHCLEventHandler mSwingHighEventListeners[]; // Swing High Event Listeners ...
|
|
|
|
/**
|
|
* Create an Object to Represent Swing High on Chart ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param name: String ...
|
|
*/
|
|
void CreateSwingHighObject(
|
|
XOHCL &bar,
|
|
string name //
|
|
)
|
|
{
|
|
//
|
|
if (!bar.IsValid() ||
|
|
!IsValid(name))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
CChartObjectArrow *iObj;
|
|
iObj = new CChartObjectArrow();
|
|
bool isCreated = iObj.Create(
|
|
ChartID(),
|
|
name,
|
|
Window(),
|
|
bar.time,
|
|
bar.high,
|
|
SwingHighArrowCode() //
|
|
);
|
|
if (!isCreated)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Configure Object ...
|
|
iObj.Width(SwingHighWidth());
|
|
iObj.Color(SwingHighColor());
|
|
iObj.Anchor(ANCHOR_BOTTOM);
|
|
|
|
//
|
|
mSwingHighObjects.Add(iObj);
|
|
}
|
|
|
|
//
|
|
// Swing Lows ...
|
|
|
|
bool mAllowDrawSwingLows; // Draw Swing Lows ...
|
|
char mSwingLowArrowCode; // Swing Low Arrow Code ...
|
|
color mSwingLowColor; // Swing Low Color ...
|
|
int mSwingLowWidth; // Swing Low Width ...
|
|
double mSwingLowThreshold; // Threshold Required for Swing Low Detection ...
|
|
XOHCL mSwingLows[]; // Swing Lows ...
|
|
CArrayObj mSwingLowObjects; // Swing Low Chart Objects ...
|
|
TXOHCLEventHandler mSwingLowEventListeners[]; // Swing Low Event Listeners ...
|
|
|
|
/**
|
|
* Create an Object to Represent Swing Low on Chart ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param name: String ...
|
|
*/
|
|
void CreateSwingLowObject(
|
|
XOHCL &bar,
|
|
string name //
|
|
)
|
|
{
|
|
//
|
|
if (!bar.IsValid() ||
|
|
!IsValid(name))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
CChartObjectArrow *iObj;
|
|
iObj = new CChartObjectArrow();
|
|
bool isCreated = iObj.Create(
|
|
ChartID(),
|
|
name,
|
|
Window(),
|
|
bar.time,
|
|
bar.low,
|
|
SwingLowArrowCode() //
|
|
);
|
|
if (!isCreated)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Configure Object ...
|
|
iObj.Width(SwingLowWidth());
|
|
iObj.Color(SwingLowColor());
|
|
iObj.Anchor(ANCHOR_TOP);
|
|
|
|
//
|
|
mSwingLowObjects.Add(iObj);
|
|
}
|
|
|
|
//
|
|
// Momentum Bar ...
|
|
|
|
bool mAllowDrawMomentumBars; // Draw Momentum Bars ...
|
|
int mMomentumBarPercent; // Momentum Bar Percent ...
|
|
double mMomentumBarSharpRatio; // Momentum Bar Sharp Ratio ...
|
|
int mMomentumBarLoopBack; // Momentum Bar Loopback ...
|
|
int mMomentumBarWidth; // Momentum Bar Width ...
|
|
char mMomentumBarBullishArrowCode; // Bullish Momentum Bar Arrow Code ...
|
|
char mMomentumBarBearishArrowCode; // Bullish Momentum Bar Color ...
|
|
color mMomentumBarBullishColor; // Bearish Momentum Bar Arrow Code ...
|
|
color mMomentumBarBearishColor; // Bearish Momentum Bar Color ...
|
|
XOHCL mMomentumBars[]; // Momentum Bars ...
|
|
CArrayObj mMomentumBarObjects; // Momentm Bar Chart Objects ...
|
|
TXOHCLEventHandler mMomentumBarEventListeners[]; // Momentum Bars Event Listeners ...
|
|
|
|
/**
|
|
* Create an Object to Represent Momentum Bar on Chart ...
|
|
*
|
|
* @param bar: XOHCL instance ...
|
|
* @param name: String ...
|
|
*/
|
|
void CreateMomentumBarObject(
|
|
XOHCL &bar,
|
|
string name //
|
|
)
|
|
{
|
|
//
|
|
if (!bar.IsValid() ||
|
|
!IsValid(name))
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
bool isBullish = bar.IsBullish();
|
|
double price =
|
|
isBullish
|
|
? bar.low
|
|
: bar.high;
|
|
char arrowCode =
|
|
isBullish
|
|
? MomentumBarBullishArrowCode()
|
|
: MomentumBarBearishArrowCode();
|
|
color clr =
|
|
isBullish
|
|
? MomentumBarBullishColor()
|
|
: MomentumBarBearishColor();
|
|
ENUM_ARROW_ANCHOR anchor =
|
|
isBullish
|
|
? ANCHOR_TOP
|
|
: ANCHOR_BOTTOM;
|
|
|
|
//
|
|
CChartObjectArrow *iObj;
|
|
iObj = new CChartObjectArrow();
|
|
bool isCreated = iObj.Create(
|
|
ChartID(),
|
|
name,
|
|
Window(),
|
|
bar.time,
|
|
price,
|
|
arrowCode //
|
|
);
|
|
if (!isCreated)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Configure Object ...
|
|
iObj.Width(MomentumBarWidth());
|
|
iObj.Color(clr);
|
|
iObj.Anchor(anchor);
|
|
|
|
//
|
|
mMomentumBarObjects.Add(iObj);
|
|
}
|
|
|
|
//
|
|
// Rejection Bar ....
|
|
bool mAllowDrawRejectionBars; // Draw Rejection Bars ...
|
|
int mRejectionBarPercent; // Rejection Bar Percent ...
|
|
double mRejectionBarSharpRatio; // Rejection Bar Sharp Ratio ...
|
|
int mRejectionBarLoopBack; // Rejection Bar Loopback ...
|
|
int mRejectionBarWidth; // Rejection Bar Width ...
|
|
char mRejectionBarBullishArrowCode; // Bullish Rejection Bar Arrow Code ...
|
|
char mRejectionBarBearishArrowCode; // Bullish Rejection Bar Color ...
|
|
color mRejectionBarBullishColor; // Bearish Rejection Bar Arrow Code ...
|
|
color mRejectionBarBearishColor; // Bearish Rejection Bar Color ...
|
|
XOHCL mRejectionBars[]; // Rejection Bars ...
|
|
CArrayObj mRejectionBarObjects; // Rejection Bar Chart Objects ...
|
|
TXOHCLEventHandler mRejectionBarEventListeners[]; // Rejection Bars Event Listeners ...
|
|
|
|
//
|
|
};
|
|
|
|
// |