2706 lines
58 KiB
Plaintext
2706 lines
58 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Indicator
|
|
// -------------------------------------------------
|
|
// Name: X121 XCATB
|
|
// Description: Integrates All Requirements inside
|
|
// this indicator for analyse Markets to
|
|
// Detect Trigger Blocks ...
|
|
//
|
|
// - HK Bars;
|
|
// - ATR Band;
|
|
// - Signal Bars;
|
|
// - Parabolic Sar;
|
|
// - HK Signal Bars;
|
|
// - Peaks and Vales;
|
|
// - Peaks and Vales Goldens;
|
|
// - Trending Average Prices;
|
|
//
|
|
// - ATR;
|
|
// - RSI;
|
|
// - ADX;
|
|
// - DELTA;
|
|
// - VOLUME;
|
|
//
|
|
// 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 XCATB Indicator"
|
|
#property strict
|
|
|
|
//
|
|
// Definitions ...
|
|
|
|
//
|
|
#define ShortName "X121 XCATB"
|
|
|
|
//
|
|
// Imports ...
|
|
#include "../Libraries/x-saherelm.common.lib.mq5"
|
|
|
|
//
|
|
// Inputs ...
|
|
|
|
//
|
|
input group "Market";
|
|
|
|
//
|
|
// Short ...
|
|
input ENUM_X_PERIOD_METHOD scMethod = X_PERIOD_AUTO; // How to Find Short Period
|
|
input ENUM_TIMEFRAMES scPeriod = NULL; // Short Period
|
|
|
|
//
|
|
// Medium ...
|
|
input ENUM_X_PERIOD_METHOD mcMethod = X_PERIOD_AUTO; // How to Find Medium Period
|
|
input ENUM_TIMEFRAMES mcPeriod = NULL; // Medium Period
|
|
|
|
//
|
|
// Long ...
|
|
input ENUM_X_PERIOD_METHOD lcMethod = X_PERIOD_AUTO; // How to Find Long Period
|
|
input ENUM_TIMEFRAMES lcPeriod = NULL; // Long Period
|
|
|
|
//
|
|
// Hind ...
|
|
input ENUM_X_PERIOD_METHOD hcMethod = X_PERIOD_AUTO; // How to Find Hind Period
|
|
input ENUM_TIMEFRAMES hcPeriod = NULL; // Hind Period
|
|
|
|
//
|
|
// Select Trending Cycle ...
|
|
// this Cycle Used for All Calculations ...
|
|
input ENUM_X_MARKET_CYCLES appliedCycle = X_MARKET_CYCLE_HIND; // Applied Cycle
|
|
|
|
//
|
|
// Presentation ...
|
|
input group "Presentation";
|
|
input bool showBars = true; // Show Bars
|
|
input bool showKI = false; // Show KI
|
|
input bool showPV = false; // Show PV
|
|
input bool showPVGolden = false; // Show PV Golden
|
|
input bool showSar = false; // Show Sar
|
|
input bool showTrend = false; // Show Trend
|
|
input bool showATRBand = false; // Show ATR Band
|
|
input bool showSignalBars = false; // Show Signal Bars
|
|
input bool showHKSignalBars = false; // Show Hiken Ashi Signal Bars
|
|
|
|
//
|
|
input int startCalculationForLastBars = 1500; // Calculate Last n Bars
|
|
|
|
//
|
|
// Non Inputs ...
|
|
double sarStep = 0.02; // Step
|
|
double sarMax = 0.2; // Maximum
|
|
double rsiOBLevel = 70.0; // RSI OB Level
|
|
double rsiOSLevel = 30.0; // RSI OS Level
|
|
double adxThreshold = 25.0; // ADX Threshold
|
|
int kiLength = 144; // KI Length
|
|
int sarArrowCode = 159; // Parabolic Sar Arrow Code
|
|
int peakArrowCode = 159; // Peaks Arrow Code
|
|
int valeArrowCode = 159; // Vales Arrow Code
|
|
double atrMultiplier = 1.5; // ATR Band Multiplier
|
|
bool showShortCycle = false; // Show Short Cycle Range
|
|
bool showMediumCycle = false; // Show Medium Cycle Range
|
|
bool showLongCycle = false; // Show Long Cycle Range
|
|
bool showHindCycle = false; // Show Hind Cycle Range
|
|
ENUM_MA_METHOD trendMode = MODE_SMA; // Trend Mode
|
|
ENUM_SERIESMODE upperMode = MODE_HIGH; // Peak Method
|
|
ENUM_SERIESMODE lowerMode = MODE_LOW; // Vale Method
|
|
ENUM_X_PRICE atrUpperPriceType = X_PRICE_HIGH; // ATR Upper Zone Applied To
|
|
ENUM_X_PRICE atrLowerPriceType = X_PRICE_LOW; // ATR Lower Zone Applied To
|
|
ENUM_APPLIED_PRICE rsiAppliedTo = PRICE_CLOSE; // RSI Applied To
|
|
ENUM_APPLIED_PRICE trendAppliedTo = PRICE_MEDIAN; // Trend Applied To
|
|
ENUM_X_MA_METHOD atrSignalMethod = X_MA_MODE_EMA; // ATR Signalling Method
|
|
ENUM_X_MA_METHOD barsSignalMethod = X_MA_MODE_EMA; // Bars Signalling Method
|
|
ENUM_X_MA_METHOD deltaSignalMethod = X_MA_MODE_EMA; // Delta Signalling Method
|
|
ENUM_X_MA_METHOD hkSignalBarMethod = X_MA_MODE_EMA; // Hiken Ashi Signal Method
|
|
ENUM_X_MA_METHOD volumeSignalMethod = X_MA_MODE_EMA; // Volume Signalling Method
|
|
|
|
//
|
|
#define hideColorIDX 0
|
|
#define bullishColorIDX 1
|
|
#define bearishColorIDX 2
|
|
#define neuturalColorIDX 3
|
|
|
|
//
|
|
#define bullishState 1
|
|
#define neuturalState 0
|
|
#define bearishState -1
|
|
|
|
//
|
|
#define emptyValue 0.0
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
#property indicator_chart_window
|
|
|
|
//
|
|
// Plot: 18
|
|
// Color: 4
|
|
// Bar: 8
|
|
// Data Buffer: 29
|
|
#property indicator_buffers 50
|
|
#property indicator_plots 19
|
|
|
|
//
|
|
// Plot Buffers ...
|
|
|
|
//
|
|
// SAR ...
|
|
|
|
//
|
|
#define sarBufferIndex 0
|
|
#define sarBufferPlotIndex 0
|
|
double sarBuffer[];
|
|
|
|
//
|
|
#define sarColorBufferIndex 1
|
|
double sarColorBuffer[];
|
|
|
|
//
|
|
#property indicator_label1 "SAR"
|
|
#property indicator_type1 DRAW_COLOR_ARROW
|
|
#property indicator_color1 CLR_NONE, clrLime, clrRed, clrGray
|
|
#property indicator_width1 2
|
|
|
|
//
|
|
// PEAKS ...
|
|
|
|
//
|
|
#define peakBufferIndex 2
|
|
#define peakBufferPlotIndex 1
|
|
double peakBuffer[];
|
|
|
|
//
|
|
#property indicator_label2 "PEAK"
|
|
#property indicator_type2 DRAW_ARROW
|
|
#property indicator_color2 clrMagenta
|
|
#property indicator_width2 1
|
|
|
|
//
|
|
// VALES ...
|
|
|
|
//
|
|
#define valeBufferIndex 3
|
|
#define valeBufferPlotIndex 2
|
|
double valeBuffer[];
|
|
|
|
//
|
|
#property indicator_label3 "VALE"
|
|
#property indicator_type3 DRAW_ARROW
|
|
#property indicator_color3 clrAqua
|
|
#property indicator_width3 1
|
|
|
|
//
|
|
// PEAKS Golden ...
|
|
|
|
//
|
|
#define peakGoldenBufferIndex 4
|
|
#define peakGoldenBufferPlotIndex 3
|
|
double peakGoldenBuffer[];
|
|
|
|
//
|
|
#property indicator_label4 "PEAK Golden"
|
|
#property indicator_type4 DRAW_LINE
|
|
#property indicator_color4 clrMagenta
|
|
#property indicator_style4 STYLE_DOT
|
|
#property indicator_width4 1
|
|
|
|
//
|
|
// VALE Golden ...
|
|
|
|
//
|
|
#define valeGoldenBufferIndex 5
|
|
#define valeGoldenBufferPlotIndex 4
|
|
double valeGoldenBuffer[];
|
|
|
|
//
|
|
#property indicator_label5 "VALES Golden"
|
|
#property indicator_type5 DRAW_LINE
|
|
#property indicator_color5 clrAqua
|
|
#property indicator_style5 STYLE_DOT
|
|
#property indicator_width5 1
|
|
|
|
//
|
|
// ATR ...
|
|
|
|
//
|
|
// Upper ...
|
|
|
|
//
|
|
#define atrUpperBufferIndex 6
|
|
#define atrUpperBufferPlotIndex 5
|
|
double atrUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label6 "XATRU"
|
|
#property indicator_type6 DRAW_LINE
|
|
#property indicator_color6 clrYellow
|
|
#property indicator_style6 STYLE_SOLID
|
|
#property indicator_width6 1
|
|
|
|
//
|
|
// Lower ...
|
|
|
|
//
|
|
#define atrLowerBufferIndex 7
|
|
#define atrLowerBufferPlotIndex 6
|
|
double atrLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label7 "XATRL"
|
|
#property indicator_type7 DRAW_LINE
|
|
#property indicator_color7 clrYellow
|
|
#property indicator_style7 STYLE_SOLID
|
|
#property indicator_width7 1
|
|
|
|
//
|
|
// TREND ...
|
|
|
|
//
|
|
#define trendBufferIndex 8
|
|
#define trendBufferPlotIndex 7
|
|
double trendBuffer[];
|
|
|
|
//
|
|
#define trendColorBufferIndex 9
|
|
double trendColorBuffer[];
|
|
|
|
//
|
|
#property indicator_label8 "Trend"
|
|
#property indicator_type8 DRAW_COLOR_LINE
|
|
#property indicator_color8 CLR_NONE, clrAqua, clrMagenta, clrGray
|
|
#property indicator_style8 STYLE_SOLID
|
|
#property indicator_width8 2
|
|
|
|
//
|
|
// Signal Bar ...
|
|
|
|
//
|
|
#define sBarOpenBufferIndex 10
|
|
double sBarOpenBuffer[];
|
|
|
|
//
|
|
#define sBarHighBufferIndex 11
|
|
double sBarHighBuffer[];
|
|
|
|
//
|
|
#define sBarLowBufferIndex 12
|
|
double sBarLowBuffer[];
|
|
|
|
//
|
|
#define sBarCloseBufferIndex 13
|
|
double sBarCloseBuffer[];
|
|
|
|
//
|
|
#define sBarColorBufferIndex 14
|
|
double sBarColorBuffer[];
|
|
|
|
//
|
|
#define sBarBufferPlotIndex 8
|
|
#property indicator_label9 "XSGB Open;XSGB High;XSGB Low;XSGB Close"
|
|
#property indicator_type9 DRAW_COLOR_CANDLES
|
|
#property indicator_color9 CLR_NONE, clrLime, clrRed
|
|
|
|
//
|
|
// XHK SIGNAL ...
|
|
|
|
//
|
|
#define hkSBarOpenBufferIndex 15
|
|
double hkSBarOpenBuffer[];
|
|
|
|
//
|
|
#define hkSBarHighBufferIndex 16
|
|
double hkSBarHighBuffer[];
|
|
|
|
//
|
|
#define hkSBarLowBufferIndex 17
|
|
double hkSBarLowBuffer[];
|
|
|
|
//
|
|
#define hkSBarCloseBufferIndex 18
|
|
double hkSBarCloseBuffer[];
|
|
|
|
//
|
|
#define hkSBarColorBufferIndex 19
|
|
double hkSBarColorBuffer[];
|
|
|
|
//
|
|
#define hkSBarBufferPlotIndex 9
|
|
#property indicator_label10 "XHKSGB Open;XHKSGB High;XHKSGB Low;XHKSGB Close"
|
|
#property indicator_type10 DRAW_COLOR_CANDLES
|
|
#property indicator_color10 CLR_NONE, clrAqua, clrMagenta
|
|
|
|
//
|
|
// CYCLES Range ...
|
|
|
|
//
|
|
// SHORT ...
|
|
|
|
//
|
|
#define sHHBufferIndex 20
|
|
#define sHHBufferPlotIndex 10
|
|
double sHHBuffer[];
|
|
|
|
//
|
|
#property indicator_label11 "SH"
|
|
#property indicator_type11 DRAW_LINE
|
|
#property indicator_color11 clrGray
|
|
#property indicator_style11 STYLE_DOT
|
|
#property indicator_width11 1
|
|
|
|
//
|
|
#define sLLBufferIndex 21
|
|
#define sLLBufferPlotIndex 11
|
|
double sLLBuffer[];
|
|
|
|
//
|
|
#property indicator_label12 "SL"
|
|
#property indicator_type12 DRAW_LINE
|
|
#property indicator_color12 clrGray
|
|
#property indicator_style12 STYLE_DOT
|
|
#property indicator_width12 1
|
|
|
|
//
|
|
// MEDIUM ...
|
|
|
|
//
|
|
#define mHHBufferIndex 22
|
|
#define mHHBufferPlotIndex 12
|
|
double mHHBuffer[];
|
|
|
|
//
|
|
#property indicator_label13 "MH"
|
|
#property indicator_type13 DRAW_LINE
|
|
#property indicator_color13 clrIndigo
|
|
#property indicator_style13 STYLE_DOT
|
|
#property indicator_width13 1
|
|
|
|
//
|
|
#define mLLBufferIndex 23
|
|
#define mLLBufferPlotIndex 13
|
|
double mLLBuffer[];
|
|
|
|
//
|
|
#property indicator_label14 "ML"
|
|
#property indicator_type14 DRAW_LINE
|
|
#property indicator_color14 clrIndigo
|
|
#property indicator_style14 STYLE_DOT
|
|
#property indicator_width14 1
|
|
|
|
//
|
|
// LONG ...
|
|
|
|
//
|
|
#define lHHBufferIndex 24
|
|
#define lHHBufferPlotIndex 14
|
|
double lHHBuffer[];
|
|
|
|
//
|
|
#property indicator_label15 "LH"
|
|
#property indicator_type15 DRAW_LINE
|
|
#property indicator_color15 clrGoldenrod
|
|
#property indicator_style15 STYLE_DOT
|
|
#property indicator_width15 1
|
|
|
|
//
|
|
#define lLLBufferIndex 25
|
|
#define lLLBufferPlotIndex 15
|
|
double lLLBuffer[];
|
|
|
|
//
|
|
#property indicator_label16 "LL"
|
|
#property indicator_type16 DRAW_LINE
|
|
#property indicator_color16 clrGoldenrod
|
|
#property indicator_style16 STYLE_DOT
|
|
#property indicator_width16 1
|
|
|
|
//
|
|
// HIND ...
|
|
|
|
//
|
|
#define hHHBufferIndex 26
|
|
#define hHHBufferPlotIndex 16
|
|
double hHHBuffer[];
|
|
|
|
//
|
|
#property indicator_label17 "HH"
|
|
#property indicator_type17 DRAW_LINE
|
|
#property indicator_color17 clrBrown
|
|
#property indicator_style17 STYLE_DOT
|
|
#property indicator_width17 1
|
|
|
|
//
|
|
#define hLLBufferIndex 27
|
|
#define hLLBufferPlotIndex 17
|
|
double hLLBuffer[];
|
|
|
|
//
|
|
#property indicator_label18 "HL"
|
|
#property indicator_type18 DRAW_LINE
|
|
#property indicator_color18 clrBrown
|
|
#property indicator_style18 STYLE_DOT
|
|
#property indicator_width18 1
|
|
|
|
//
|
|
// KI ...
|
|
|
|
//
|
|
#define kiBufferIndex 28
|
|
#define kiBufferPlotIndex 18
|
|
double kiBuffer[];
|
|
|
|
//
|
|
#define kiColorBufferIndex 29
|
|
double kiColorBuffer[];
|
|
|
|
//
|
|
#property indicator_label19 "KI"
|
|
#property indicator_type19 DRAW_COLOR_LINE
|
|
#property indicator_color19 CLR_NONE, clrGreen, clrRed, clrGray
|
|
#property indicator_style19 STYLE_DASHDOTDOT
|
|
#property indicator_width19 2
|
|
|
|
//
|
|
// Data Buffers ...
|
|
|
|
//
|
|
#define mLastBufferIndex 29
|
|
|
|
//
|
|
// SAR ...
|
|
|
|
//
|
|
#define sarStateBufferIndex mLastBufferIndex + 1
|
|
double sarStateBuffer[];
|
|
|
|
//
|
|
// TREND State ...
|
|
|
|
//
|
|
#define trendStateBufferIndex mLastBufferIndex + 2
|
|
double trendStateBuffer[];
|
|
|
|
//
|
|
// RSI ...
|
|
|
|
//
|
|
#define rsiBufferIndex mLastBufferIndex + 3
|
|
double rsiBuffer[];
|
|
|
|
//
|
|
// ADX ...
|
|
|
|
//
|
|
#define adxBufferIndex mLastBufferIndex + 4
|
|
double adxBuffer[];
|
|
|
|
//
|
|
#define adxpBufferIndex mLastBufferIndex + 5
|
|
double adxpBuffer[];
|
|
|
|
//
|
|
#define adxnBufferIndex mLastBufferIndex + 6
|
|
double adxnBuffer[];
|
|
|
|
//
|
|
// DELTA ...
|
|
|
|
//
|
|
#define deltaBufferIndex mLastBufferIndex + 7
|
|
double deltaBuffer[];
|
|
|
|
//
|
|
#define deltaSignalBufferIndex mLastBufferIndex + 8
|
|
double deltaSignalBuffer[];
|
|
|
|
//
|
|
// VOLUMES ...
|
|
|
|
//
|
|
#define bullishVolumeBufferIndex mLastBufferIndex + 9
|
|
double bullishVolumeBuffer[];
|
|
|
|
//
|
|
#define bearishVolumeBufferIndex mLastBufferIndex + 10
|
|
double bearishVolumeBuffer[];
|
|
|
|
//
|
|
#define bullishVolumeSignalBufferIndex mLastBufferIndex + 11
|
|
double bullishVolumeSignalBuffer[];
|
|
|
|
//
|
|
#define bearishVolumeSignalBufferIndex mLastBufferIndex + 12
|
|
double bearishVolumeSignalBuffer[];
|
|
|
|
//
|
|
// ATR ...
|
|
|
|
//
|
|
#define atrBufferIndex mLastBufferIndex + 13
|
|
double atrBuffer[];
|
|
|
|
//
|
|
#define atrUpperRawBufferIndex mLastBufferIndex + 14
|
|
double atrUpperRawBuffer[];
|
|
|
|
//
|
|
#define atrLowerRawBufferIndex mLastBufferIndex + 15
|
|
double atrLowerRawBuffer[];
|
|
|
|
//
|
|
// HK ...
|
|
|
|
//
|
|
#define openHKBufferIndex mLastBufferIndex + 16
|
|
double openHKBuffer[];
|
|
|
|
//
|
|
#define highHKBufferIndex mLastBufferIndex + 17
|
|
double highHKBuffer[];
|
|
|
|
//
|
|
#define lowHKBufferIndex mLastBufferIndex + 18
|
|
double lowHKBuffer[];
|
|
|
|
//
|
|
#define closeHKBufferIndex mLastBufferIndex + 19
|
|
double closeHKBuffer[];
|
|
|
|
//
|
|
// KI ...
|
|
|
|
//
|
|
#define kiStateBufferIndex mLastBufferIndex + 20
|
|
double kiStateBuffer[];
|
|
|
|
//
|
|
// Variables, Properties and etc ...
|
|
|
|
//
|
|
int limit;
|
|
|
|
//
|
|
int maxLength;
|
|
|
|
//
|
|
int firstBarIndex;
|
|
|
|
//
|
|
// Bars Color Variables ...
|
|
color _upColor = clrLime;
|
|
color _downColor = clrRed;
|
|
color _lineColor = clrLime;
|
|
color _bullishColor = clrLime;
|
|
color _bearishColor = clrRed;
|
|
|
|
//
|
|
// XMarketCycle sc;
|
|
int mSCLength = 0;
|
|
ENUM_TIMEFRAMES mSCPeriod = NULL;
|
|
|
|
//
|
|
// XMarketCycle mc;
|
|
int mMCLength = 0;
|
|
ENUM_TIMEFRAMES mMCPeriod = NULL;
|
|
|
|
//
|
|
// XMarketCycle lc;
|
|
int mLCLength = 0;
|
|
ENUM_TIMEFRAMES mLCPeriod = NULL;
|
|
|
|
//
|
|
// XMarketCycle hc;
|
|
int mHCLength = 0;
|
|
ENUM_TIMEFRAMES mHCPeriod = NULL;
|
|
|
|
//
|
|
// Applied Cycle ...
|
|
int mAppliedLength;
|
|
ENUM_TIMEFRAMES mAppliedPeriod = NULL;
|
|
|
|
//
|
|
// Handlers ...
|
|
int atrHandler = INVALID_HANDLE;
|
|
int sarHandler = INVALID_HANDLE;
|
|
int rsiHandler = INVALID_HANDLE;
|
|
int adxHandler = INVALID_HANDLE;
|
|
int trendHandler = INVALID_HANDLE;
|
|
|
|
//
|
|
// Event Handlers ...
|
|
|
|
/**
|
|
* Initialize Indicator ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int OnInit()
|
|
{
|
|
//
|
|
bool has = false;
|
|
|
|
//
|
|
ReadBarStyle();
|
|
|
|
//
|
|
// Validate Inputs ...
|
|
has = ValidateInputs();
|
|
if (!has)
|
|
{
|
|
return INIT_PARAMETERS_INCORRECT;
|
|
}
|
|
|
|
//
|
|
has = InitCycles();
|
|
if (!has)
|
|
{
|
|
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();
|
|
|
|
//
|
|
// Initial Requirements ...
|
|
has = InitRequirements();
|
|
if (!has)
|
|
{
|
|
return INIT_FAILED;
|
|
}
|
|
|
|
//
|
|
if (showBars)
|
|
{
|
|
ShowBars();
|
|
}
|
|
else
|
|
{
|
|
HideBars();
|
|
}
|
|
|
|
//
|
|
// Define Index Buffers ...
|
|
DefineBuffers();
|
|
|
|
//
|
|
// Set Indicator ShortName ...
|
|
SetIndicatorName();
|
|
|
|
//
|
|
// 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
|
|
|
|
//
|
|
ShowBars();
|
|
|
|
//
|
|
// De Initialize all Handlers and etc ...
|
|
IndicatorRelease(atrHandler);
|
|
IndicatorRelease(sarHandler);
|
|
IndicatorRelease(rsiHandler);
|
|
IndicatorRelease(adxHandler);
|
|
IndicatorRelease(trendHandler);
|
|
}
|
|
|
|
/**
|
|
* 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 ...
|
|
|
|
//
|
|
// ATR ...
|
|
int atrCalculatedBars = BarsCalculated(atrHandler);
|
|
|
|
//
|
|
// SAR ...
|
|
int sarCalculatedBars = BarsCalculated(sarHandler);
|
|
|
|
//
|
|
// RSI ...
|
|
int rsiCalculatedBars = BarsCalculated(rsiHandler);
|
|
|
|
//
|
|
// ADX ...
|
|
int adxCalculatedBars = BarsCalculated(adxHandler);
|
|
|
|
//
|
|
// TREND ...
|
|
int trendCalculatedBars = BarsCalculated(trendHandler);
|
|
|
|
//
|
|
bool isPassedRequiredCalculatedBars =
|
|
//
|
|
// ATR ...
|
|
atrCalculatedBars >= maxLength &&
|
|
//
|
|
// SAR ...
|
|
sarCalculatedBars >= maxLength &&
|
|
//
|
|
// RSI ...
|
|
rsiCalculatedBars >= maxLength &&
|
|
//
|
|
// ADX ...
|
|
adxCalculatedBars >= maxLength &&
|
|
//
|
|
// TREND ...
|
|
trendCalculatedBars >= maxLength
|
|
//
|
|
;
|
|
if (!isPassedRequiredCalculatedBars)
|
|
{
|
|
return prev_calculated;
|
|
}
|
|
|
|
//
|
|
limit = (prev_calculated > rates_total || prev_calculated <= 0)
|
|
? rates_total
|
|
: (rates_total - prev_calculated) + 1;
|
|
|
|
//
|
|
// Buffers Copy ...
|
|
|
|
//
|
|
// ATR ...
|
|
int copiedAtrs = CopyBuffer(atrHandler, MAIN_LINE, 0, limit, atrBuffer);
|
|
|
|
//
|
|
// SAR ...
|
|
int copiedSars = CopyBuffer(sarHandler, MAIN_LINE, 0, limit, sarBuffer);
|
|
|
|
//
|
|
// RSI ...
|
|
int copiedRSIs = CopyBuffer(rsiHandler, MAIN_LINE, 0, limit, rsiBuffer);
|
|
|
|
//
|
|
// ADX ...
|
|
int copiedADXs = CopyBuffer(adxHandler, MAIN_LINE, 0, limit, adxBuffer);
|
|
|
|
//
|
|
// ADX Plus ...
|
|
int copiedADXPs = CopyBuffer(adxHandler, PLUSDI_LINE, 0, limit, adxpBuffer);
|
|
|
|
//
|
|
// ADX Negative ...
|
|
int copiedADXNs = CopyBuffer(adxHandler, MINUSDI_LINE, 0, limit, adxnBuffer);
|
|
|
|
//
|
|
// TREND ...
|
|
int copiedTrends = CopyBuffer(trendHandler, MAIN_LINE, 0, limit, trendBuffer);
|
|
|
|
//
|
|
// Validate Copied Items ...
|
|
bool isPassedRequiredCopiedItems =
|
|
//
|
|
// ATR ...
|
|
copiedAtrs >= limit &&
|
|
//
|
|
// SAR ...
|
|
copiedSars >= limit &&
|
|
//
|
|
// RSI ...
|
|
copiedRSIs >= limit &&
|
|
//
|
|
// TREND ...
|
|
copiedTrends >= limit
|
|
//
|
|
;
|
|
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 //
|
|
);
|
|
}
|
|
|
|
//
|
|
if (prev_calculated == 0)
|
|
{
|
|
//
|
|
string message = "History Finished ...";
|
|
Print(message);
|
|
}
|
|
|
|
//
|
|
return rates_total;
|
|
}
|
|
|
|
//
|
|
// Custom Functions ...
|
|
|
|
/**
|
|
* Set Indicator Short Name and also we can define Buffers Labels ...
|
|
*/
|
|
void SetIndicatorName()
|
|
{
|
|
//
|
|
IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
|
|
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
|
|
}
|
|
|
|
/**
|
|
* Validate Input Args for Initialization ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool ValidateInputs()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
sarMax > 0 &&
|
|
sarStep > 0 &&
|
|
rsiOBLevel > 0 &&
|
|
rsiOSLevel > 0 &&
|
|
adxThreshold > 0 &&
|
|
sarMax > sarStep &&
|
|
atrMultiplier > 0 &&
|
|
//
|
|
IsValid(appliedCycle) &&
|
|
//
|
|
IsValid(atrUpperPriceType) &&
|
|
IsValid(atrLowerPriceType) &&
|
|
//
|
|
// CYCLES ...
|
|
(IsValid(scMethod, scPeriod) &&
|
|
IsValid(mcMethod, mcPeriod) &&
|
|
IsValid(lcMethod, lcPeriod) &&
|
|
IsValid(hcMethod, hcPeriod))
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Extract Max Length of Inputs ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int ExtractMaxLengthOfInputs()
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
result = MathMax(mSCLength, mMCLength);
|
|
result = MathMax(result, mLCLength);
|
|
result = MathMax(result, mHCLength);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Define Required Buffers ...
|
|
*/
|
|
void DefineBuffers()
|
|
{
|
|
//
|
|
// Plot Buffers ...
|
|
|
|
//
|
|
// SAR ...
|
|
|
|
//
|
|
ArraySetAsSeries(sarBuffer, true);
|
|
SetIndexBuffer(sarBufferIndex, sarBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(sarBufferPlotIndex, PLOT_SHOW_DATA, showSar);
|
|
PlotIndexSetDouble(sarBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
PlotIndexSetInteger(sarBufferPlotIndex, PLOT_ARROW, sarArrowCode);
|
|
|
|
//
|
|
ArraySetAsSeries(sarColorBuffer, true);
|
|
SetIndexBuffer(sarColorBufferIndex, sarColorBuffer, INDICATOR_COLOR_INDEX);
|
|
|
|
//
|
|
ArraySetAsSeries(sarStateBuffer, true);
|
|
SetIndexBuffer(sarStateBufferIndex, sarStateBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
// PEAK / VALE ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE pvDrawType = showPV ? DRAW_ARROW : DRAW_NONE;
|
|
|
|
//
|
|
// PEAK ...
|
|
|
|
//
|
|
ArraySetAsSeries(peakBuffer, true);
|
|
SetIndexBuffer(peakBufferIndex, peakBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(peakBufferPlotIndex, PLOT_SHOW_DATA, showPV);
|
|
PlotIndexSetInteger(peakBufferPlotIndex, PLOT_DRAW_TYPE, pvDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(peakBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
PlotIndexSetInteger(peakBufferPlotIndex, PLOT_ARROW, peakArrowCode);
|
|
|
|
//
|
|
// VALE ...
|
|
|
|
//
|
|
ArraySetAsSeries(valeBuffer, true);
|
|
SetIndexBuffer(valeBufferIndex, valeBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(valeBufferPlotIndex, PLOT_SHOW_DATA, showPV);
|
|
PlotIndexSetInteger(valeBufferPlotIndex, PLOT_DRAW_TYPE, pvDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(valeBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
PlotIndexSetInteger(valeBufferPlotIndex, PLOT_ARROW, valeArrowCode);
|
|
|
|
//
|
|
// PV GOLDEN ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE pvGoldenDrawType = showPVGolden ? DRAW_LINE : DRAW_NONE;
|
|
|
|
//
|
|
// PEAK Golden ...
|
|
|
|
//
|
|
ArraySetAsSeries(peakGoldenBuffer, true);
|
|
SetIndexBuffer(peakGoldenBufferIndex, peakGoldenBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(peakGoldenBufferPlotIndex, PLOT_SHOW_DATA, showPVGolden);
|
|
PlotIndexSetInteger(peakGoldenBufferPlotIndex, PLOT_DRAW_TYPE, pvGoldenDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(peakGoldenBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
// VALE Golden ...
|
|
|
|
//
|
|
ArraySetAsSeries(valeGoldenBuffer, true);
|
|
SetIndexBuffer(valeGoldenBufferIndex, valeGoldenBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(valeGoldenBufferPlotIndex, PLOT_SHOW_DATA, showPVGolden);
|
|
PlotIndexSetInteger(valeGoldenBufferPlotIndex, PLOT_DRAW_TYPE, pvGoldenDrawType);
|
|
|
|
//
|
|
PlotIndexSetDouble(valeGoldenBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
// ATR Band ...
|
|
|
|
//
|
|
// UPPER ...
|
|
ENUM_DRAW_TYPE atrUpperDrawType = showATRBand ? DRAW_LINE : DRAW_NONE;
|
|
|
|
//
|
|
ArraySetAsSeries(atrUpperBuffer, true);
|
|
SetIndexBuffer(atrUpperBufferIndex, atrUpperBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetDouble(atrUpperBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
PlotIndexSetInteger(atrUpperBufferPlotIndex, PLOT_SHOW_DATA, showATRBand);
|
|
PlotIndexSetInteger(atrUpperBufferPlotIndex, PLOT_DRAW_TYPE, atrUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
ENUM_DRAW_TYPE atrLowerDrawType = showATRBand ? DRAW_LINE : DRAW_NONE;
|
|
|
|
//
|
|
ArraySetAsSeries(atrLowerBuffer, true);
|
|
SetIndexBuffer(atrLowerBufferIndex, atrLowerBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetDouble(atrLowerBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
PlotIndexSetInteger(atrLowerBufferPlotIndex, PLOT_SHOW_DATA, showATRBand);
|
|
PlotIndexSetInteger(atrLowerBufferPlotIndex, PLOT_DRAW_TYPE, atrLowerDrawType);
|
|
|
|
//
|
|
// TREND ...
|
|
|
|
//
|
|
ArraySetAsSeries(trendBuffer, true);
|
|
SetIndexBuffer(trendBufferIndex, trendBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(trendBufferPlotIndex, PLOT_SHOW_DATA, showTrend);
|
|
PlotIndexSetDouble(trendBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
ArraySetAsSeries(trendColorBuffer, true);
|
|
SetIndexBuffer(trendColorBufferIndex, trendColorBuffer, INDICATOR_COLOR_INDEX);
|
|
|
|
//
|
|
ArraySetAsSeries(trendStateBuffer, true);
|
|
SetIndexBuffer(trendStateBufferIndex, trendStateBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
// SIGNAL Bar ...
|
|
|
|
//
|
|
// Signal Bars Color ...
|
|
ArraySetAsSeries(sBarColorBuffer, true);
|
|
SetIndexBuffer(sBarColorBufferIndex, sBarColorBuffer, INDICATOR_COLOR_INDEX);
|
|
|
|
//
|
|
// Set EMPTY_VALUE on XHK Bar Buffer ...
|
|
PlotIndexSetDouble(sBarBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
PlotIndexSetInteger(sBarBufferPlotIndex, PLOT_SHOW_DATA, false);
|
|
|
|
//
|
|
// Open ...
|
|
ArraySetAsSeries(sBarOpenBuffer, true);
|
|
SetIndexBuffer(sBarOpenBufferIndex, sBarOpenBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
// High ...
|
|
ArraySetAsSeries(sBarHighBuffer, true);
|
|
SetIndexBuffer(sBarHighBufferIndex, sBarHighBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
// Low ...
|
|
ArraySetAsSeries(sBarLowBuffer, true);
|
|
SetIndexBuffer(sBarLowBufferIndex, sBarLowBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
// Close ...
|
|
ArraySetAsSeries(sBarCloseBuffer, true);
|
|
SetIndexBuffer(sBarCloseBufferIndex, sBarCloseBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
// XHK SIGNAL Bar ...
|
|
|
|
//
|
|
// HK Bars Color ...
|
|
ArraySetAsSeries(hkSBarColorBuffer, true);
|
|
SetIndexBuffer(hkSBarColorBufferIndex, hkSBarColorBuffer, INDICATOR_COLOR_INDEX);
|
|
|
|
//
|
|
// Set EMPTY_VALUE on XHK Bar Buffer ...
|
|
PlotIndexSetDouble(hkSBarBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
PlotIndexSetInteger(hkSBarBufferPlotIndex, PLOT_SHOW_DATA, false);
|
|
|
|
//
|
|
// Open ...
|
|
ArraySetAsSeries(hkSBarOpenBuffer, true);
|
|
SetIndexBuffer(hkSBarOpenBufferIndex, hkSBarOpenBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
// High ...
|
|
ArraySetAsSeries(hkSBarHighBuffer, true);
|
|
SetIndexBuffer(hkSBarHighBufferIndex, hkSBarHighBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
// Low ...
|
|
ArraySetAsSeries(hkSBarLowBuffer, true);
|
|
SetIndexBuffer(hkSBarLowBufferIndex, hkSBarLowBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
// Close ...
|
|
ArraySetAsSeries(hkSBarCloseBuffer, true);
|
|
SetIndexBuffer(hkSBarCloseBufferIndex, hkSBarCloseBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
// CYCLES ...
|
|
|
|
//
|
|
// SHORT ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE sDrawType = showShortCycle ? DRAW_LINE : DRAW_NONE;
|
|
|
|
//
|
|
// HH ...
|
|
|
|
//
|
|
ArraySetAsSeries(sHHBuffer, true);
|
|
SetIndexBuffer(sHHBufferIndex, sHHBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(sHHBufferPlotIndex, PLOT_SHOW_DATA, showShortCycle);
|
|
PlotIndexSetInteger(sHHBufferPlotIndex, PLOT_DRAW_TYPE, sDrawType);
|
|
PlotIndexSetDouble(sHHBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
// LL ...
|
|
|
|
//
|
|
ArraySetAsSeries(sLLBuffer, true);
|
|
SetIndexBuffer(sLLBufferIndex, sLLBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(sLLBufferPlotIndex, PLOT_SHOW_DATA, showShortCycle);
|
|
PlotIndexSetInteger(sLLBufferPlotIndex, PLOT_DRAW_TYPE, sDrawType);
|
|
PlotIndexSetDouble(sLLBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
// MEDIUM ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE mDrawType = showMediumCycle ? DRAW_LINE : DRAW_NONE;
|
|
|
|
//
|
|
// HH ...
|
|
|
|
//
|
|
ArraySetAsSeries(mHHBuffer, true);
|
|
SetIndexBuffer(mHHBufferIndex, mHHBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(mHHBufferPlotIndex, PLOT_SHOW_DATA, showMediumCycle);
|
|
PlotIndexSetInteger(mHHBufferPlotIndex, PLOT_DRAW_TYPE, mDrawType);
|
|
PlotIndexSetDouble(mHHBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
// LL ...
|
|
|
|
//
|
|
ArraySetAsSeries(mLLBuffer, true);
|
|
SetIndexBuffer(mLLBufferIndex, mLLBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(mLLBufferPlotIndex, PLOT_SHOW_DATA, showMediumCycle);
|
|
PlotIndexSetInteger(mLLBufferPlotIndex, PLOT_DRAW_TYPE, mDrawType);
|
|
PlotIndexSetDouble(mLLBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
// LONG ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE lDrawType = showLongCycle ? DRAW_LINE : DRAW_NONE;
|
|
|
|
//
|
|
// HH ...
|
|
|
|
//
|
|
ArraySetAsSeries(lHHBuffer, true);
|
|
SetIndexBuffer(lHHBufferIndex, lHHBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(lHHBufferPlotIndex, PLOT_SHOW_DATA, showLongCycle);
|
|
PlotIndexSetInteger(lHHBufferPlotIndex, PLOT_DRAW_TYPE, lDrawType);
|
|
PlotIndexSetDouble(lHHBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
// LL ...
|
|
|
|
//
|
|
ArraySetAsSeries(lLLBuffer, true);
|
|
SetIndexBuffer(lLLBufferIndex, lLLBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(lLLBufferPlotIndex, PLOT_SHOW_DATA, showLongCycle);
|
|
PlotIndexSetInteger(lLLBufferPlotIndex, PLOT_DRAW_TYPE, lDrawType);
|
|
PlotIndexSetDouble(lLLBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
// HIND ...
|
|
|
|
//
|
|
ENUM_DRAW_TYPE hDrawType = showHindCycle ? DRAW_LINE : DRAW_NONE;
|
|
|
|
//
|
|
// HH ...
|
|
|
|
//
|
|
ArraySetAsSeries(hHHBuffer, true);
|
|
SetIndexBuffer(hHHBufferIndex, hHHBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(hHHBufferPlotIndex, PLOT_SHOW_DATA, showHindCycle);
|
|
PlotIndexSetInteger(hHHBufferPlotIndex, PLOT_DRAW_TYPE, hDrawType);
|
|
PlotIndexSetDouble(hHHBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
// LL ...
|
|
|
|
//
|
|
ArraySetAsSeries(hLLBuffer, true);
|
|
SetIndexBuffer(hLLBufferIndex, hLLBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(hLLBufferPlotIndex, PLOT_SHOW_DATA, showHindCycle);
|
|
PlotIndexSetInteger(hLLBufferPlotIndex, PLOT_DRAW_TYPE, hDrawType);
|
|
PlotIndexSetDouble(hLLBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
// KI ...
|
|
|
|
//
|
|
ArraySetAsSeries(kiBuffer, true);
|
|
SetIndexBuffer(kiBufferIndex, kiBuffer, INDICATOR_DATA);
|
|
|
|
//
|
|
PlotIndexSetInteger(kiBufferPlotIndex, PLOT_SHOW_DATA, showKI);
|
|
PlotIndexSetDouble(kiBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue);
|
|
|
|
//
|
|
ArraySetAsSeries(kiColorBuffer, true);
|
|
SetIndexBuffer(kiColorBufferIndex, kiColorBuffer, INDICATOR_COLOR_INDEX);
|
|
|
|
//
|
|
// Data Buffers ...
|
|
|
|
//
|
|
// RSI ...
|
|
ArraySetAsSeries(rsiBuffer, true);
|
|
SetIndexBuffer(rsiBufferIndex, rsiBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
// ADX ...
|
|
|
|
//
|
|
ArraySetAsSeries(adxBuffer, true);
|
|
SetIndexBuffer(adxBufferIndex, adxBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(adxpBuffer, true);
|
|
SetIndexBuffer(adxpBufferIndex, adxpBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(adxnBuffer, true);
|
|
SetIndexBuffer(adxnBufferIndex, adxnBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
// DELTA ...
|
|
|
|
//
|
|
ArraySetAsSeries(deltaBuffer, true);
|
|
SetIndexBuffer(deltaBufferIndex, deltaBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(deltaSignalBuffer, true);
|
|
SetIndexBuffer(deltaSignalBufferIndex, deltaSignalBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
// VOLUME ...
|
|
|
|
//
|
|
ArraySetAsSeries(bullishVolumeBuffer, true);
|
|
SetIndexBuffer(bullishVolumeBufferIndex, bullishVolumeBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(bearishVolumeBuffer, true);
|
|
SetIndexBuffer(bearishVolumeBufferIndex, bearishVolumeBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(bullishVolumeSignalBuffer, true);
|
|
SetIndexBuffer(bullishVolumeSignalBufferIndex, bullishVolumeSignalBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(bearishVolumeSignalBuffer, true);
|
|
SetIndexBuffer(bearishVolumeSignalBufferIndex, bearishVolumeSignalBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
// ATR ...
|
|
|
|
ArraySetAsSeries(atrBuffer, true);
|
|
SetIndexBuffer(atrBufferIndex, atrBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(atrUpperRawBuffer, true);
|
|
SetIndexBuffer(atrUpperRawBufferIndex, atrUpperRawBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(atrLowerRawBuffer, true);
|
|
SetIndexBuffer(atrLowerRawBufferIndex, atrLowerRawBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
// XHK ...
|
|
|
|
//
|
|
ArraySetAsSeries(openHKBuffer, true);
|
|
SetIndexBuffer(openHKBufferIndex, openHKBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(highHKBuffer, true);
|
|
SetIndexBuffer(highHKBufferIndex, highHKBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(lowHKBuffer, true);
|
|
SetIndexBuffer(lowHKBufferIndex, lowHKBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
ArraySetAsSeries(closeHKBuffer, true);
|
|
SetIndexBuffer(closeHKBufferIndex, closeHKBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
// KI ...
|
|
|
|
//
|
|
ArraySetAsSeries(kiStateBuffer, true);
|
|
SetIndexBuffer(kiStateBufferIndex, kiStateBuffer, INDICATOR_CALCULATIONS);
|
|
|
|
//
|
|
}
|
|
|
|
/**
|
|
* Initial Market Cycles ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool InitCycles()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
int cPeriodSeconds = PeriodSeconds(_Period);
|
|
|
|
//
|
|
// Find Cycle Period ...
|
|
if (scMethod == X_PERIOD_AUTO)
|
|
{
|
|
//
|
|
// Select Period ...
|
|
mSCPeriod = GetCyclePeriod(
|
|
X_MARKET_CYCLE_SHORT,
|
|
_Period //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mSCPeriod = scPeriod;
|
|
}
|
|
|
|
//
|
|
if (IsValid(mSCPeriod))
|
|
{
|
|
mSCLength = PeriodSeconds(mSCPeriod) / cPeriodSeconds;
|
|
}
|
|
|
|
//
|
|
// Find Cycle Period ...
|
|
if (mcMethod == X_PERIOD_AUTO)
|
|
{
|
|
//
|
|
// Select Period ...
|
|
mMCPeriod = GetCyclePeriod(
|
|
X_MARKET_CYCLE_MEDIUM,
|
|
_Period //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mMCPeriod = mcPeriod;
|
|
}
|
|
|
|
//
|
|
if (IsValid(mMCPeriod))
|
|
{
|
|
mMCLength = PeriodSeconds(mMCPeriod) / cPeriodSeconds;
|
|
}
|
|
|
|
//
|
|
// Find Cycle Period ...
|
|
if (lcMethod == X_PERIOD_AUTO)
|
|
{
|
|
//
|
|
// Select Period ...
|
|
mLCPeriod = GetCyclePeriod(
|
|
X_MARKET_CYCLE_LONG,
|
|
_Period //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mLCPeriod = lcPeriod;
|
|
}
|
|
|
|
//
|
|
if (IsValid(mLCPeriod))
|
|
{
|
|
mLCLength = PeriodSeconds(mLCPeriod) / cPeriodSeconds;
|
|
}
|
|
|
|
//
|
|
// Find Cycle Period ...
|
|
if (hcMethod == X_PERIOD_AUTO)
|
|
{
|
|
//
|
|
// Select Period ...
|
|
mHCPeriod = GetCyclePeriod(
|
|
X_MARKET_CYCLE_HIND,
|
|
_Period //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mHCPeriod = hcPeriod;
|
|
}
|
|
|
|
//
|
|
if (IsValid(mHCPeriod))
|
|
{
|
|
mHCLength = PeriodSeconds(mHCPeriod) / cPeriodSeconds;
|
|
}
|
|
|
|
//
|
|
result = mSCLength > 0 &&
|
|
mMCLength > mSCLength &&
|
|
mLCLength > mMCLength &&
|
|
mHCLength > mLCLength;
|
|
|
|
//
|
|
// Selecte Applied Cycle ...
|
|
if (result)
|
|
{
|
|
//
|
|
switch (appliedCycle)
|
|
{
|
|
//
|
|
case X_MARKET_CYCLE_SHORT:
|
|
//
|
|
mAppliedLength = mSCLength;
|
|
mAppliedPeriod = mSCPeriod;
|
|
break;
|
|
|
|
//
|
|
case X_MARKET_CYCLE_MEDIUM:
|
|
//
|
|
mAppliedLength = mMCLength;
|
|
mAppliedPeriod = mMCPeriod;
|
|
break;
|
|
|
|
//
|
|
case X_MARKET_CYCLE_LONG:
|
|
//
|
|
mAppliedLength = mLCLength;
|
|
mAppliedPeriod = mLCPeriod;
|
|
break;
|
|
|
|
//
|
|
case X_MARKET_CYCLE_HIND:
|
|
//
|
|
mAppliedLength = mHCLength;
|
|
mAppliedPeriod = mHCPeriod;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Initial all Indicator Requirements ...
|
|
*
|
|
* @return ( false )
|
|
*
|
|
*/
|
|
bool InitRequirements()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Handlers ...
|
|
|
|
//
|
|
// SAR ...
|
|
sarHandler = iSAR(
|
|
_Symbol,
|
|
_Period,
|
|
sarStep,
|
|
sarMax //
|
|
);
|
|
result = sarHandler != INVALID_HANDLE;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// ATR ...
|
|
atrHandler = iATR(
|
|
_Symbol,
|
|
_Period,
|
|
mAppliedLength //
|
|
);
|
|
result = atrHandler != INVALID_HANDLE;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// RSI ...
|
|
rsiHandler = iRSI(
|
|
_Symbol,
|
|
_Period,
|
|
mAppliedLength,
|
|
rsiAppliedTo //
|
|
);
|
|
result = rsiHandler != INVALID_HANDLE;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// ADX ...
|
|
adxHandler = iADX(
|
|
_Symbol,
|
|
_Period,
|
|
mAppliedLength //
|
|
);
|
|
result = adxHandler != INVALID_HANDLE;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// TREND ...
|
|
trendHandler = iMA(
|
|
_Symbol,
|
|
_Period,
|
|
mAppliedLength,
|
|
0,
|
|
trendMode,
|
|
trendAppliedTo //
|
|
);
|
|
result = trendHandler != INVALID_HANDLE;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Calculate Custom Buffers ...
|
|
*
|
|
* @param barIndex: 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 barIndex,
|
|
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;
|
|
if (barsLimit == 0)
|
|
{
|
|
//
|
|
barsLimit = ratesTotal;
|
|
firstBarIndex = barsLimit - 1;
|
|
}
|
|
else
|
|
{
|
|
firstBarIndex = startCalculationForLastBars;
|
|
}
|
|
|
|
//
|
|
// bool canCalculate = true;
|
|
bool canCalculate =
|
|
barIndex <= barsLimit;
|
|
if (canCalculate)
|
|
{
|
|
//
|
|
// Calculate Values ...
|
|
CalculateValues(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
FillBuffersZero(barIndex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fill All Bufers to Zero Vlue for Specified Bar Index ...
|
|
*
|
|
* @param barIndex: Integer ...
|
|
*/
|
|
void FillBuffersZero(int barIndex)
|
|
{
|
|
//
|
|
kiColorBuffer[barIndex] = hideColorIDX;
|
|
sarColorBuffer[barIndex] = hideColorIDX;
|
|
trendColorBuffer[barIndex] = hideColorIDX;
|
|
|
|
//
|
|
atrUpperRawBuffer[barIndex] = emptyValue;
|
|
atrLowerRawBuffer[barIndex] = emptyValue;
|
|
}
|
|
|
|
//
|
|
// Custom Handlers ...
|
|
|
|
/**
|
|
* Calculate Values ...
|
|
*
|
|
* @param barIndex: int, Specified Bar Index ...
|
|
* @param prevCalculated: int, Provides Previous Calculated Bars ...
|
|
* @param ratesTotal: int, Provides All Availabled Bars ...
|
|
* @param open: double Collection, Provides Open Prices Time Series ...
|
|
* @param high: double Collection, Provides High Prices Time Series ...
|
|
* @param close: double Collection, Provides Close Prices Time Series ...
|
|
* @param low: double Collection, Provides Low Prices Time Series ...
|
|
* @param tickVolume: long Collection, Provides Ticks Volume Prices Time Series ...
|
|
*/
|
|
void CalculateValues(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
int lastBarIndex = barIndex + 1;
|
|
int maxBarIndex = startCalculationForLastBars > 0
|
|
? startCalculationForLastBars
|
|
: ratesTotal;
|
|
bool isFirstBar =
|
|
startCalculationForLastBars > 0
|
|
? barIndex == startCalculationForLastBars
|
|
: barIndex == firstBarIndex;
|
|
|
|
//
|
|
// Cycle Ranges ...
|
|
CalculateCycleRanges(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
|
|
//
|
|
// KI ...
|
|
CalculateKI(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
|
|
//
|
|
// PV ...
|
|
CalculatePV(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
|
|
//
|
|
// SAR ...
|
|
CalculateSAR(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
|
|
//
|
|
// SBAR ...
|
|
CalculateSBar(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
|
|
//
|
|
// HKBAR ...
|
|
CalculateHKBar(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
|
|
//
|
|
// DELTA ...
|
|
CalculateDelta(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
|
|
//
|
|
// TREND ...
|
|
CalculateTrend(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
|
|
//
|
|
// VOLUME ...
|
|
CalculateVolume(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
|
|
//
|
|
// ATR Band ...
|
|
CalculateATRBand(
|
|
barIndex,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
}
|
|
|
|
//
|
|
void CalculateCycleRanges(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
// SHORT ...
|
|
CalculateCycle(
|
|
barIndex,
|
|
X_MARKET_CYCLE_SHORT,
|
|
sHHBuffer,
|
|
sLLBuffer //
|
|
);
|
|
|
|
//
|
|
// MEDIUM ...
|
|
CalculateCycle(
|
|
barIndex,
|
|
X_MARKET_CYCLE_MEDIUM,
|
|
mHHBuffer,
|
|
mLLBuffer //
|
|
);
|
|
|
|
//
|
|
// LONG ...
|
|
CalculateCycle(
|
|
barIndex,
|
|
X_MARKET_CYCLE_LONG,
|
|
lHHBuffer,
|
|
lLLBuffer //
|
|
);
|
|
|
|
//
|
|
// HIND ...
|
|
CalculateCycle(
|
|
barIndex,
|
|
X_MARKET_CYCLE_HIND,
|
|
hHHBuffer,
|
|
hLLBuffer //
|
|
);
|
|
}
|
|
|
|
//
|
|
void CalculateKI(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
int lastBarIndex = barIndex + 1;
|
|
bool isFirstBar =
|
|
startCalculationForLastBars > 0
|
|
? barIndex == startCalculationForLastBars
|
|
: barIndex == firstBarIndex;
|
|
|
|
//
|
|
XOHCL iBar;
|
|
bool isInited = iBar.Init(
|
|
_Symbol,
|
|
_Period,
|
|
barIndex //
|
|
);
|
|
|
|
//
|
|
double iClose = close[barIndex];
|
|
|
|
//
|
|
// Calculate KI / Color ...
|
|
double lastKI =
|
|
isFirstBar
|
|
? emptyValue
|
|
: kiBuffer[lastBarIndex];
|
|
double iKI = lastKI;
|
|
if (isInited)
|
|
{
|
|
//
|
|
double iLLKI = iBar.FindLowest(kiLength, MODE_LOW);
|
|
double iHHKI = iBar.FindHighest(kiLength, MODE_HIGH);
|
|
|
|
//
|
|
iKI = (iHHKI + iLLKI) / 2;
|
|
if (iLLKI == 0 || iHHKI == 0)
|
|
{
|
|
iKI = lastKI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iKI = lastKI;
|
|
}
|
|
kiBuffer[barIndex] = iKI;
|
|
|
|
//
|
|
double iKIState = neuturalState;
|
|
double iKIColor = neuturalColorIDX;
|
|
if (iClose > iKI)
|
|
{
|
|
//
|
|
iKIState = bullishState;
|
|
iKIColor =
|
|
!showKI
|
|
? hideColorIDX
|
|
: bullishColorIDX;
|
|
}
|
|
else if (iClose < iKI)
|
|
{
|
|
//
|
|
iKIState = bearishState;
|
|
iKIColor =
|
|
!showKI
|
|
? hideColorIDX
|
|
: bearishColorIDX;
|
|
}
|
|
kiStateBuffer[barIndex] = iKIState;
|
|
kiColorBuffer[barIndex] = iKIColor;
|
|
|
|
//
|
|
iBar.Clean();
|
|
}
|
|
|
|
//
|
|
void CalculatePV(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
int lastBarIndex = barIndex + 1;
|
|
bool isFirstBar =
|
|
startCalculationForLastBars > 0
|
|
? barIndex == startCalculationForLastBars
|
|
: barIndex == firstBarIndex;
|
|
|
|
//
|
|
double iSHH = sHHBuffer[barIndex];
|
|
double iSLL = sLLBuffer[barIndex];
|
|
|
|
//
|
|
double iMHH = mHHBuffer[barIndex];
|
|
double iMLL = mLLBuffer[barIndex];
|
|
|
|
//
|
|
double iLHH = lHHBuffer[barIndex];
|
|
double iLLL = lLLBuffer[barIndex];
|
|
|
|
//
|
|
double iHHH = hHHBuffer[barIndex];
|
|
double iHLL = hLLBuffer[barIndex];
|
|
|
|
//
|
|
// Calculate VALE ...
|
|
bool isVale = iSLL == iMLL &&
|
|
iMLL == iLLL &&
|
|
iLLL == iHLL;
|
|
double iPVale =
|
|
isFirstBar
|
|
? emptyValue
|
|
: valeBuffer[lastBarIndex];
|
|
double iVale =
|
|
isVale
|
|
? iSLL
|
|
: iPVale;
|
|
valeBuffer[barIndex] = iVale;
|
|
|
|
//
|
|
// Calculate PEAK ...
|
|
bool isPeak = iSHH == iMHH &&
|
|
iMHH == iLHH &&
|
|
iLHH == iHHH;
|
|
double iPPeak =
|
|
isFirstBar
|
|
? emptyValue
|
|
: peakBuffer[lastBarIndex];
|
|
double iPeak =
|
|
isPeak
|
|
? iSHH
|
|
: iPPeak;
|
|
peakBuffer[barIndex] = iPeak;
|
|
|
|
//
|
|
// GOLDEN ...
|
|
|
|
XOHCL iBar;
|
|
bool isInited = iBar.Init(
|
|
_Symbol,
|
|
_Period,
|
|
barIndex //
|
|
);
|
|
|
|
//
|
|
// Calculate PV Gold ...
|
|
double lastPeakGold =
|
|
isFirstBar
|
|
? emptyValue
|
|
: peakGoldenBuffer[lastBarIndex];
|
|
double lastValeGold =
|
|
isFirstBar
|
|
? emptyValue
|
|
: valeGoldenBuffer[lastBarIndex];
|
|
double iPeakGold = lastPeakGold;
|
|
double iValeGold = lastValeGold;
|
|
if (isInited)
|
|
{
|
|
//
|
|
iPeakGold = iBar.FindHighest(mHCLength, MODE_CLOSE);
|
|
if (iPeakGold == 0)
|
|
{
|
|
iPeakGold = lastPeakGold;
|
|
}
|
|
|
|
//
|
|
iValeGold = iBar.FindLowest(mHCLength, MODE_CLOSE);
|
|
if (iValeGold == 0)
|
|
{
|
|
iValeGold = lastValeGold;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
iPeakGold = lastPeakGold;
|
|
iValeGold = lastValeGold;
|
|
}
|
|
|
|
//
|
|
peakGoldenBuffer[barIndex] = iPeakGold;
|
|
valeGoldenBuffer[barIndex] = iValeGold;
|
|
|
|
//
|
|
iBar.Clean();
|
|
}
|
|
|
|
//
|
|
void CalculateSAR(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
double iLow = low[barIndex];
|
|
double iHigh = low[barIndex];
|
|
double iSar = sarBuffer[barIndex];
|
|
|
|
//
|
|
bool isBullish = iSar < iLow;
|
|
bool isBearish = iSar > iHigh;
|
|
|
|
//
|
|
double iSarState = isBullish
|
|
? 1
|
|
: isBearish
|
|
? -1
|
|
: 0;
|
|
double iSarColor = iSarState > 0
|
|
? bullishColorIDX
|
|
: iSarState < 0
|
|
? bearishColorIDX
|
|
: neuturalColorIDX;
|
|
sarStateBuffer[barIndex] = iSarState;
|
|
sarColorBuffer[barIndex] = showSar
|
|
? iSarColor
|
|
: hideColorIDX;
|
|
}
|
|
|
|
//
|
|
void CalculateSBar(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
// Open ...
|
|
iMAOnBuffer(
|
|
ratesTotal,
|
|
prevCalculated,
|
|
barIndex,
|
|
mAppliedLength,
|
|
open,
|
|
sBarOpenBuffer,
|
|
barsSignalMethod //
|
|
);
|
|
|
|
//
|
|
// Close ...
|
|
iMAOnBuffer(
|
|
ratesTotal,
|
|
prevCalculated,
|
|
barIndex,
|
|
mAppliedLength,
|
|
close,
|
|
sBarCloseBuffer,
|
|
barsSignalMethod //
|
|
);
|
|
|
|
//
|
|
double min = MathMin(sBarCloseBuffer[barIndex], sBarOpenBuffer[barIndex]);
|
|
double max = MathMin(sBarCloseBuffer[barIndex], sBarOpenBuffer[barIndex]);
|
|
|
|
//
|
|
sBarLowBuffer[barIndex] = min;
|
|
sBarHighBuffer[barIndex] = max;
|
|
|
|
//
|
|
// Calculate HK Signal Color ...
|
|
double iSignalColorValue =
|
|
sBarOpenBuffer[barIndex] < sBarCloseBuffer[barIndex]
|
|
? bullishColorIDX
|
|
: bearishColorIDX;
|
|
sBarColorBuffer[barIndex] =
|
|
showSignalBars
|
|
? iSignalColorValue
|
|
: hideColorIDX;
|
|
}
|
|
|
|
//
|
|
void CalculateHKBar(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
int lastBarIndex = barIndex + 1;
|
|
bool isFirstBar =
|
|
startCalculationForLastBars > 0
|
|
? barIndex == startCalculationForLastBars
|
|
: barIndex == firstBarIndex;
|
|
|
|
//
|
|
double lastHKOpen =
|
|
isFirstBar
|
|
? emptyValue
|
|
: openHKBuffer[lastBarIndex];
|
|
double lastHKClose =
|
|
isFirstBar
|
|
? emptyValue
|
|
: closeHKBuffer[lastBarIndex];
|
|
|
|
//
|
|
double iHKOpenValue = (lastHKOpen + lastHKClose) / 2;
|
|
double iHKCloseValue = (open[barIndex] + high[barIndex] + close[barIndex] + low[barIndex]) / 4;
|
|
double iHKHighValue = MathMax(high[barIndex], MathMax(iHKOpenValue, iHKCloseValue));
|
|
double iHKLowValue = MathMin(low[barIndex], MathMin(iHKOpenValue, iHKCloseValue));
|
|
|
|
//
|
|
// Raw HK Buffers ...
|
|
openHKBuffer[barIndex] = iHKOpenValue;
|
|
highHKBuffer[barIndex] = iHKHighValue;
|
|
lowHKBuffer[barIndex] = iHKLowValue;
|
|
closeHKBuffer[barIndex] = iHKCloseValue;
|
|
|
|
//
|
|
// XHK Signal ...
|
|
|
|
//
|
|
// Open ...
|
|
iMAOnBuffer(
|
|
ratesTotal,
|
|
prevCalculated,
|
|
barIndex,
|
|
mAppliedLength,
|
|
openHKBuffer,
|
|
hkSBarOpenBuffer,
|
|
hkSignalBarMethod //
|
|
);
|
|
|
|
//
|
|
// Close ...
|
|
iMAOnBuffer(
|
|
ratesTotal,
|
|
prevCalculated,
|
|
barIndex,
|
|
mAppliedLength,
|
|
closeHKBuffer,
|
|
hkSBarCloseBuffer,
|
|
hkSignalBarMethod //
|
|
);
|
|
|
|
//
|
|
double min = MathMin(hkSBarCloseBuffer[barIndex], hkSBarOpenBuffer[barIndex]);
|
|
double max = MathMin(hkSBarCloseBuffer[barIndex], hkSBarOpenBuffer[barIndex]);
|
|
|
|
//
|
|
hkSBarLowBuffer[barIndex] = min;
|
|
hkSBarHighBuffer[barIndex] = max;
|
|
|
|
//
|
|
// Calculate HK Signal Color ...
|
|
double iHKSignalColorValue =
|
|
hkSBarOpenBuffer[barIndex] < hkSBarCloseBuffer[barIndex]
|
|
? bullishColorIDX
|
|
: bearishColorIDX;
|
|
hkSBarColorBuffer[barIndex] =
|
|
showHKSignalBars
|
|
? iHKSignalColorValue
|
|
: hideColorIDX;
|
|
}
|
|
|
|
//
|
|
void CalculateDelta(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
int lastBarIndex = barIndex + 1;
|
|
bool isFirstBar =
|
|
startCalculationForLastBars > 0
|
|
? barIndex == startCalculationForLastBars
|
|
: barIndex == firstBarIndex;
|
|
|
|
//
|
|
double iClose = close[barIndex];
|
|
double iOpen = open[barIndex];
|
|
double iVolume = (double)iVolume(_Symbol, _Period, barIndex);
|
|
|
|
//
|
|
bool isBullish = iClose > iOpen;
|
|
bool isBearish = iClose < iOpen;
|
|
|
|
//
|
|
// DELTA ...
|
|
double lastDelta =
|
|
isFirstBar
|
|
? emptyValue
|
|
: deltaBuffer[lastBarIndex];
|
|
double iAppliedVolume =
|
|
isBullish
|
|
? iVolume
|
|
: -1 * iVolume;
|
|
double iDelta =
|
|
lastDelta + iAppliedVolume;
|
|
deltaBuffer[barIndex] = iDelta;
|
|
|
|
//
|
|
// Calculate Delta Signal ...
|
|
int deltaSignalsCount = iMAOnBuffer(
|
|
ratesTotal,
|
|
prevCalculated,
|
|
barIndex,
|
|
mAppliedLength,
|
|
deltaBuffer,
|
|
deltaSignalBuffer,
|
|
deltaSignalMethod //
|
|
);
|
|
}
|
|
|
|
//
|
|
void CalculateTrend(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
double iLow = low[barIndex];
|
|
double iHigh = high[barIndex];
|
|
double iClose = close[barIndex];
|
|
double iTrend = trendBuffer[barIndex];
|
|
|
|
//
|
|
bool isBullish = iTrend < iLow;
|
|
bool isBearish = iTrend > iHigh;
|
|
|
|
//
|
|
double iTrendState =
|
|
isBullish
|
|
? 1
|
|
: isBearish
|
|
? -1
|
|
: 0;
|
|
double iTrendColor =
|
|
iTrendState > 0
|
|
? bullishColorIDX
|
|
: iTrendState < 0
|
|
? bearishColorIDX
|
|
: neuturalColorIDX;
|
|
trendStateBuffer[barIndex] = iTrendState;
|
|
trendColorBuffer[barIndex] = showTrend
|
|
? iTrendColor
|
|
: hideColorIDX;
|
|
}
|
|
|
|
//
|
|
void CalculateVolume(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
double iClose = close[barIndex];
|
|
double iOpen = open[barIndex];
|
|
double iVolume = (double)iVolume(_Symbol, _Period, barIndex);
|
|
|
|
//
|
|
bool isBullish = iClose > iOpen;
|
|
bool isBearish = iClose < iOpen;
|
|
|
|
//
|
|
double iBullishVolume = emptyValue;
|
|
double iBearishVolume = emptyValue;
|
|
if (isBullish)
|
|
{
|
|
iBullishVolume = iVolume;
|
|
}
|
|
else if (isBearish)
|
|
{
|
|
iBearishVolume = iVolume;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
double iHalfVolume = iVolume / 2;
|
|
|
|
//
|
|
iBullishVolume = iHalfVolume;
|
|
iBearishVolume = iHalfVolume;
|
|
}
|
|
bullishVolumeBuffer[barIndex] = iBullishVolume;
|
|
bearishVolumeBuffer[barIndex] = iBearishVolume;
|
|
|
|
//
|
|
// Calculate Volume Signals ...
|
|
|
|
//
|
|
int bullishVolumeSignalsCount = iMAOnBuffer(
|
|
ratesTotal,
|
|
prevCalculated,
|
|
barIndex,
|
|
mAppliedLength,
|
|
bullishVolumeBuffer,
|
|
bullishVolumeSignalBuffer,
|
|
volumeSignalMethod //
|
|
);
|
|
|
|
//
|
|
int bearishVolumeSignalsCount = iMAOnBuffer(
|
|
ratesTotal,
|
|
prevCalculated,
|
|
barIndex,
|
|
mAppliedLength,
|
|
bearishVolumeBuffer,
|
|
bearishVolumeSignalBuffer,
|
|
volumeSignalMethod //
|
|
);
|
|
}
|
|
|
|
//
|
|
void CalculateATRBand(
|
|
int barIndex,
|
|
const int prevCalculated,
|
|
const int ratesTotal,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &close[],
|
|
const double &low[],
|
|
const long &tickVolume[] //
|
|
)
|
|
{
|
|
//
|
|
double iATR = atrBuffer[barIndex];
|
|
double iAppliedATR = atrMultiplier * iATR;
|
|
double iATRUpperPrice = GetAppliedPrice(
|
|
atrUpperPriceType,
|
|
open,
|
|
high,
|
|
low,
|
|
close,
|
|
barIndex //
|
|
);
|
|
double iATRLowerPrice = GetAppliedPrice(
|
|
atrLowerPriceType,
|
|
open,
|
|
high,
|
|
low,
|
|
close,
|
|
barIndex //
|
|
);
|
|
double iATRUpper = iATRUpperPrice + iAppliedATR;
|
|
double iATRLower = iATRLowerPrice - iAppliedATR;
|
|
atrUpperRawBuffer[barIndex] = iATRUpper;
|
|
atrLowerRawBuffer[barIndex] = iATRLower;
|
|
|
|
//
|
|
bool canSignalATR = IsValid(atrSignalMethod);
|
|
if (canSignalATR)
|
|
{
|
|
//
|
|
// Upper ...
|
|
iMAOnBuffer(
|
|
ratesTotal,
|
|
prevCalculated,
|
|
barIndex,
|
|
mAppliedLength,
|
|
atrUpperRawBuffer,
|
|
atrUpperBuffer,
|
|
atrSignalMethod //
|
|
);
|
|
|
|
//
|
|
// Lower ...
|
|
iMAOnBuffer(
|
|
ratesTotal,
|
|
prevCalculated,
|
|
barIndex,
|
|
mAppliedLength,
|
|
atrLowerRawBuffer,
|
|
atrLowerBuffer,
|
|
atrSignalMethod //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
atrUpperBuffer[barIndex] = iATRUpper;
|
|
atrLowerBuffer[barIndex] = iATRLower;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculate Specified Market Cycle Info ...
|
|
*
|
|
* @param barIndex: Integer, Bar Index ...
|
|
* @param cycle: ENUM_X_MARKET_CYCLES member, Specified Cycle ...
|
|
* @param hhBuffer: Highest High Buffer Reference ...
|
|
* @param llBuffer: Lowest Low Buffer Reference ...
|
|
*/
|
|
void CalculateCycle(
|
|
int barIndex,
|
|
ENUM_X_MARKET_CYCLES cycle,
|
|
double &hhBuffer[],
|
|
double &llBuffer[] //
|
|
)
|
|
{
|
|
//
|
|
XOHCL bar;
|
|
bool isBarInited = bar.Init(
|
|
_Symbol,
|
|
_Period,
|
|
barIndex
|
|
//
|
|
);
|
|
if (!isBarInited)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
int mLength = 0;
|
|
switch (cycle)
|
|
{
|
|
//
|
|
case X_MARKET_CYCLE_SHORT:
|
|
mLength = mSCLength;
|
|
break;
|
|
|
|
//
|
|
case X_MARKET_CYCLE_MEDIUM:
|
|
mLength = mMCLength;
|
|
break;
|
|
|
|
//
|
|
case X_MARKET_CYCLE_LONG:
|
|
mLength = mLCLength;
|
|
break;
|
|
|
|
//
|
|
case X_MARKET_CYCLE_HIND:
|
|
mLength = mHCLength;
|
|
break;
|
|
}
|
|
|
|
//
|
|
if (mLength == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Find Highest High ...
|
|
double hhValue = bar.FindHighest(
|
|
mLength,
|
|
upperMode //
|
|
);
|
|
hhBuffer[barIndex] = hhValue;
|
|
|
|
//
|
|
// Find Lowest Low ...
|
|
double llValue = bar.FindLowest(
|
|
mLength,
|
|
lowerMode //
|
|
);
|
|
llBuffer[barIndex] = llValue;
|
|
|
|
//
|
|
bar.Clean();
|
|
}
|
|
|
|
//
|
|
void ReadBarStyle()
|
|
{
|
|
//
|
|
long chartId = ChartID();
|
|
|
|
//
|
|
_upColor = GetChartUpColor(chartId);
|
|
_downColor = GetChartDownColor(chartId);
|
|
_lineColor = GetChartLineColor(chartId);
|
|
_bullishColor = GetChartBullishColor(chartId);
|
|
_bearishColor = GetChartBearishColor(chartId);
|
|
}
|
|
|
|
//
|
|
void ShowBars()
|
|
{
|
|
//
|
|
long chartId = ChartID();
|
|
|
|
//
|
|
SetChartUpColor(_upColor, chartId);
|
|
SetChartDownColor(_downColor, chartId);
|
|
SetChartLineColor(_lineColor, chartId);
|
|
SetChartBullishColor(_bullishColor, chartId);
|
|
SetChartBearishColor(_bearishColor, chartId);
|
|
}
|
|
|
|
//
|
|
void HideBars()
|
|
{
|
|
//
|
|
long chartId = ChartID();
|
|
|
|
//
|
|
SetChartUpColor(CLR_NONE, chartId);
|
|
SetChartDownColor(CLR_NONE, chartId);
|
|
SetChartLineColor(CLR_NONE, chartId);
|
|
SetChartBullishColor(CLR_NONE, chartId);
|
|
SetChartBearishColor(CLR_NONE, chartId);
|
|
}
|
|
|
|
// |