2020 lines
47 KiB
Plaintext
2020 lines
47 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Indicator
|
|
// -------------------------------------------------
|
|
// Name: X121 XWZ
|
|
// Description: XWZ ...
|
|
//
|
|
//
|
|
// Maintainer:
|
|
// ------------
|
|
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
|
|
//
|
|
//////////////////////////////////////////////////////
|
|
//
|
|
// Global Properties ...
|
|
#property copyright "Copyright 2023, SaherElm IT Center"
|
|
#property link "https://saherelm.ir"
|
|
#property version "1.00"
|
|
#property description "SaherElm X121 XWZ Indicator"
|
|
#property strict
|
|
|
|
//
|
|
// Definitions ...
|
|
|
|
//
|
|
enum ENUM_XWZ_REJECTION_TYPES
|
|
{
|
|
XWZ_REJECTION_BAR, // Only Bar Reject
|
|
XWZ_REJECTION_STRONG_BAR, // Directional Bar Reject
|
|
XWZ_REJECTION_PRESSURED_BAR, // Bar Reject using Pressure
|
|
XWZ_REJECTION_STRONG_PRESSURED_BAR, // Strong Bar Reject using Pressure
|
|
};
|
|
|
|
//
|
|
#define ShortName "X121 XWZ"
|
|
|
|
//
|
|
// Includes Common Library ...
|
|
#include "../Classes/x-saherelm.x-bar.analyser.class.mq5"
|
|
#include "../Classes/x-saherelm.x-poi.drawer.class.mq5"
|
|
#include "../Libraries/x-saherelm.common.lib.mq5"
|
|
|
|
//
|
|
// Inputs ...
|
|
|
|
//
|
|
// Market ...
|
|
input group "Market";
|
|
|
|
//
|
|
input group "Calculation";
|
|
input ENUM_APPLIED_PRICE appliedTo = PRICE_CLOSE; // Detect Price Type
|
|
input ENUM_XWZ_REJECTION_TYPES rejectionType = XWZ_REJECTION_STRONG_BAR; // Rejection Type
|
|
input int rejectionVerificationLength = 3; // Rejection Verification Length
|
|
|
|
//
|
|
input group "MA Detection";
|
|
input int maLength = 20; // MA Length
|
|
input ENUM_MA_METHOD maMethod = MODE_EMA; // MA Method
|
|
|
|
//
|
|
input group "ATR StopLoss";
|
|
input int atrLength = 14; // ATR Length
|
|
input int atrMultiplier = 2; // ATR Multiplier
|
|
|
|
//
|
|
input group "ADX Detection";
|
|
input int adxLength = 14; // ADX Length
|
|
input double adxThreshold = 25; // ADX Threshold for Strong Trends
|
|
|
|
//
|
|
// Presentation ...
|
|
input group "Presentation";
|
|
|
|
//
|
|
input int startCalculationForLastBars = 1000; // Calculate Last n Bars
|
|
input int upTrendArrowCode = 233; // Up Trend Arrow Code
|
|
input int downTrendArrowCode = 234; // Down Trend Arrow Code
|
|
input int longRejectArrowCode = 225; // Long Reject Arrow Code
|
|
input int shortRejectArrowCode = 226; // Short Reject Arrow Code
|
|
|
|
//
|
|
input bool showMA = true; // Show Moving Average
|
|
input bool showLongSL = true; // Show Long SL
|
|
input bool showShortSL = true; // Show Short SL
|
|
input bool showUpTrend = true; // Show Up Trend
|
|
input bool showDownTrend = true; // Show Down Trend
|
|
input bool showLongReject = true; // Show Long Reject
|
|
input bool showShortReject = true; // Show Short Reject
|
|
|
|
//
|
|
input bool showPOIs = false; // Draw POI(s) ...
|
|
input bool showActivatedPOIs = false; // Draw Activated POI(s) ...
|
|
input bool showBullishOrderBlocks = true; // Draw Bullish Order Blocks ...
|
|
input bool showBearishOrderBlocks = true; // Draw Bearish Order Blocks ...
|
|
input bool showBullishFairValueGaps = true; // Draw Bullish Fair Value Gaps ...
|
|
input bool showBearishFairValueGaps = true; // Draw Bearish Fair Value Gaps ...
|
|
input bool showSupplyZones = true; // Draw Supply Zones ...
|
|
input bool showDemandZones = true; // Draw Demand Zones ...
|
|
input bool showSupportZones = true; // Draw Support Zones ...
|
|
input bool showResistanceZones = true; // Draw Resistance Zones ...
|
|
|
|
//
|
|
#property indicator_chart_window
|
|
|
|
//
|
|
#property indicator_buffers 8
|
|
#property indicator_plots 7
|
|
|
|
//
|
|
// Plot Buffers ...
|
|
|
|
//
|
|
#define maBufferIndex 0
|
|
double maBuffer[];
|
|
|
|
//
|
|
#property indicator_label1 "X121 XWZ MA"
|
|
#property indicator_type1 DRAW_LINE
|
|
#property indicator_color1 clrLightSkyBlue
|
|
#property indicator_style1 STYLE_SOLID
|
|
#property indicator_width1 2
|
|
|
|
//
|
|
#define longSLBufferIndex 1
|
|
double longSLBuffer[];
|
|
|
|
//
|
|
#property indicator_label2 "X121 XWZ Long SL"
|
|
#property indicator_type2 DRAW_LINE
|
|
#property indicator_color2 clrOrange
|
|
#property indicator_style2 STYLE_SOLID
|
|
#property indicator_width2 1
|
|
|
|
//
|
|
#define shortSLBufferIndex 2
|
|
double shortSLBuffer[];
|
|
|
|
//
|
|
#property indicator_label3 "X121 XWZ Short SL"
|
|
#property indicator_type3 DRAW_LINE
|
|
#property indicator_color3 clrOrange
|
|
#property indicator_style3 STYLE_SOLID
|
|
#property indicator_width3 1
|
|
|
|
//
|
|
#define longRejectBufferIndex 3
|
|
double longRejectBuffer[];
|
|
|
|
//
|
|
#property indicator_label4 "X121 XWZ Long Reject"
|
|
#property indicator_type4 DRAW_ARROW
|
|
#property indicator_color4 clrLime
|
|
#property indicator_style4 STYLE_SOLID
|
|
#property indicator_width4 1
|
|
|
|
//
|
|
#define shortRejectBufferIndex 4
|
|
double shortRejectBuffer[];
|
|
|
|
//
|
|
#property indicator_label5 "X121 XWZ Short Reject"
|
|
#property indicator_type5 DRAW_ARROW
|
|
#property indicator_color5 clrRed
|
|
#property indicator_style5 STYLE_SOLID
|
|
#property indicator_width5 1
|
|
|
|
//
|
|
#define upTrendBufferIndex 5
|
|
double upTrendBuffer[];
|
|
|
|
//
|
|
#property indicator_label6 "X121 XTREND Up"
|
|
#property indicator_type6 DRAW_ARROW
|
|
#property indicator_color6 clrAqua
|
|
#property indicator_width6 1
|
|
|
|
//
|
|
#define downTrendBufferIndex 6
|
|
double downTrendBuffer[];
|
|
|
|
//
|
|
#property indicator_label7 "X121 XTREND Down"
|
|
#property indicator_type7 DRAW_ARROW
|
|
#property indicator_color7 clrMagenta
|
|
#property indicator_width7 1
|
|
|
|
//
|
|
// Data Buffers ...
|
|
|
|
//
|
|
int mLastBufferIndex = 6;
|
|
|
|
//
|
|
#define atrBufferIndex mLastBufferIndex + 1
|
|
double atrBuffer[];
|
|
|
|
//
|
|
#define adxBufferIndex mLastBufferIndex + 2
|
|
double adxBuffer[];
|
|
|
|
//
|
|
// Variables, Properties and etc ...
|
|
|
|
//
|
|
// this counts Available Bars ...
|
|
int limit;
|
|
|
|
//
|
|
int maxLength;
|
|
|
|
//
|
|
// MA Handler ...
|
|
int maHandler = INVALID_HANDLE;
|
|
|
|
//
|
|
// ATR Handler ...
|
|
int atrHandler = INVALID_HANDLE;
|
|
|
|
//
|
|
// ADX Handler ...
|
|
int adxHandler = INVALID_HANDLE;
|
|
|
|
//
|
|
CArrayObj mXWZDrawnObjects;
|
|
XCPOIDrawer *mXWZPOIDrawer;
|
|
XCBarAnalyser *mXWZBarAnalyser;
|
|
|
|
//
|
|
datetime lastBullishTrend = NULL;
|
|
datetime lastBearishTrend = NULL;
|
|
|
|
//
|
|
// Un Activated POI(s) ...
|
|
XCFVG *mXWZUnActivatedFVGs[];
|
|
XCOrderBlock *mXWZUnActivatedOBs[];
|
|
XCSupplyZone *mXWZUnActivatedSupplyZones[];
|
|
XCDemandZone *mXWZUnActivatedDemandZones[];
|
|
XCSupportZone *mXWZUnActivatedSupportZones[];
|
|
XCResistanceZone *mXWZUnActivatedResistanceZones[];
|
|
|
|
//
|
|
// Activated POI(s) ...
|
|
XCFVG *mXWZActivatedFVGs[];
|
|
XCOrderBlock *mXWZActivatedOBs[];
|
|
XCSupplyZone *mXWZActivatedSupplyZones[];
|
|
XCDemandZone *mXWZActivatedDemandZones[];
|
|
XCSupportZone *mXWZActivatedSupportZones[];
|
|
XCResistanceZone *mXWZActivatedResistanceZones[];
|
|
|
|
//
|
|
// Event Handlers ...
|
|
|
|
/**
|
|
* Initialize Indicator ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int OnInit()
|
|
{
|
|
//
|
|
mXWZDrawnObjects.Clear();
|
|
|
|
//
|
|
// Validate Inputs ...
|
|
if (!ValidateInputs())
|
|
{
|
|
return INIT_PARAMETERS_INCORRECT;
|
|
}
|
|
|
|
//
|
|
// Initialize Indicator Handlers ...
|
|
|
|
//
|
|
// MA ...
|
|
maHandler = iMA(
|
|
_Symbol,
|
|
_Period,
|
|
maLength,
|
|
0,
|
|
maMethod,
|
|
appliedTo //
|
|
);
|
|
bool isInited = maHandler != INVALID_HANDLE;
|
|
if (!isInited)
|
|
{
|
|
return INIT_FAILED;
|
|
}
|
|
|
|
//
|
|
// ATR ...
|
|
atrHandler = iATR(
|
|
_Symbol,
|
|
_Period,
|
|
atrLength //
|
|
);
|
|
isInited = maHandler != INVALID_HANDLE;
|
|
if (!isInited)
|
|
{
|
|
return INIT_FAILED;
|
|
}
|
|
|
|
//
|
|
// ADX ...
|
|
adxHandler = iADX(
|
|
_Symbol,
|
|
_Period,
|
|
adxLength //
|
|
);
|
|
isInited = maHandler != INVALID_HANDLE;
|
|
if (!isInited)
|
|
{
|
|
return INIT_FAILED;
|
|
}
|
|
|
|
//
|
|
// because in some cases we may have more than one input for
|
|
// calculation and we must prevent any calculation
|
|
// untill we pass the biggest input length, here we get max Input length
|
|
// and then wait until pass it ...
|
|
maxLength = ExtractMaxLengthOfInputs();
|
|
|
|
//
|
|
// Define Index Buffers ...
|
|
DefineBuffers();
|
|
|
|
//
|
|
// Set Indicator ShortName ...
|
|
SetIndicatorName();
|
|
IndicatorSetInteger(INDICATOR_DIGITS, 2);
|
|
|
|
//
|
|
mXWZPOIDrawer = new XCPOIDrawer();
|
|
mXWZBarAnalyser = new XCBarAnalyser();
|
|
|
|
//
|
|
// Init Succeed ...
|
|
return INIT_SUCCEEDED;
|
|
}
|
|
|
|
/**
|
|
* De Initialize Indicator ...
|
|
*
|
|
* @param reason: Integer, De Initialization Reason ...
|
|
*/
|
|
void OnDeinit(const int reason)
|
|
{
|
|
//
|
|
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
|
|
// REASON_REMOVE 1 Program removed from a chart
|
|
// REASON_RECOMPILE 2 Program recompiled
|
|
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
|
|
// REASON_CHARTCLOSE 4 Chart closed
|
|
// REASON_PARAMETERS 5 Inputs changed by a user
|
|
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
|
|
// REASON_TEMPLATE 7 Another chart template applied
|
|
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
|
|
// REASON_CLOSE 9 Terminal closed
|
|
|
|
//
|
|
IndicatorRelease(maHandler);
|
|
IndicatorRelease(atrHandler);
|
|
IndicatorRelease(adxHandler);
|
|
|
|
//
|
|
mXWZDrawnObjects.Clear();
|
|
|
|
//
|
|
ZeroMemory(mXWZPOIDrawer);
|
|
ZeroMemory(mXWZBarAnalyser);
|
|
|
|
//
|
|
Clean(mXWZActivatedFVGs);
|
|
Clean(mXWZActivatedOBs);
|
|
Clean(mXWZActivatedSupplyZones);
|
|
Clean(mXWZActivatedDemandZones);
|
|
Clean(mXWZActivatedSupportZones);
|
|
Clean(mXWZActivatedResistanceZones);
|
|
|
|
//
|
|
Clean(mXWZUnActivatedOBs);
|
|
Clean(mXWZUnActivatedFVGs);
|
|
Clean(mXWZUnActivatedSupplyZones);
|
|
Clean(mXWZUnActivatedDemandZones);
|
|
Clean(mXWZUnActivatedSupportZones);
|
|
Clean(mXWZUnActivatedResistanceZones);
|
|
}
|
|
|
|
/**
|
|
* Calculate Bars ...
|
|
*
|
|
* @param rates_total: Integer, Total Bars on Chart ...
|
|
* @param prev_calculated: Integer, Total Calculated Bars on Charts ...
|
|
* @param time: DateTime Array, History of Open Time ...
|
|
* @param open: Double Array, History of Open Prices ...
|
|
* @param high: Double Array, History of High Prices ...
|
|
* @param low: Double Array, History of Low Prices ...
|
|
* @param close: Double Array, History of Close Prices ...
|
|
* @param tick_volume: Long, History of Tick Volumes on Bar ...
|
|
* @param volume: Long, History of Trade Volumes ...
|
|
* @param spread: Double, History of Spread Price ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int OnCalculate(
|
|
const int rates_total,
|
|
const int prev_calculated,
|
|
const datetime &time[],
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &low[],
|
|
const double &close[],
|
|
const long &tick_volume[],
|
|
const long &volume[],
|
|
const int &spread[] //
|
|
)
|
|
{
|
|
//
|
|
// Prepare Buffers ...
|
|
ArraySetAsSeries(time, true);
|
|
ArraySetAsSeries(open, true);
|
|
ArraySetAsSeries(high, true);
|
|
ArraySetAsSeries(low, true);
|
|
ArraySetAsSeries(close, true);
|
|
ArraySetAsSeries(tick_volume, true);
|
|
ArraySetAsSeries(volume, true);
|
|
ArraySetAsSeries(spread, true);
|
|
|
|
//
|
|
// Validate Calculated Bars ...
|
|
|
|
//
|
|
// MA ...
|
|
int maCalculatedBars = BarsCalculated(maHandler);
|
|
|
|
//
|
|
// ATR ...
|
|
int atrCalculatedBars = BarsCalculated(atrHandler);
|
|
|
|
//
|
|
// ADX ...
|
|
int adxCalculatedBars = BarsCalculated(adxHandler);
|
|
|
|
//
|
|
bool isPassedRequiredCalculatedBars =
|
|
//
|
|
// MA ...
|
|
maCalculatedBars >= maxLength &&
|
|
//
|
|
// ATR ...
|
|
atrCalculatedBars >= maxLength &&
|
|
//
|
|
// ADX ...
|
|
adxCalculatedBars >= maxLength
|
|
//
|
|
;
|
|
if (!isPassedRequiredCalculatedBars)
|
|
{
|
|
return prev_calculated;
|
|
}
|
|
|
|
//
|
|
limit = (prev_calculated > rates_total || prev_calculated <= 0)
|
|
? rates_total
|
|
: (rates_total - prev_calculated) + 1;
|
|
|
|
//
|
|
// Buffers Copy ...
|
|
|
|
//
|
|
// MA ...
|
|
int copiedMas = CopyBuffer(maHandler, 0, 0, limit, maBuffer);
|
|
|
|
//
|
|
// ATR ...
|
|
int copiedAtr = CopyBuffer(atrHandler, MAIN_LINE, 0, limit, atrBuffer);
|
|
|
|
//
|
|
// ADX ...
|
|
int copiedAdxs = CopyBuffer(adxHandler, MAIN_LINE, 0, limit, adxBuffer);
|
|
|
|
//
|
|
// Validate Copied Items ...
|
|
bool isPassedRequiredCopiedItems =
|
|
//
|
|
// MA ...
|
|
copiedMas > 0 &&
|
|
//
|
|
// ATR ...
|
|
copiedAtr > 0 &&
|
|
//
|
|
// ADX ...
|
|
copiedAdxs > 0
|
|
//
|
|
;
|
|
if (!isPassedRequiredCopiedItems)
|
|
{
|
|
return prev_calculated;
|
|
}
|
|
|
|
//
|
|
// Main Loop ...
|
|
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
|
|
{
|
|
//
|
|
CalculateBuffers(
|
|
//
|
|
i,
|
|
prev_calculated,
|
|
rates_total,
|
|
//
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tick_volume //
|
|
);
|
|
}
|
|
|
|
//
|
|
return rates_total;
|
|
}
|
|
|
|
//
|
|
// Functions ...
|
|
|
|
/**
|
|
* Validate Input Args for Initialization ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool ValidateInputs()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
// MA ...
|
|
maLength > 0 &&
|
|
//
|
|
// ATR ...
|
|
atrLength > 0 &&
|
|
atrMultiplier > 0 &&
|
|
//
|
|
// ADX ...
|
|
adxLength > 0 &&
|
|
adxThreshold > 0
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Extract Max Length of Inputs ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int ExtractMaxLengthOfInputs()
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
result = MathMax(maLength, atrLength);
|
|
result = MathMax(result, adxLength);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Set Indicator Short Name and also we can define Buffers Labels ...
|
|
*/
|
|
void SetIndicatorName()
|
|
{
|
|
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
|
|
}
|
|
|
|
/**
|
|
* Define Required Buffers ...
|
|
*/
|
|
void DefineBuffers()
|
|
{
|
|
//
|
|
// Plot Buffers ...
|
|
|
|
//
|
|
// MA Buffer ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE maDrawType = showMA ? DRAW_LINE : DRAW_NONE;
|
|
|
|
//
|
|
ArraySetAsSeries(maBuffer, true);
|
|
SetIndexBuffer(maBufferIndex, maBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(maBufferIndex, PLOT_SHOW_DATA, showMA);
|
|
PlotIndexSetInteger(maBufferIndex, PLOT_DRAW_TYPE, maDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(maBufferIndex, PLOT_EMPTY_VALUE, 0);
|
|
|
|
//
|
|
// LONG SL Buffer ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE longSLDrawType = showLongSL ? DRAW_LINE : DRAW_NONE;
|
|
|
|
//
|
|
ArraySetAsSeries(longSLBuffer, true);
|
|
SetIndexBuffer(longSLBufferIndex, longSLBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(longSLBufferIndex, PLOT_SHOW_DATA, showLongSL);
|
|
PlotIndexSetInteger(longSLBufferIndex, PLOT_DRAW_TYPE, longSLDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(longSLBufferIndex, PLOT_EMPTY_VALUE, 0);
|
|
|
|
//
|
|
// SHORT SL Buffer ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE shortSLDrawType = showShortSL ? DRAW_LINE : DRAW_NONE;
|
|
|
|
//
|
|
ArraySetAsSeries(shortSLBuffer, true);
|
|
SetIndexBuffer(shortSLBufferIndex, shortSLBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(shortSLBufferIndex, PLOT_SHOW_DATA, showShortSL);
|
|
PlotIndexSetInteger(shortSLBufferIndex, PLOT_DRAW_TYPE, shortSLDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(shortSLBufferIndex, PLOT_EMPTY_VALUE, 0);
|
|
|
|
//
|
|
// LONG Reject ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE longRejectDrawType = showLongReject ? DRAW_ARROW : DRAW_NONE;
|
|
|
|
//
|
|
ArraySetAsSeries(longRejectBuffer, true);
|
|
SetIndexBuffer(longRejectBufferIndex, longRejectBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(longRejectBufferIndex, PLOT_SHOW_DATA, showLongReject);
|
|
PlotIndexSetInteger(longRejectBufferIndex, PLOT_DRAW_TYPE, longRejectDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(longRejectBufferIndex, PLOT_EMPTY_VALUE, 0);
|
|
PlotIndexSetInteger(longRejectBufferIndex, PLOT_ARROW, longRejectArrowCode);
|
|
|
|
//
|
|
// SHORT Reject ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE shortRejectDrawType = showShortReject ? DRAW_ARROW : DRAW_NONE;
|
|
|
|
//
|
|
ArraySetAsSeries(shortRejectBuffer, true);
|
|
SetIndexBuffer(shortRejectBufferIndex, shortRejectBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(shortRejectBufferIndex, PLOT_SHOW_DATA, showShortReject);
|
|
PlotIndexSetInteger(shortRejectBufferIndex, PLOT_DRAW_TYPE, shortRejectDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(shortRejectBufferIndex, PLOT_EMPTY_VALUE, 0);
|
|
PlotIndexSetInteger(shortRejectBufferIndex, PLOT_ARROW, shortRejectArrowCode);
|
|
|
|
//
|
|
// UP Trend ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE upTrendDrawType = showUpTrend ? DRAW_ARROW : DRAW_NONE;
|
|
|
|
//
|
|
ArraySetAsSeries(upTrendBuffer, true);
|
|
SetIndexBuffer(upTrendBufferIndex, upTrendBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(upTrendBufferIndex, PLOT_SHOW_DATA, showUpTrend);
|
|
PlotIndexSetInteger(upTrendBufferIndex, PLOT_DRAW_TYPE, upTrendDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(upTrendBufferIndex, PLOT_EMPTY_VALUE, 0);
|
|
PlotIndexSetInteger(upTrendBufferIndex, PLOT_ARROW, upTrendArrowCode);
|
|
|
|
//
|
|
// DOWN Trend ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE downTrendDrawType = showDownTrend ? DRAW_ARROW : DRAW_NONE;
|
|
|
|
//
|
|
ArraySetAsSeries(downTrendBuffer, true);
|
|
SetIndexBuffer(downTrendBufferIndex, downTrendBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(downTrendBufferIndex, PLOT_SHOW_DATA, showDownTrend);
|
|
PlotIndexSetInteger(downTrendBufferIndex, PLOT_DRAW_TYPE, downTrendDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(downTrendBufferIndex, PLOT_EMPTY_VALUE, 0);
|
|
PlotIndexSetInteger(downTrendBufferIndex, PLOT_ARROW, downTrendArrowCode);
|
|
|
|
//
|
|
// DATA Buffers ...
|
|
|
|
//
|
|
ArraySetAsSeries(atrBuffer, true);
|
|
SetIndexBuffer(atrBufferIndex, atrBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(adxBuffer, true);
|
|
SetIndexBuffer(adxBufferIndex, adxBuffer, INDICATOR_CALCULATIONS);
|
|
}
|
|
|
|
/**
|
|
* Calculate Custom Buffers ...
|
|
*
|
|
* @param bar_index: Integer, Represent Current Bar ...
|
|
* @param prevCalculated: Integer, Represent Previous Calculated Bars ...
|
|
* @param ratesTotal: Integer, Represents All Available Bars ...
|
|
* @param open: Double Array, History of Open Prices ...
|
|
* @param high: Double Array, History of High Prices ...
|
|
* @param close: Double Array, History of Close Prices ...
|
|
* @param low: Double Array, History of Low Prices ...
|
|
* @param tickVolume: Long, History of Tick Volumes on Bar ...
|
|
*/
|
|
void CalculateBuffers(
|
|
int bar_index, // Selected Bar Index
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
int barsLimit = startCalculationForLastBars > 0
|
|
? startCalculationForLastBars
|
|
: 0;
|
|
//
|
|
// bool canCalculate = true;
|
|
bool canCalculate =
|
|
barsLimit == 0 ||
|
|
bar_index <= barsLimit;
|
|
if (canCalculate)
|
|
{
|
|
//
|
|
CalculatedPOIs(
|
|
//
|
|
bar_index,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
//
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
|
|
//
|
|
CalculateValues(
|
|
bar_index,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
FillBuffersZero(bar_index);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fill All Bufers to Zero Vlue for Specified Bar Index ...
|
|
*
|
|
* @param barIndex: Integer ...
|
|
*/
|
|
void FillBuffersZero(int barIndex)
|
|
{
|
|
//
|
|
maBuffer[barIndex] = 0;
|
|
atrBuffer[barIndex] = 0;
|
|
adxBuffer[barIndex] = 0;
|
|
longSLBuffer[barIndex] = 0;
|
|
shortSLBuffer[barIndex] = 0;
|
|
upTrendBuffer[barIndex] = 0;
|
|
downTrendBuffer[barIndex] = 0;
|
|
longRejectBuffer[barIndex] = 0;
|
|
shortRejectBuffer[barIndex] = 0;
|
|
}
|
|
|
|
/**
|
|
* Calculate Vales ...
|
|
*
|
|
* @param bar_index: Integer, Represent Current Bar ...
|
|
* @param prevCalculated: Integer, Represent Previous Calculated Bars ...
|
|
* @param ratesTotal: Integer, Represents All Available Bars ...
|
|
* @param open: Double Array, History of Open Prices ...
|
|
* @param high: Double Array, History of High Prices ...
|
|
* @param close: Double Array, History of Close Prices ...
|
|
* @param low: Double Array, History of Low Prices ...
|
|
* @param tickVolume: Long, History of Tick Volumes on Bar ...
|
|
*/
|
|
void CalculateValues(
|
|
int bar_index, // Selected Bar Index
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
XOHCL iBar;
|
|
bool isInited = iBar.Init(
|
|
_Symbol,
|
|
_Period,
|
|
bar_index //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
return;
|
|
}
|
|
|
|
//
|
|
XOHCL pBar;
|
|
isInited = iBar.GetPreviousBar(pBar);
|
|
if (!isInited)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
pBar.Clean();
|
|
return;
|
|
}
|
|
|
|
//
|
|
double iPrice = GetAppliedPrice(
|
|
appliedTo,
|
|
open,
|
|
high,
|
|
low,
|
|
close,
|
|
bar_index //
|
|
);
|
|
|
|
//
|
|
double iMa = maBuffer[bar_index];
|
|
double iAtr = atrBuffer[bar_index];
|
|
double iAdx = adxBuffer[bar_index];
|
|
double iAppliedAtr = iAtr * atrMultiplier;
|
|
|
|
//
|
|
double points = GetPoints(_Symbol);
|
|
double points10 = 10 * points;
|
|
|
|
//
|
|
// Calculate SL Values ...
|
|
|
|
//
|
|
double iLongSL = iPrice - iAppliedAtr;
|
|
double iShortSL = iPrice + iAppliedAtr;
|
|
|
|
//
|
|
// Calculate Trend Values ...
|
|
|
|
//
|
|
bool isUpTrend =
|
|
//
|
|
iPrice > iMa &&
|
|
iBar.open < iMa &&
|
|
iAdx > adxThreshold
|
|
//
|
|
;
|
|
|
|
//
|
|
bool isDownTrend =
|
|
//
|
|
iPrice < iMa &&
|
|
iBar.open > iMa &&
|
|
iAdx > adxThreshold
|
|
//
|
|
;
|
|
|
|
//
|
|
double upTrendValue = 0;
|
|
double downTrendValue = 0;
|
|
if (isUpTrend)
|
|
{
|
|
//
|
|
lastBullishTrend = iBar.time;
|
|
upTrendValue = iBar.low - points10;
|
|
}
|
|
if (isDownTrend)
|
|
{
|
|
//
|
|
lastBearishTrend = iBar.time;
|
|
downTrendValue = iBar.high + points10;
|
|
}
|
|
|
|
//
|
|
// Calculate Rejection Values ...
|
|
|
|
//
|
|
double fiboUpDown = GetFibonacciLevel(
|
|
iBar.high,
|
|
iBar.low,
|
|
X_FIBO_LEVEL_382,
|
|
X_DIRECTION_BEARISH //
|
|
);
|
|
double fiboDownUp = GetFibonacciLevel(
|
|
iBar.high,
|
|
iBar.low,
|
|
X_FIBO_LEVEL_382,
|
|
X_DIRECTION_BULLISH //
|
|
);
|
|
|
|
//
|
|
bool hasFiboToUpPressure =
|
|
fiboDownUp > 0 &&
|
|
fiboDownUp <= iBar.GetDown();
|
|
bool hasFiboToDownPressure =
|
|
fiboUpDown > 0 &&
|
|
fiboUpDown >= iBar.GetUp();
|
|
|
|
//
|
|
bool isLongReject =
|
|
//
|
|
iBar.low < iMa &&
|
|
iBar.high >= iMa &&
|
|
iBar.GetDown() >= iMa
|
|
//
|
|
;
|
|
bool isStrongLongReject =
|
|
iBar.IsBullish() &&
|
|
isLongReject;
|
|
bool isPressuredLongReject =
|
|
isLongReject &&
|
|
hasFiboToUpPressure;
|
|
bool isPressuredStrongLongReject =
|
|
isStrongLongReject &&
|
|
isPressuredLongReject;
|
|
|
|
//
|
|
bool isShortReject =
|
|
//
|
|
iBar.high > iMa &&
|
|
iBar.low <= iMa &&
|
|
iBar.GetUp() <= iMa
|
|
//
|
|
;
|
|
bool isStrongShortReject =
|
|
iBar.IsBearish() &&
|
|
isShortReject;
|
|
bool isPressuredShortReject =
|
|
isShortReject &&
|
|
hasFiboToDownPressure;
|
|
bool isPressuredStrongShortReject =
|
|
isStrongShortReject &&
|
|
isPressuredShortReject;
|
|
|
|
//
|
|
double iLongRejectValue = 0;
|
|
double iShortRejectValue = 0;
|
|
|
|
//
|
|
bool isAppliedLongReject = false;
|
|
bool isAppliedShortReject = false;
|
|
switch (rejectionType)
|
|
{
|
|
//
|
|
case XWZ_REJECTION_BAR:
|
|
isAppliedLongReject = isLongReject;
|
|
isAppliedShortReject = isShortReject;
|
|
break;
|
|
|
|
//
|
|
case XWZ_REJECTION_STRONG_BAR:
|
|
isAppliedLongReject = isStrongLongReject;
|
|
isAppliedShortReject = isStrongShortReject;
|
|
break;
|
|
|
|
//
|
|
case XWZ_REJECTION_PRESSURED_BAR:
|
|
isAppliedLongReject = isPressuredLongReject;
|
|
isAppliedShortReject = isPressuredShortReject;
|
|
break;
|
|
|
|
//
|
|
case XWZ_REJECTION_STRONG_PRESSURED_BAR:
|
|
isAppliedLongReject = isPressuredStrongLongReject;
|
|
isAppliedShortReject = isPressuredStrongShortReject;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Calculate Rejection Verification Values ...
|
|
|
|
//
|
|
int iLLIDX = pBar
|
|
.FindLowestIndex(
|
|
rejectionVerificationLength,
|
|
MODE_LOW //
|
|
);
|
|
datetime iLLTime = iTime(
|
|
_Symbol,
|
|
_Period,
|
|
iLLIDX //
|
|
);
|
|
double iLL = iLow(
|
|
_Symbol,
|
|
_Period,
|
|
iLLIDX //
|
|
);
|
|
|
|
//
|
|
int iHHIDX = pBar
|
|
.FindHighestIndex(
|
|
rejectionVerificationLength,
|
|
MODE_HIGH //
|
|
);
|
|
datetime iHHTime = iTime(
|
|
_Symbol,
|
|
_Period,
|
|
iHHIDX //
|
|
);
|
|
double iHH = iHigh(
|
|
_Symbol,
|
|
_Period,
|
|
iHHIDX //
|
|
);
|
|
|
|
//
|
|
bool isLLBreaked = false;
|
|
bool isHHBreaked = false;
|
|
if (rejectionVerificationLength > 0)
|
|
{
|
|
//
|
|
for (int i = bar_index + 1; i < bar_index + rejectionVerificationLength; i++)
|
|
{
|
|
//
|
|
double iMaValue = maBuffer[i];
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isInited = iBar.Init(
|
|
_Symbol,
|
|
_Period,
|
|
i //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
isLLBreaked = true;
|
|
isHHBreaked = true;
|
|
break;
|
|
}
|
|
|
|
//
|
|
if (!isLLBreaked)
|
|
{
|
|
isLLBreaked = iBar.low < iMaValue;
|
|
}
|
|
|
|
//
|
|
if (!isHHBreaked)
|
|
{
|
|
isHHBreaked = iBar.high > iMaValue;
|
|
}
|
|
|
|
//
|
|
if (isLLBreaked &&
|
|
isHHBreaked)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Validate Rejections ...
|
|
|
|
//
|
|
// -[] Before Reject Long, price
|
|
// must not touch Ma from Up for at least 3 Bar ...
|
|
bool isValidAppliedLongReject =
|
|
!isLLBreaked &&
|
|
isAppliedLongReject;
|
|
|
|
//
|
|
// -[] Before Reject Short Price
|
|
// must no touch Ma from down at least 3 Bar ...
|
|
bool isValidAppliedShortReject =
|
|
!isHHBreaked &&
|
|
isAppliedShortReject;
|
|
|
|
//
|
|
if (isValidAppliedLongReject)
|
|
{
|
|
iLongRejectValue = iBar.low - points10;
|
|
}
|
|
else
|
|
{
|
|
iLongRejectValue = 0;
|
|
}
|
|
|
|
//
|
|
if (isValidAppliedShortReject)
|
|
{
|
|
iShortRejectValue = iBar.high + points10;
|
|
}
|
|
else
|
|
{
|
|
iShortRejectValue = 0;
|
|
}
|
|
|
|
//
|
|
// Draw Verification Box ...
|
|
if (isValidAppliedLongReject ||
|
|
isValidAppliedShortReject)
|
|
{
|
|
//
|
|
datetime time1 = iTime(
|
|
_Symbol,
|
|
_Period,
|
|
iBar.Index() + rejectionVerificationLength //
|
|
);
|
|
datetime time2 = iTime(
|
|
_Symbol,
|
|
_Period,
|
|
iBar.Index() + 0 //
|
|
);
|
|
string llName = ToString(iLLIDX) + "_" +
|
|
ToString(iLL) + "_" +
|
|
ToMD5(iLLTime);
|
|
CChartObjectTrend *llTrend;
|
|
llTrend = new CChartObjectTrend();
|
|
bool isCreated = llTrend.Create(
|
|
0,
|
|
llName,
|
|
0,
|
|
time1,
|
|
iLL,
|
|
time2,
|
|
iLL //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
mXWZDrawnObjects.Add(llTrend);
|
|
}
|
|
|
|
//
|
|
string hhName = ToString(iHHIDX) + "_" +
|
|
ToString(iHH) + "_" +
|
|
ToMD5(iHHTime);
|
|
CChartObjectTrend *hhTrend;
|
|
hhTrend = new CChartObjectTrend();
|
|
isCreated = hhTrend.Create(
|
|
0,
|
|
hhName,
|
|
0,
|
|
time1,
|
|
iHH,
|
|
time2,
|
|
iHH //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
mXWZDrawnObjects.Add(hhTrend);
|
|
}
|
|
}
|
|
|
|
//
|
|
int idx = -1;
|
|
int count = 0;
|
|
bool has = false;
|
|
|
|
//
|
|
ENUM_X_DIRECTION trend =
|
|
IsValid(lastBullishTrend) &&
|
|
lastBullishTrend > lastBearishTrend
|
|
? X_DIRECTION_BULLISH
|
|
: IsValid(lastBearishTrend) &&
|
|
lastBearishTrend > lastBullishTrend
|
|
? X_DIRECTION_BEARISH
|
|
: X_DIRECTION_NONE;
|
|
bool hasTrend = HasDirection(trend);
|
|
bool hasBullishTrend = hasTrend &&
|
|
IsBullish(trend);
|
|
bool hasBearishTrend = hasTrend &&
|
|
IsBearish(trend);
|
|
|
|
//
|
|
// Filling Buffers ...
|
|
|
|
//
|
|
longSLBuffer[bar_index] = iLongSL;
|
|
shortSLBuffer[bar_index] = iShortSL;
|
|
|
|
//
|
|
upTrendBuffer[bar_index] = upTrendValue;
|
|
downTrendBuffer[bar_index] = downTrendValue;
|
|
|
|
//
|
|
longRejectBuffer[bar_index] = iLongRejectValue;
|
|
shortRejectBuffer[bar_index] = iShortRejectValue;
|
|
|
|
//
|
|
// Cleanup Resources ...
|
|
|
|
//
|
|
iBar.Clean();
|
|
pBar.Clean();
|
|
}
|
|
|
|
//
|
|
// POIS Functions ...
|
|
void CalculatedPOIs(
|
|
int bar_index, // Selected Bar Index
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
XOHCL iBar;
|
|
bool isInited = iBar.Init(
|
|
_Symbol,
|
|
_Period,
|
|
bar_index //
|
|
);
|
|
if (!isInited)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
return;
|
|
}
|
|
|
|
//
|
|
XOHCL pBar;
|
|
isInited = iBar.GetPreviousBar(pBar);
|
|
if (!isInited)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
pBar.Clean();
|
|
return;
|
|
}
|
|
|
|
//
|
|
// POI ...
|
|
DetectPOIs(iBar);
|
|
UpdatePOIs(iBar);
|
|
DrawPOIs();
|
|
|
|
//
|
|
iBar.Clean();
|
|
pBar.Clean();
|
|
}
|
|
|
|
//
|
|
void DetectPOIs(
|
|
XOHCL &bar //
|
|
)
|
|
{
|
|
//
|
|
int idx = -1;
|
|
int range = 21;
|
|
|
|
//
|
|
// Detect Order Block ...
|
|
|
|
//
|
|
XOHCL obBar;
|
|
XCOrderBlock *ob;
|
|
ENUM_X_DIRECTION obDir;
|
|
bool hasOB = mXWZBarAnalyser.HasOrderBlock(
|
|
bar,
|
|
obBar,
|
|
obDir //
|
|
);
|
|
bool hasBullishOB =
|
|
hasOB &&
|
|
IsBullish(obDir);
|
|
bool hasBearishOB =
|
|
hasOB &&
|
|
IsBearish(obDir);
|
|
if (hasOB)
|
|
{
|
|
//
|
|
ob = new XCOrderBlock();
|
|
bool isInited = ob.Init(obBar, obDir);
|
|
if (isInited)
|
|
{
|
|
//
|
|
ENUM_X_DIRECTION forDir = ob.GetDirection();
|
|
|
|
//
|
|
// Check OB Not Activated ...
|
|
XOHCL activationBar;
|
|
bool isActivationBarBodyIn = false;
|
|
bool isActivated = ob.IsActivated(
|
|
forDir,
|
|
activationBar,
|
|
isActivationBarBodyIn,
|
|
false,
|
|
_Period //
|
|
);
|
|
|
|
//
|
|
if (!isActivated)
|
|
{
|
|
//
|
|
idx = FindIndex(
|
|
ob,
|
|
mXWZUnActivatedOBs //
|
|
);
|
|
if (!IsValidIndex(idx))
|
|
{
|
|
//
|
|
Add(
|
|
ob,
|
|
mXWZUnActivatedOBs //
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
idx = FindIndex(
|
|
ob,
|
|
mXWZActivatedOBs //
|
|
);
|
|
if (!IsValidIndex(idx))
|
|
{
|
|
//
|
|
ob.To(activationBar.time);
|
|
|
|
//
|
|
Add(
|
|
ob,
|
|
mXWZActivatedOBs //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
activationBar.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
obBar.Clean();
|
|
|
|
//
|
|
// Detect Fair Value Gap ...
|
|
|
|
//
|
|
XOHCL fvgStartBar;
|
|
XOHCL fvgEndBar;
|
|
XCFVG *fvg;
|
|
ENUM_X_DIRECTION fvgDir;
|
|
bool hasFVG = mXWZBarAnalyser.HasFairValueGap(
|
|
bar,
|
|
fvgStartBar,
|
|
fvgEndBar,
|
|
fvgDir //
|
|
);
|
|
bool hasBullishFVG =
|
|
hasFVG &&
|
|
IsBullish(fvgDir);
|
|
bool hasBearishFVG =
|
|
hasFVG &&
|
|
IsBearish(fvgDir);
|
|
if (hasFVG)
|
|
{
|
|
//
|
|
fvg = new XCFVG();
|
|
bool isInited = fvg.Init(
|
|
fvgStartBar,
|
|
fvgEndBar,
|
|
fvgDir //
|
|
);
|
|
if (isInited)
|
|
{
|
|
//
|
|
ENUM_X_DIRECTION forDir = fvg.GetDirection();
|
|
|
|
//
|
|
// Check OB Not Activated ...
|
|
XOHCL activationBar;
|
|
bool isActivationBarBodyIn = false;
|
|
bool isActivated = fvg.IsActivated(
|
|
forDir,
|
|
activationBar,
|
|
isActivationBarBodyIn,
|
|
false,
|
|
_Period //
|
|
);
|
|
|
|
//
|
|
if (!isActivated)
|
|
{
|
|
//
|
|
idx = FindIndex(
|
|
fvg,
|
|
mXWZUnActivatedFVGs //
|
|
);
|
|
if (!IsValidIndex(idx))
|
|
{
|
|
//
|
|
Add(
|
|
fvg,
|
|
mXWZUnActivatedFVGs //
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
idx = FindIndex(
|
|
fvg,
|
|
mXWZActivatedFVGs //
|
|
);
|
|
if (!IsValidIndex(idx))
|
|
{
|
|
//
|
|
fvg.To(activationBar.time);
|
|
|
|
//
|
|
Add(
|
|
fvg,
|
|
mXWZActivatedFVGs //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
activationBar.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
fvgEndBar.Clean();
|
|
fvgStartBar.Clean();
|
|
|
|
//
|
|
// Detect Supply Zone ...
|
|
|
|
//
|
|
// Detect Deman Zone ...
|
|
|
|
//
|
|
// Detect Support Zone ...
|
|
|
|
//
|
|
XOHCL supportBar;
|
|
XCSupportZone *supportZone;
|
|
bool hasSupport = mXWZBarAnalyser
|
|
.HasSupport(
|
|
bar,
|
|
supportBar,
|
|
range //
|
|
);
|
|
if (hasSupport)
|
|
{
|
|
//
|
|
supportZone = new XCSupportZone();
|
|
hasSupport = supportZone.Init(
|
|
supportBar,
|
|
range,
|
|
true // Use Range As Start ...
|
|
);
|
|
|
|
//
|
|
if (hasSupport)
|
|
{
|
|
//
|
|
// Check OB Not Activated ...
|
|
XOHCL activationBar;
|
|
bool isActivationBarBodyIn = false;
|
|
bool isActivated = supportZone.IsActivated(
|
|
X_DIRECTION_BULLISH,
|
|
activationBar,
|
|
isActivationBarBodyIn,
|
|
false,
|
|
_Period //
|
|
);
|
|
|
|
//
|
|
if (!isActivated)
|
|
{
|
|
//
|
|
idx = FindIndex(
|
|
supportZone,
|
|
mXWZUnActivatedSupportZones //
|
|
);
|
|
hasSupport = !IsValidIndex(idx);
|
|
if (hasSupport)
|
|
{
|
|
//
|
|
Add(
|
|
supportZone,
|
|
mXWZUnActivatedSupportZones //
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
idx = FindIndex(
|
|
supportZone,
|
|
mXWZActivatedSupportZones //
|
|
);
|
|
hasSupport = !IsValidIndex(idx);
|
|
if (hasSupport)
|
|
{
|
|
//
|
|
supportZone.To(activationBar.time);
|
|
|
|
//
|
|
Add(
|
|
supportZone,
|
|
mXWZActivatedSupportZones //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
activationBar.Clean();
|
|
}
|
|
}
|
|
|
|
//
|
|
supportBar.Clean();
|
|
|
|
//
|
|
// Detect Resistance Zone ...
|
|
|
|
//
|
|
}
|
|
|
|
//
|
|
void UpdatePOIs(
|
|
XOHCL &bar //
|
|
)
|
|
{
|
|
//
|
|
int count = -1;
|
|
bool has = false;
|
|
|
|
//
|
|
if (!bar.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
datetime to = bar.time;
|
|
|
|
//
|
|
// Order Blocks ...
|
|
count = ArraySize(mXWZUnActivatedOBs);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
XCOrderBlock *tmps[];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
// Update To ...
|
|
mXWZUnActivatedOBs[i].To(to);
|
|
|
|
//
|
|
// Check Activation ...
|
|
|
|
//
|
|
// Check OB Not Activated ...
|
|
XOHCL activationBar;
|
|
bool isActivationBarBodyIn = false;
|
|
bool isActivated = mXWZUnActivatedOBs[i]
|
|
.IsActivated(
|
|
mXWZUnActivatedOBs[i].GetDirection(),
|
|
activationBar,
|
|
isActivationBarBodyIn,
|
|
false,
|
|
_Period //
|
|
);
|
|
|
|
//
|
|
activationBar.Clean();
|
|
|
|
//
|
|
if (!isActivated)
|
|
{
|
|
//
|
|
Add(
|
|
mXWZUnActivatedOBs[i],
|
|
tmps //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
Add(
|
|
mXWZUnActivatedOBs[i],
|
|
mXWZActivatedOBs //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Copy(
|
|
tmps,
|
|
mXWZUnActivatedOBs //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Fair Value Gaps ...
|
|
count = ArraySize(mXWZUnActivatedFVGs);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
XCFVG *tmps[];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
// Update To ...
|
|
mXWZUnActivatedFVGs[i].To(to);
|
|
|
|
//
|
|
// Check Activation ...
|
|
|
|
//
|
|
// Check OB Not Activated ...
|
|
XOHCL activationBar;
|
|
bool isActivationBarBodyIn = false;
|
|
bool isActivated = mXWZUnActivatedFVGs[i]
|
|
.IsActivated(
|
|
mXWZUnActivatedFVGs[i].GetDirection(),
|
|
activationBar,
|
|
isActivationBarBodyIn,
|
|
false,
|
|
_Period //
|
|
);
|
|
|
|
//
|
|
activationBar.Clean();
|
|
|
|
//
|
|
if (!isActivated)
|
|
{
|
|
//
|
|
Add(
|
|
mXWZUnActivatedFVGs[i],
|
|
tmps //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
Add(
|
|
mXWZUnActivatedFVGs[i],
|
|
mXWZActivatedFVGs //
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
Copy(
|
|
tmps,
|
|
mXWZUnActivatedFVGs //
|
|
);
|
|
}
|
|
|
|
//
|
|
// Support Zones ...
|
|
count = ArraySize(mXWZUnActivatedSupportZones);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
XCSupportZone *tmps[];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
// Update To ...
|
|
mXWZUnActivatedSupportZones[i].To(to);
|
|
|
|
//
|
|
// Check Activation ...
|
|
|
|
//
|
|
// Check OB Not Activated ...
|
|
XOHCL activationBar;
|
|
bool isActivationBarBodyIn = false;
|
|
bool isActivated = mXWZUnActivatedSupportZones[i]
|
|
.IsActivated(
|
|
X_DIRECTION_BULLISH,
|
|
activationBar,
|
|
isActivationBarBodyIn,
|
|
false,
|
|
_Period //
|
|
);
|
|
|
|
//
|
|
if (!isActivated)
|
|
{
|
|
//
|
|
Add(
|
|
mXWZUnActivatedSupportZones[i],
|
|
tmps //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
mXWZUnActivatedSupportZones[i].To(activationBar.time);
|
|
|
|
//
|
|
Add(
|
|
mXWZUnActivatedSupportZones[i],
|
|
mXWZActivatedSupportZones //
|
|
);
|
|
}
|
|
|
|
//
|
|
activationBar.Clean();
|
|
}
|
|
|
|
//
|
|
Copy(
|
|
tmps,
|
|
mXWZUnActivatedSupportZones //
|
|
);
|
|
}
|
|
|
|
//
|
|
}
|
|
|
|
//
|
|
void DrawPOIs()
|
|
{
|
|
//
|
|
int count = 0;
|
|
bool has = false;
|
|
bool isCreated = false;
|
|
|
|
//
|
|
if (!showPOIs)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Order Blocks ...
|
|
bool showOrderBlocks =
|
|
showBullishOrderBlocks ||
|
|
showBearishOrderBlocks;
|
|
if (showOrderBlocks)
|
|
{
|
|
//
|
|
// UnActivated ...
|
|
count = ArraySize(mXWZUnActivatedOBs);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
bool isBullish = mXWZUnActivatedOBs[i].IsBullish();
|
|
|
|
//
|
|
if ((isBullish &&
|
|
showBullishOrderBlocks) ||
|
|
(!isBullish &&
|
|
showBearishOrderBlocks))
|
|
{
|
|
//
|
|
XCBaseObject *iObj;
|
|
isCreated = mXWZPOIDrawer
|
|
.CreateOrderBlock(
|
|
mXWZUnActivatedOBs[i],
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
mXWZDrawnObjects.Add(iObj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Activated ...
|
|
count = ArraySize(mXWZActivatedOBs);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCOrderBlock *iOB = mXWZActivatedOBs[i];
|
|
|
|
//
|
|
bool isBullish = iOB.IsBullish();
|
|
|
|
//
|
|
if (showActivatedPOIs &&
|
|
((isBullish &&
|
|
showBullishOrderBlocks) ||
|
|
(!isBullish &&
|
|
showBearishOrderBlocks)))
|
|
{
|
|
//
|
|
XCBaseObject *iObj;
|
|
isCreated = mXWZPOIDrawer
|
|
.CreateOrderBlock(
|
|
iOB,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
//
|
|
// if (isBullish)
|
|
// {
|
|
// ((XCBullishOrderBlockObject *)iObj).ZoneFill(true);
|
|
// }
|
|
// else
|
|
// {
|
|
// ((XCBearishOrderBlockObject *)iObj).ZoneFill(true);
|
|
// }
|
|
|
|
//
|
|
mXWZDrawnObjects.Add(iObj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Fair Value Gaps ...
|
|
bool showOrderFairValueGaps =
|
|
showBullishFairValueGaps ||
|
|
showBearishFairValueGaps;
|
|
if (showOrderFairValueGaps)
|
|
{
|
|
//
|
|
// UnActivated ...
|
|
count = ArraySize(mXWZUnActivatedFVGs);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
bool isBullish = mXWZUnActivatedFVGs[i].IsBullish();
|
|
|
|
//
|
|
if ((isBullish &&
|
|
showBullishFairValueGaps) ||
|
|
(!isBullish &&
|
|
showBearishFairValueGaps))
|
|
{
|
|
//
|
|
XCBaseObject *iObj;
|
|
isCreated = mXWZPOIDrawer
|
|
.CreateFairValueGap(
|
|
mXWZUnActivatedFVGs[i],
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
mXWZDrawnObjects.Add(iObj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Activated ...
|
|
count = ArraySize(mXWZActivatedFVGs);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCFVG *iFVG = mXWZActivatedFVGs[i];
|
|
|
|
//
|
|
bool isBullish = iFVG.IsBullish();
|
|
|
|
//
|
|
if (showActivatedPOIs &&
|
|
((isBullish &&
|
|
showBullishFairValueGaps) ||
|
|
(!isBullish &&
|
|
showBearishFairValueGaps)))
|
|
{
|
|
XCBaseObject *iObj;
|
|
isCreated = mXWZPOIDrawer
|
|
.CreateFairValueGap(
|
|
iFVG,
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
//
|
|
// if (isBullish)
|
|
// {
|
|
// ((XCBullishOrderBlockObject *)iObj).ZoneFill(true);
|
|
// }
|
|
// else
|
|
// {
|
|
// ((XCBearishOrderBlockObject *)iObj).ZoneFill(true);
|
|
// }
|
|
|
|
//
|
|
mXWZDrawnObjects.Add(iObj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Support Zones ...
|
|
if (showSupportZones)
|
|
{
|
|
//
|
|
// UnActivated ...
|
|
count = ArraySize(mXWZUnActivatedSupportZones);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSupportZoneObject *iObj;
|
|
isCreated = mXWZPOIDrawer
|
|
.CreateSupportZone(
|
|
mXWZUnActivatedSupportZones[i],
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
mXWZDrawnObjects.Add(iObj);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Activated ...
|
|
if (showActivatedPOIs)
|
|
{
|
|
//
|
|
count = ArraySize(mXWZActivatedSupportZones);
|
|
has = IsValidSize(count);
|
|
if (has)
|
|
{
|
|
//
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
//
|
|
XCSupportZoneObject *iObj;
|
|
isCreated = mXWZPOIDrawer
|
|
.CreateSupportZone(
|
|
mXWZActivatedSupportZones[i],
|
|
iObj //
|
|
);
|
|
if (isCreated)
|
|
{
|
|
mXWZDrawnObjects.Add(iObj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
}
|
|
|
|
// |