1603 lines
42 KiB
Plaintext
1603 lines
42 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Indicator
|
|
// -------------------------------------------------
|
|
// Name: XCHDON
|
|
// Description: Donchain on Cycles ...
|
|
//
|
|
//
|
|
// 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 XCHDON Indicator"
|
|
#property strict
|
|
|
|
//
|
|
#define ShortName "XCHDON"
|
|
|
|
//
|
|
// Includes Common Library ...
|
|
#include "../Libraries/x-saherelm.common.lib.mq5"
|
|
|
|
//
|
|
// Inputs ...
|
|
|
|
//
|
|
input group "Market";
|
|
input int length = 52; // Market Length
|
|
|
|
//
|
|
input group "Cycles";
|
|
|
|
//
|
|
input group "Short";
|
|
input ENUM_X_PERIOD_METHOD scMethod = X_PERIOD_AUTO; // How to Find Period
|
|
input ENUM_TIMEFRAMES scPeriod = NULL; // Time Period
|
|
|
|
//
|
|
input group "Medium";
|
|
input ENUM_X_PERIOD_METHOD mcMethod = X_PERIOD_AUTO; // How to Find Period
|
|
input ENUM_TIMEFRAMES mcPeriod = NULL; // Time Period
|
|
|
|
//
|
|
input group "Long";
|
|
input ENUM_X_PERIOD_METHOD lcMethod = X_PERIOD_AUTO; // How to Find Period
|
|
input ENUM_TIMEFRAMES lcPeriod = NULL; // Time Period
|
|
|
|
//
|
|
input group "Hind";
|
|
input ENUM_X_PERIOD_METHOD hcMethod = X_PERIOD_AUTO; // How to Find Period
|
|
input ENUM_TIMEFRAMES hcPeriod = NULL; // Time Period
|
|
|
|
//
|
|
input group "Presentation";
|
|
|
|
//
|
|
input bool showUpper = true; // Show Upper Band
|
|
input bool showLower = true; // Show Lower Band
|
|
|
|
//
|
|
input bool showOpen = true; // Show Open
|
|
input bool showHigh = true; // Show High
|
|
input bool showClose = true; // Show Close
|
|
input bool showLow = true; // Show Low
|
|
|
|
//
|
|
input bool showCurrent = true; // Show Current Cycle
|
|
input bool showShort = true; // Show Short Cycle
|
|
input bool showMedium = true; // Show Medium Cycle
|
|
input bool showLong = true; // Show Long Cycle
|
|
input bool showHind = true; // Show Hind Cycle
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
#property indicator_chart_window
|
|
|
|
//
|
|
#property indicator_buffers 40
|
|
#property indicator_plots 40
|
|
|
|
//
|
|
// Current ...
|
|
|
|
//
|
|
// Open ...
|
|
|
|
//
|
|
#define cOpenUpperBufferIndex 0
|
|
double cOpenUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label1 "XCHDON C O U"
|
|
#property indicator_type1 DRAW_LINE
|
|
#property indicator_color1 clrCornflowerBlue
|
|
#property indicator_width1 1
|
|
|
|
//
|
|
#define cOpenLowerBufferIndex 1
|
|
double cOpenLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label2 "XCHDON C O L"
|
|
#property indicator_type2 DRAW_LINE
|
|
#property indicator_color2 clrCornflowerBlue
|
|
#property indicator_width2 1
|
|
|
|
//
|
|
// High ...
|
|
|
|
//
|
|
#define cHighUpperBufferIndex 2
|
|
double cHighUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label3 "XCHDON C H U"
|
|
#property indicator_type3 DRAW_LINE
|
|
#property indicator_color3 clrAquamarine
|
|
#property indicator_width3 1
|
|
|
|
//
|
|
#define cHighLowerBufferIndex 3
|
|
double cHighLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label4 "XCHDON C H L"
|
|
#property indicator_type4 DRAW_LINE
|
|
#property indicator_color4 clrAquamarine
|
|
#property indicator_width4 1
|
|
|
|
//
|
|
// Low ...
|
|
|
|
//
|
|
#define cLowUpperBufferIndex 4
|
|
double cLowUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label5 "XCHDON C L U"
|
|
#property indicator_type5 DRAW_LINE
|
|
#property indicator_color5 clrDarkOrchid
|
|
#property indicator_width5 1
|
|
|
|
//
|
|
#define cLowLowerBufferIndex 5
|
|
double cLowLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label6 "XCHDON C L L"
|
|
#property indicator_type6 DRAW_LINE
|
|
#property indicator_color6 clrDarkOrchid
|
|
#property indicator_width6 1
|
|
|
|
//
|
|
// Close ...
|
|
|
|
//
|
|
#define cCloseUpperBufferIndex 6
|
|
double cCloseUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label7 "XCHDON C C U"
|
|
#property indicator_type7 DRAW_LINE
|
|
#property indicator_color7 clrCoral
|
|
#property indicator_width7 1
|
|
|
|
//
|
|
#define cCloseLowerBufferIndex 7
|
|
double cCloseLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label8 "XCHDON C C L"
|
|
#property indicator_type8 DRAW_LINE
|
|
#property indicator_color8 clrCoral
|
|
#property indicator_width8 1
|
|
|
|
//
|
|
// Short ...
|
|
|
|
//
|
|
// Open ...
|
|
|
|
//
|
|
#define sOpenUpperBufferIndex 8
|
|
double sOpenUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label9 "XCHDON S O U"
|
|
#property indicator_type9 DRAW_LINE
|
|
#property indicator_color9 clrCornflowerBlue
|
|
#property indicator_width9 1
|
|
|
|
//
|
|
#define sOpenLowerBufferIndex 9
|
|
double sOpenLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label10 "XCHDON S O L"
|
|
#property indicator_type10 DRAW_LINE
|
|
#property indicator_color10 clrCornflowerBlue
|
|
#property indicator_width10 1
|
|
|
|
//
|
|
// High ...
|
|
|
|
//
|
|
#define sHighUpperBufferIndex 10
|
|
double sHighUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label11 "XCHDON S H U"
|
|
#property indicator_type11 DRAW_LINE
|
|
#property indicator_color11 clrAquamarine
|
|
#property indicator_width11 1
|
|
|
|
//
|
|
#define sHighLowerBufferIndex 11
|
|
double sHighLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label12 "XCHDON S H L"
|
|
#property indicator_type12 DRAW_LINE
|
|
#property indicator_color12 clrAquamarine
|
|
#property indicator_width12 1
|
|
|
|
//
|
|
// Low ...
|
|
|
|
//
|
|
#define sLowUpperBufferIndex 12
|
|
double sLowUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label13 "XCHDON S L U"
|
|
#property indicator_type13 DRAW_LINE
|
|
#property indicator_color13 clrDarkOrchid
|
|
#property indicator_width13 1
|
|
|
|
//
|
|
#define sLowLowerBufferIndex 13
|
|
double sLowLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label14 "XCHDON S L L"
|
|
#property indicator_type14 DRAW_LINE
|
|
#property indicator_color14 clrDarkOrchid
|
|
#property indicator_width14 1
|
|
|
|
//
|
|
// Close ...
|
|
|
|
//
|
|
#define sCloseUpperBufferIndex 14
|
|
double sCloseUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label15 "XCHDON S C U"
|
|
#property indicator_type15 DRAW_LINE
|
|
#property indicator_color15 clrCoral
|
|
#property indicator_width15 1
|
|
|
|
//
|
|
#define sCloseLowerBufferIndex 15
|
|
double sCloseLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label16 "XCHDON S C L"
|
|
#property indicator_type16 DRAW_LINE
|
|
#property indicator_color16 clrCoral
|
|
#property indicator_width16 1
|
|
|
|
//
|
|
// Medium ...
|
|
|
|
//
|
|
// Open ...
|
|
|
|
//
|
|
#define mOpenUpperBufferIndex 16
|
|
double mOpenUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label17 "XCHDON M O U"
|
|
#property indicator_type17 DRAW_LINE
|
|
#property indicator_color17 clrCornflowerBlue
|
|
#property indicator_width17 1
|
|
|
|
//
|
|
#define mOpenLowerBufferIndex 17
|
|
double mOpenLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label18 "XCHDON M O L"
|
|
#property indicator_type18 DRAW_LINE
|
|
#property indicator_color18 clrCornflowerBlue
|
|
#property indicator_width18 1
|
|
|
|
//
|
|
// High ...
|
|
|
|
//
|
|
#define mHighUpperBufferIndex 18
|
|
double mHighUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label19 "XCHDON M H U"
|
|
#property indicator_type19 DRAW_LINE
|
|
#property indicator_color19 clrAquamarine
|
|
#property indicator_width19 1
|
|
|
|
//
|
|
#define mHighLowerBufferIndex 19
|
|
double mHighLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label20 "XCHDON M H L"
|
|
#property indicator_type20 DRAW_LINE
|
|
#property indicator_color20 clrAquamarine
|
|
#property indicator_width20 1
|
|
|
|
//
|
|
// Low ...
|
|
|
|
//
|
|
#define mLowUpperBufferIndex 20
|
|
double mLowUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label21 "XCHDON M L U"
|
|
#property indicator_type21 DRAW_LINE
|
|
#property indicator_color21 clrDarkOrchid
|
|
#property indicator_width21 1
|
|
|
|
//
|
|
#define mLowLowerBufferIndex 21
|
|
double mLowLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label22 "XCHDON M L L"
|
|
#property indicator_type22 DRAW_LINE
|
|
#property indicator_color22 clrDarkOrchid
|
|
#property indicator_width22 1
|
|
|
|
//
|
|
// Close ...
|
|
|
|
//
|
|
#define mCloseUpperBufferIndex 22
|
|
double mCloseUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label23 "XCHDON M C U"
|
|
#property indicator_type23 DRAW_LINE
|
|
#property indicator_color23 clrCoral
|
|
#property indicator_width23 1
|
|
|
|
//
|
|
#define mCloseLowerBufferIndex 23
|
|
double mCloseLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label24 "XCHDON M C L"
|
|
#property indicator_type24 DRAW_LINE
|
|
#property indicator_color24 clrCoral
|
|
#property indicator_width24 1
|
|
|
|
//
|
|
// Long ...
|
|
|
|
//
|
|
// Open ...
|
|
|
|
//
|
|
#define lOpenUpperBufferIndex 24
|
|
double lOpenUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label25 "XCHDON L O U"
|
|
#property indicator_type25 DRAW_LINE
|
|
#property indicator_color25 clrCornflowerBlue
|
|
#property indicator_width25 1
|
|
|
|
//
|
|
#define lOpenLowerBufferIndex 25
|
|
double lOpenLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label26 "XCHDON L O L"
|
|
#property indicator_type26 DRAW_LINE
|
|
#property indicator_color26 clrCornflowerBlue
|
|
#property indicator_width26 1
|
|
|
|
//
|
|
// High ...
|
|
|
|
//
|
|
#define lHighUpperBufferIndex 26
|
|
double lHighUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label27 "XCHDON L H U"
|
|
#property indicator_type27 DRAW_LINE
|
|
#property indicator_color27 clrAquamarine
|
|
#property indicator_width27 1
|
|
|
|
//
|
|
#define lHighLowerBufferIndex 27
|
|
double lHighLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label28 "XCHDON L H L"
|
|
#property indicator_type28 DRAW_LINE
|
|
#property indicator_color28 clrAquamarine
|
|
#property indicator_width28 1
|
|
|
|
//
|
|
// Low ...
|
|
|
|
//
|
|
#define lLowUpperBufferIndex 28
|
|
double lLowUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label29 "XCHDON L L U"
|
|
#property indicator_type29 DRAW_LINE
|
|
#property indicator_color29 clrDarkOrchid
|
|
#property indicator_width29 1
|
|
|
|
//
|
|
#define lLowLowerBufferIndex 29
|
|
double lLowLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label30 "XCHDON L L L"
|
|
#property indicator_type30 DRAW_LINE
|
|
#property indicator_color30 clrDarkOrchid
|
|
#property indicator_width30 1
|
|
|
|
//
|
|
// Close ...
|
|
|
|
//
|
|
#define lCloseUpperBufferIndex 30
|
|
double lCloseUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label31 "XCHDON L C U"
|
|
#property indicator_type31 DRAW_LINE
|
|
#property indicator_color31 clrCoral
|
|
#property indicator_width31 1
|
|
|
|
//
|
|
#define lCloseLowerBufferIndex 31
|
|
double lCloseLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label32 "XCHDON L C L"
|
|
#property indicator_type32 DRAW_LINE
|
|
#property indicator_color32 clrCoral
|
|
#property indicator_width32 1
|
|
|
|
//
|
|
// Hind ...
|
|
|
|
//
|
|
// Open ...
|
|
|
|
//
|
|
#define hOpenUpperBufferIndex 32
|
|
double hOpenUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label33 "XCHDON H O U"
|
|
#property indicator_type33 DRAW_LINE
|
|
#property indicator_color33 clrCornflowerBlue
|
|
#property indicator_width33 1
|
|
|
|
//
|
|
#define hOpenLowerBufferIndex 33
|
|
double hOpenLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label34 "XCHDON H O L"
|
|
#property indicator_type34 DRAW_LINE
|
|
#property indicator_color34 clrCornflowerBlue
|
|
#property indicator_width34 1
|
|
|
|
//
|
|
// High ...
|
|
|
|
//
|
|
#define hHighUpperBufferIndex 34
|
|
double hHighUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label35 "XCHDON H H U"
|
|
#property indicator_type35 DRAW_LINE
|
|
#property indicator_color35 clrAquamarine
|
|
#property indicator_width35 1
|
|
|
|
//
|
|
#define hHighLowerBufferIndex 35
|
|
double hHighLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label36 "XCHDON H H L"
|
|
#property indicator_type36 DRAW_LINE
|
|
#property indicator_color36 clrAquamarine
|
|
#property indicator_width36 1
|
|
|
|
//
|
|
// Low ...
|
|
|
|
//
|
|
#define hLowUpperBufferIndex 36
|
|
double hLowUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label37 "XCHDON H L U"
|
|
#property indicator_type37 DRAW_LINE
|
|
#property indicator_color37 clrDarkOrchid
|
|
#property indicator_width37 1
|
|
|
|
//
|
|
#define hLowLowerBufferIndex 37
|
|
double hLowLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label38 "XCHDON H L L"
|
|
#property indicator_type38 DRAW_LINE
|
|
#property indicator_color38 clrDarkOrchid
|
|
#property indicator_width38 1
|
|
|
|
//
|
|
// Close ...
|
|
|
|
//
|
|
#define hCloseUpperBufferIndex 38
|
|
double hCloseUpperBuffer[];
|
|
|
|
//
|
|
#property indicator_label39 "XCHDON H C U"
|
|
#property indicator_type39 DRAW_LINE
|
|
#property indicator_color39 clrCoral
|
|
#property indicator_width39 1
|
|
|
|
//
|
|
#define hCloseLowerBufferIndex 39
|
|
double hCloseLowerBuffer[];
|
|
|
|
//
|
|
#property indicator_label40 "XCHDON H C L"
|
|
#property indicator_type40 DRAW_LINE
|
|
#property indicator_color40 clrCoral
|
|
#property indicator_width40 1
|
|
|
|
//
|
|
// Variables, Properties and etc ...
|
|
|
|
//
|
|
int maxLength;
|
|
|
|
//
|
|
// Current ...
|
|
int mCMarketLength = length;
|
|
|
|
//
|
|
// Short ...
|
|
int mSCycleLength = 0;
|
|
int mSMarketLength = 0;
|
|
ENUM_TIMEFRAMES mSCPeriod = NULL;
|
|
|
|
//
|
|
// Medium ...
|
|
int mMCycleLength = 0;
|
|
int mMMarketLength = 0;
|
|
ENUM_TIMEFRAMES mMCPeriod = NULL;
|
|
|
|
//
|
|
// Long ...
|
|
int mLCycleLength = 0;
|
|
int mLMarketLength = 0;
|
|
ENUM_TIMEFRAMES mLCPeriod = NULL;
|
|
|
|
//
|
|
// Hind ...
|
|
int mHCycleLength = 0;
|
|
int mHMarketLength = 0;
|
|
ENUM_TIMEFRAMES mHCPeriod = NULL;
|
|
|
|
//
|
|
// Event Handlers ...
|
|
|
|
//
|
|
// Initialization ...
|
|
int OnInit()
|
|
{
|
|
//
|
|
// Validate Inputs ...
|
|
if (!ValidateInputs())
|
|
{
|
|
return INIT_PARAMETERS_INCORRECT;
|
|
}
|
|
|
|
//
|
|
if (!InitMarketCycles())
|
|
{
|
|
return INIT_PARAMETERS_INCORRECT;
|
|
}
|
|
|
|
//
|
|
// 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();
|
|
|
|
//
|
|
// Init Succeed ...
|
|
return INIT_SUCCEEDED;
|
|
}
|
|
|
|
//
|
|
// DeInitialization ...
|
|
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
|
|
}
|
|
|
|
//
|
|
// Calculating what we want ...
|
|
int OnCalculate(
|
|
const int rates_total, // Total Bars on Chart ...
|
|
const int prev_calculated, // Total Calculated Bars on Charts ...
|
|
const datetime &time[], // History of Open Time ...
|
|
const double &open[], // History of Open Price ...
|
|
const double &high[], // History of High Price ...
|
|
const double &low[], // History of Low Price ...
|
|
const double &close[], // History of Close Price ...
|
|
const long &tick_volume[], // History of Tick Volumes on Bar ...
|
|
const long &volume[], // History of Trade Volumes ...
|
|
const int &spread[] // History of Spread Price ...
|
|
)
|
|
{
|
|
//
|
|
if (rates_total < maxLength - 1)
|
|
{
|
|
return prev_calculated;
|
|
}
|
|
|
|
//
|
|
int start = prev_calculated == 0
|
|
? maxLength
|
|
: prev_calculated - 1;
|
|
|
|
//
|
|
// Main Loop ...
|
|
for (int i = start; i < rates_total; i++)
|
|
{
|
|
//
|
|
CalculateBuffers(
|
|
//
|
|
i,
|
|
prev_calculated,
|
|
rates_total,
|
|
//
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tick_volume
|
|
//
|
|
);
|
|
}
|
|
|
|
//
|
|
return rates_total;
|
|
}
|
|
|
|
//
|
|
// Functions ...
|
|
|
|
//
|
|
// Validate Input Args for Initialization ...
|
|
bool ValidateInputs()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
length > 2
|
|
//
|
|
&&
|
|
//
|
|
(IsValid(scMethod, scPeriod) &&
|
|
IsValid(mcMethod, mcPeriod) &&
|
|
IsValid(lcMethod, lcPeriod) &&
|
|
IsValid(hcMethod, hcPeriod))
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Initialize Market Cycles ...
|
|
bool InitMarketCycles()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Current Cycle Initialization ...
|
|
|
|
//
|
|
int cPeriodSeconds = PeriodSeconds(_Period);
|
|
|
|
//
|
|
// Short Cycle Initialization ...
|
|
|
|
//
|
|
// Find Cycle Period ...
|
|
if (scMethod == X_PERIOD_AUTO)
|
|
{
|
|
//
|
|
// Select Period ...
|
|
mSCPeriod = GetCyclePeriod(
|
|
X_MARKET_CYCLE_SHORT,
|
|
_Period //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mSCPeriod = scPeriod;
|
|
}
|
|
|
|
//
|
|
result = IsValid(mSCPeriod);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mSCycleLength = PeriodSeconds(mSCPeriod) / cPeriodSeconds;
|
|
mSMarketLength = mSCycleLength * mCMarketLength;
|
|
result = mSCycleLength > 0;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Medium Cycle Initialization ...
|
|
|
|
//
|
|
// Find Cycle Period ...
|
|
if (mcMethod == X_PERIOD_AUTO)
|
|
{
|
|
//
|
|
// Select Period ...
|
|
mMCPeriod = GetCyclePeriod(
|
|
X_MARKET_CYCLE_MEDIUM,
|
|
_Period //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mMCPeriod = mcPeriod;
|
|
}
|
|
|
|
//
|
|
result = IsValid(mMCPeriod);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mMCycleLength = PeriodSeconds(mMCPeriod) / cPeriodSeconds;
|
|
mMMarketLength = mMCycleLength * mCMarketLength;
|
|
result = mMCycleLength > 0;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Long Cycle Initialization ...
|
|
|
|
//
|
|
// Find Cycle Period ...
|
|
if (lcMethod == X_PERIOD_AUTO)
|
|
{
|
|
//
|
|
// Select Period ...
|
|
mLCPeriod = GetCyclePeriod(
|
|
X_MARKET_CYCLE_LONG,
|
|
_Period //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mLCPeriod = lcPeriod;
|
|
}
|
|
|
|
//
|
|
result = IsValid(mLCPeriod);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mLCycleLength = PeriodSeconds(mLCPeriod) / cPeriodSeconds;
|
|
mLMarketLength = mLCycleLength * mCMarketLength;
|
|
result = mLCycleLength > 0;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Hind Cycle Initialization ...
|
|
|
|
//
|
|
// Find Cycle Period ...
|
|
if (hcMethod == X_PERIOD_AUTO)
|
|
{
|
|
//
|
|
// Select Period ...
|
|
mHCPeriod = GetCyclePeriod(
|
|
X_MARKET_CYCLE_HIND,
|
|
_Period //
|
|
);
|
|
}
|
|
else
|
|
{
|
|
mHCPeriod = hcPeriod;
|
|
}
|
|
|
|
//
|
|
result = IsValid(mHCPeriod);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mHCycleLength = PeriodSeconds(mHCPeriod) / cPeriodSeconds;
|
|
mHMarketLength = mHCycleLength * mCMarketLength;
|
|
result = mHCycleLength > 0;
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve all Exists Input Max Length ...
|
|
// use for Start Of Drawing ...
|
|
int ExtractMaxLengthOfInputs()
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
// Current ...
|
|
result = MathMax(mCMarketLength, mSMarketLength);
|
|
result = MathMax(result, mMMarketLength);
|
|
result = MathMax(result, mLMarketLength);
|
|
result = MathMax(result, mHMarketLength);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Set Indicator Short Name and also we can define Buffers Labels ...
|
|
void SetIndicatorName()
|
|
{
|
|
//
|
|
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
|
|
IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
|
|
}
|
|
|
|
//
|
|
// Define Indexes and Styles ...
|
|
void DefineBuffers()
|
|
{
|
|
//
|
|
// CURRENT ...
|
|
|
|
//
|
|
// Open ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowCOpenUpper = showUpper && showOpen && showCurrent;
|
|
ENUM_DRAW_TYPE cOpenUpperDrawType = canShowCOpenUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(cOpenUpperBufferIndex, cOpenUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(cOpenUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(cOpenUpperBufferIndex, PLOT_SHOW_DATA, canShowCOpenUpper);
|
|
PlotIndexSetInteger(cOpenUpperBufferIndex, PLOT_DRAW_TYPE, cOpenUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowCOpenLower = showLower && showOpen && showCurrent;
|
|
ENUM_DRAW_TYPE cOpenLowerDrawType = canShowCOpenLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(cOpenLowerBufferIndex, cOpenLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(cOpenLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(cOpenLowerBufferIndex, PLOT_SHOW_DATA, canShowCOpenLower);
|
|
PlotIndexSetInteger(cOpenLowerBufferIndex, PLOT_DRAW_TYPE, cOpenLowerDrawType);
|
|
|
|
//
|
|
// Close ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowCCloseUpper = showUpper && showClose && showCurrent;
|
|
ENUM_DRAW_TYPE cCloseUpperDrawType = canShowCCloseUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(cCloseUpperBufferIndex, cCloseUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(cCloseUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(cCloseUpperBufferIndex, PLOT_SHOW_DATA, canShowCCloseUpper);
|
|
PlotIndexSetInteger(cCloseUpperBufferIndex, PLOT_DRAW_TYPE, cCloseUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowCCloseLower = showLower && showClose && showCurrent;
|
|
ENUM_DRAW_TYPE cCloseLowerDrawType = canShowCCloseLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(cCloseLowerBufferIndex, cCloseLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(cCloseLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(cCloseLowerBufferIndex, PLOT_SHOW_DATA, canShowCCloseLower);
|
|
PlotIndexSetInteger(cCloseLowerBufferIndex, PLOT_DRAW_TYPE, cCloseLowerDrawType);
|
|
|
|
//
|
|
// High ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowCHighUpper = showUpper && showHigh && showCurrent;
|
|
ENUM_DRAW_TYPE cHighUpperDrawType = canShowCHighUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(cHighUpperBufferIndex, cHighUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(cHighUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(cHighUpperBufferIndex, PLOT_SHOW_DATA, canShowCHighUpper);
|
|
PlotIndexSetInteger(cHighUpperBufferIndex, PLOT_DRAW_TYPE, cHighUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowCHighLower = showLower && showHigh && showCurrent;
|
|
ENUM_DRAW_TYPE cHighLowerDrawType = canShowCHighLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(cHighLowerBufferIndex, cHighLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(cHighLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(cHighLowerBufferIndex, PLOT_SHOW_DATA, canShowCHighLower);
|
|
PlotIndexSetInteger(cHighLowerBufferIndex, PLOT_DRAW_TYPE, cHighLowerDrawType);
|
|
|
|
//
|
|
// Low ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowCLowUpper = showUpper && showLow && showCurrent;
|
|
ENUM_DRAW_TYPE cLowUpperDrawType = canShowCLowUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(cLowUpperBufferIndex, cLowUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(cLowUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(cLowUpperBufferIndex, PLOT_SHOW_DATA, canShowCLowUpper);
|
|
PlotIndexSetInteger(cLowUpperBufferIndex, PLOT_DRAW_TYPE, cLowUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowCLowLower = showLower && showLow && showCurrent;
|
|
ENUM_DRAW_TYPE cLowLowerDrawType = canShowCLowLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(cLowLowerBufferIndex, cLowLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(cLowLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(cLowLowerBufferIndex, PLOT_SHOW_DATA, canShowCLowLower);
|
|
PlotIndexSetInteger(cLowLowerBufferIndex, PLOT_DRAW_TYPE, cLowLowerDrawType);
|
|
|
|
//
|
|
// SHORT ...
|
|
|
|
//
|
|
// Open ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowSOpenUpper = showUpper && showOpen && showShort;
|
|
ENUM_DRAW_TYPE sOpenUpperDrawType = canShowSOpenUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(sOpenUpperBufferIndex, sOpenUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(sOpenUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(sOpenUpperBufferIndex, PLOT_SHOW_DATA, canShowSOpenUpper);
|
|
PlotIndexSetInteger(sOpenUpperBufferIndex, PLOT_DRAW_TYPE, sOpenUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowSOpenLower = showLower && showOpen && showShort;
|
|
ENUM_DRAW_TYPE sOpenLowerDrawType = canShowSOpenLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(sOpenLowerBufferIndex, sOpenLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(sOpenLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(sOpenLowerBufferIndex, PLOT_SHOW_DATA, canShowSOpenLower);
|
|
PlotIndexSetInteger(sOpenLowerBufferIndex, PLOT_DRAW_TYPE, sOpenLowerDrawType);
|
|
|
|
//
|
|
// Close ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowSCloseUpper = showUpper && showClose && showShort;
|
|
ENUM_DRAW_TYPE sCloseUpperDrawType = canShowSCloseUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(sCloseUpperBufferIndex, sCloseUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(sCloseUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(sCloseUpperBufferIndex, PLOT_SHOW_DATA, canShowSCloseUpper);
|
|
PlotIndexSetInteger(sCloseUpperBufferIndex, PLOT_DRAW_TYPE, sCloseUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowSCloseLower = showLower && showClose && showShort;
|
|
ENUM_DRAW_TYPE sCloseLowerDrawType = canShowSCloseLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(sCloseLowerBufferIndex, sCloseLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(sCloseLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(sCloseLowerBufferIndex, PLOT_SHOW_DATA, canShowSCloseLower);
|
|
PlotIndexSetInteger(sCloseLowerBufferIndex, PLOT_DRAW_TYPE, sCloseLowerDrawType);
|
|
|
|
//
|
|
// High ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowSHighUpper = showUpper && showHigh && showShort;
|
|
ENUM_DRAW_TYPE sHighUpperDrawType = canShowSHighUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(sHighUpperBufferIndex, sHighUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(sHighUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(sHighUpperBufferIndex, PLOT_SHOW_DATA, canShowSHighUpper);
|
|
PlotIndexSetInteger(sHighUpperBufferIndex, PLOT_DRAW_TYPE, sHighUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowSHighLower = showLower && showHigh && showShort;
|
|
ENUM_DRAW_TYPE sHighLowerDrawType = canShowSHighLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(sHighLowerBufferIndex, sHighLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(sHighLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(sHighLowerBufferIndex, PLOT_SHOW_DATA, canShowSHighLower);
|
|
PlotIndexSetInteger(sHighLowerBufferIndex, PLOT_DRAW_TYPE, sHighLowerDrawType);
|
|
|
|
//
|
|
// Low ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowSLowUpper = showUpper && showLow && showShort;
|
|
ENUM_DRAW_TYPE sLowUpperDrawType = canShowSLowUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(sLowUpperBufferIndex, sLowUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(sLowUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(sLowUpperBufferIndex, PLOT_SHOW_DATA, canShowSLowUpper);
|
|
PlotIndexSetInteger(sLowUpperBufferIndex, PLOT_DRAW_TYPE, sLowUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowSLowLower = showLower && showLow && showShort;
|
|
ENUM_DRAW_TYPE sLowLowerDrawType = canShowSLowLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(sLowLowerBufferIndex, sLowLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(sLowLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(sLowLowerBufferIndex, PLOT_SHOW_DATA, canShowSLowLower);
|
|
PlotIndexSetInteger(sLowLowerBufferIndex, PLOT_DRAW_TYPE, sLowLowerDrawType);
|
|
|
|
//
|
|
// MEDIUM ...
|
|
|
|
//
|
|
// Open ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowMOpenUpper = showUpper && showOpen && showMedium;
|
|
ENUM_DRAW_TYPE mOpenUpperDrawType = canShowMOpenUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(mOpenUpperBufferIndex, mOpenUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(mOpenUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(mOpenUpperBufferIndex, PLOT_SHOW_DATA, canShowMOpenUpper);
|
|
PlotIndexSetInteger(mOpenUpperBufferIndex, PLOT_DRAW_TYPE, mOpenUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowMOpenLower = showLower && showOpen && showMedium;
|
|
ENUM_DRAW_TYPE mOpenLowerDrawType = canShowMOpenLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(mOpenLowerBufferIndex, mOpenLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(mOpenLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(mOpenLowerBufferIndex, PLOT_SHOW_DATA, canShowMOpenLower);
|
|
PlotIndexSetInteger(mOpenLowerBufferIndex, PLOT_DRAW_TYPE, mOpenLowerDrawType);
|
|
|
|
//
|
|
// Close ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowMCloseUpper = showUpper && showClose && showMedium;
|
|
ENUM_DRAW_TYPE mCloseUpperDrawType = canShowMCloseUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(mCloseUpperBufferIndex, mCloseUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(mCloseUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(mCloseUpperBufferIndex, PLOT_SHOW_DATA, canShowMCloseUpper);
|
|
PlotIndexSetInteger(mCloseUpperBufferIndex, PLOT_DRAW_TYPE, mCloseUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowMCloseLower = showLower && showClose && showMedium;
|
|
ENUM_DRAW_TYPE mCloseLowerDrawType = canShowMCloseLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(mCloseLowerBufferIndex, mCloseLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(mCloseLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(mCloseLowerBufferIndex, PLOT_SHOW_DATA, canShowMCloseLower);
|
|
PlotIndexSetInteger(mCloseLowerBufferIndex, PLOT_DRAW_TYPE, mCloseLowerDrawType);
|
|
|
|
//
|
|
// High ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowMHighUpper = showUpper && showHigh && showMedium;
|
|
ENUM_DRAW_TYPE mHighUpperDrawType = canShowMHighUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(mHighUpperBufferIndex, mHighUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(mHighUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(mHighUpperBufferIndex, PLOT_SHOW_DATA, canShowMHighUpper);
|
|
PlotIndexSetInteger(mHighUpperBufferIndex, PLOT_DRAW_TYPE, mHighUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowMHighLower = showLower && showHigh && showMedium;
|
|
ENUM_DRAW_TYPE mHighLowerDrawType = canShowMHighLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(mHighLowerBufferIndex, mHighLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(mHighLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(mHighLowerBufferIndex, PLOT_SHOW_DATA, canShowMHighLower);
|
|
PlotIndexSetInteger(mHighLowerBufferIndex, PLOT_DRAW_TYPE, mHighLowerDrawType);
|
|
|
|
//
|
|
// Low ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowMLowUpper = showUpper && showLow && showMedium;
|
|
ENUM_DRAW_TYPE mLowUpperDrawType = canShowMLowUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(mLowUpperBufferIndex, mLowUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(mLowUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(mLowUpperBufferIndex, PLOT_SHOW_DATA, canShowMLowUpper);
|
|
PlotIndexSetInteger(mLowUpperBufferIndex, PLOT_DRAW_TYPE, mLowUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowMLowLower = showLower && showLow && showMedium;
|
|
ENUM_DRAW_TYPE mLowLowerDrawType = canShowMLowLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(mLowLowerBufferIndex, mLowLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(mLowLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(mLowLowerBufferIndex, PLOT_SHOW_DATA, canShowMLowLower);
|
|
PlotIndexSetInteger(mLowLowerBufferIndex, PLOT_DRAW_TYPE, mLowLowerDrawType);
|
|
|
|
//
|
|
// LONG ...
|
|
|
|
//
|
|
// Open ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowLOpenUpper = showUpper && showOpen && showLong;
|
|
ENUM_DRAW_TYPE lOpenUpperDrawType = canShowLOpenUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(lOpenUpperBufferIndex, lOpenUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(lOpenUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(lOpenUpperBufferIndex, PLOT_SHOW_DATA, canShowLOpenUpper);
|
|
PlotIndexSetInteger(lOpenUpperBufferIndex, PLOT_DRAW_TYPE, lOpenUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowLOpenLower = showLower && showOpen && showLong;
|
|
ENUM_DRAW_TYPE lOpenLowerDrawType = canShowLOpenLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(lOpenLowerBufferIndex, lOpenLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(lOpenLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(lOpenLowerBufferIndex, PLOT_SHOW_DATA, canShowLOpenLower);
|
|
PlotIndexSetInteger(lOpenLowerBufferIndex, PLOT_DRAW_TYPE, lOpenLowerDrawType);
|
|
|
|
//
|
|
// Close ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowLCloseUpper = showUpper && showClose && showLong;
|
|
ENUM_DRAW_TYPE lCloseUpperDrawType = canShowLCloseUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(lCloseUpperBufferIndex, lCloseUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(lCloseUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(lCloseUpperBufferIndex, PLOT_SHOW_DATA, canShowLCloseUpper);
|
|
PlotIndexSetInteger(lCloseUpperBufferIndex, PLOT_DRAW_TYPE, lCloseUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowLCloseLower = showLower && showClose && showLong;
|
|
ENUM_DRAW_TYPE lCloseLowerDrawType = canShowLCloseLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(lCloseLowerBufferIndex, lCloseLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(lCloseLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(lCloseLowerBufferIndex, PLOT_SHOW_DATA, canShowLCloseLower);
|
|
PlotIndexSetInteger(lCloseLowerBufferIndex, PLOT_DRAW_TYPE, lCloseLowerDrawType);
|
|
|
|
//
|
|
// High ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowLHighUpper = showUpper && showHigh && showLong;
|
|
ENUM_DRAW_TYPE lHighUpperDrawType = canShowLHighUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(lHighUpperBufferIndex, lHighUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(lHighUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(lHighUpperBufferIndex, PLOT_SHOW_DATA, canShowLHighUpper);
|
|
PlotIndexSetInteger(lHighUpperBufferIndex, PLOT_DRAW_TYPE, lHighUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowLHighLower = showLower && showHigh && showLong;
|
|
ENUM_DRAW_TYPE lHighLowerDrawType = canShowLHighLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(lHighLowerBufferIndex, lHighLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(lHighLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(lHighLowerBufferIndex, PLOT_SHOW_DATA, canShowLHighLower);
|
|
PlotIndexSetInteger(lHighLowerBufferIndex, PLOT_DRAW_TYPE, lHighLowerDrawType);
|
|
|
|
//
|
|
// Low ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowLLowUpper = showUpper && showLow && showLong;
|
|
ENUM_DRAW_TYPE lLowUpperDrawType = canShowLLowUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(lLowUpperBufferIndex, lLowUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(lLowUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(lLowUpperBufferIndex, PLOT_SHOW_DATA, canShowLLowUpper);
|
|
PlotIndexSetInteger(lLowUpperBufferIndex, PLOT_DRAW_TYPE, lLowUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowLLowLower = showLower && showLow && showLong;
|
|
ENUM_DRAW_TYPE lLowLowerDrawType = canShowLLowLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(lLowLowerBufferIndex, lLowLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(lLowLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(lLowLowerBufferIndex, PLOT_SHOW_DATA, canShowLLowLower);
|
|
PlotIndexSetInteger(lLowLowerBufferIndex, PLOT_DRAW_TYPE, lLowLowerDrawType);
|
|
|
|
//
|
|
// HIND ...
|
|
|
|
//
|
|
// Open ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowHOpenUpper = showUpper && showOpen && showHind;
|
|
ENUM_DRAW_TYPE hOpenUpperDrawType = canShowHOpenUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(hOpenUpperBufferIndex, hOpenUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(hOpenUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(hOpenUpperBufferIndex, PLOT_SHOW_DATA, canShowHOpenUpper);
|
|
PlotIndexSetInteger(hOpenUpperBufferIndex, PLOT_DRAW_TYPE, hOpenUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowHOpenLower = showLower && showOpen && showHind;
|
|
ENUM_DRAW_TYPE hOpenLowerDrawType = canShowHOpenLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(hOpenLowerBufferIndex, hOpenLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(hOpenLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(hOpenLowerBufferIndex, PLOT_SHOW_DATA, canShowHOpenLower);
|
|
PlotIndexSetInteger(hOpenLowerBufferIndex, PLOT_DRAW_TYPE, hOpenLowerDrawType);
|
|
|
|
//
|
|
// Close ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowHCloseUpper = showUpper && showClose && showHind;
|
|
ENUM_DRAW_TYPE hCloseUpperDrawType = canShowHCloseUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(hCloseUpperBufferIndex, hCloseUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(hCloseUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(hCloseUpperBufferIndex, PLOT_SHOW_DATA, canShowHCloseUpper);
|
|
PlotIndexSetInteger(hCloseUpperBufferIndex, PLOT_DRAW_TYPE, hCloseUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowHCloseLower = showLower && showClose && showHind;
|
|
ENUM_DRAW_TYPE hCloseLowerDrawType = canShowHCloseLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(hCloseLowerBufferIndex, hCloseLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(hCloseLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(hCloseLowerBufferIndex, PLOT_SHOW_DATA, canShowHCloseLower);
|
|
PlotIndexSetInteger(hCloseLowerBufferIndex, PLOT_DRAW_TYPE, hCloseLowerDrawType);
|
|
|
|
//
|
|
// High ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowHHighUpper = showUpper && showHigh && showHind;
|
|
ENUM_DRAW_TYPE hHighUpperDrawType = canShowHHighUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(hHighUpperBufferIndex, hHighUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(hHighUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(hHighUpperBufferIndex, PLOT_SHOW_DATA, canShowHHighUpper);
|
|
PlotIndexSetInteger(hHighUpperBufferIndex, PLOT_DRAW_TYPE, hHighUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowHHighLower = showLower && showHigh && showHind;
|
|
ENUM_DRAW_TYPE hHighLowerDrawType = canShowHHighLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(hHighLowerBufferIndex, hHighLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(hHighLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(hHighLowerBufferIndex, PLOT_SHOW_DATA, canShowHHighLower);
|
|
PlotIndexSetInteger(hHighLowerBufferIndex, PLOT_DRAW_TYPE, hHighLowerDrawType);
|
|
|
|
//
|
|
// Low ...
|
|
|
|
//
|
|
// UPPER ...
|
|
bool canShowHLowUpper = showUpper && showLow && showHind;
|
|
ENUM_DRAW_TYPE hLowUpperDrawType = canShowHLowUpper ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(hLowUpperBufferIndex, hLowUpperBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(hLowUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(hLowUpperBufferIndex, PLOT_SHOW_DATA, canShowHLowUpper);
|
|
PlotIndexSetInteger(hLowUpperBufferIndex, PLOT_DRAW_TYPE, hLowUpperDrawType);
|
|
|
|
//
|
|
// LOWER ...
|
|
bool canShowHLowLower = showLower && showLow && showHind;
|
|
ENUM_DRAW_TYPE hLowLowerDrawType = canShowHLowLower ? DRAW_LINE : DRAW_NONE;
|
|
SetIndexBuffer(hLowLowerBufferIndex, hLowLowerBuffer, INDICATOR_DATA);
|
|
PlotIndexSetDouble(hLowLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
|
|
PlotIndexSetInteger(hLowLowerBufferIndex, PLOT_SHOW_DATA, canShowHLowLower);
|
|
PlotIndexSetInteger(hLowLowerBufferIndex, PLOT_DRAW_TYPE, hLowLowerDrawType);
|
|
}
|
|
|
|
//
|
|
// Calculations ...
|
|
|
|
//
|
|
// Calculate Buffers ...
|
|
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[] //
|
|
)
|
|
{
|
|
//
|
|
CalculateCycles(
|
|
bar_index,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume //
|
|
);
|
|
}
|
|
|
|
//
|
|
void CalculateCycles(
|
|
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[] //
|
|
)
|
|
{
|
|
//
|
|
// CURRENT ...
|
|
CalculateCycle(
|
|
//
|
|
bar_index,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
//
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume,
|
|
//
|
|
mCMarketLength,
|
|
//
|
|
cOpenUpperBuffer,
|
|
cOpenLowerBuffer,
|
|
cHighUpperBuffer,
|
|
cHighLowerBuffer,
|
|
cLowUpperBuffer,
|
|
cLowLowerBuffer,
|
|
cCloseUpperBuffer,
|
|
cCloseLowerBuffer //
|
|
);
|
|
|
|
//
|
|
// SHORT ...
|
|
CalculateCycle(
|
|
//
|
|
bar_index,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
//
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume,
|
|
//
|
|
mSMarketLength,
|
|
//
|
|
sOpenUpperBuffer,
|
|
sOpenLowerBuffer,
|
|
sHighUpperBuffer,
|
|
sHighLowerBuffer,
|
|
sLowUpperBuffer,
|
|
sLowLowerBuffer,
|
|
sCloseUpperBuffer,
|
|
sCloseLowerBuffer //
|
|
);
|
|
|
|
//
|
|
// MEDIUM ...
|
|
CalculateCycle(
|
|
//
|
|
bar_index,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
//
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume,
|
|
//
|
|
mMMarketLength,
|
|
//
|
|
mOpenUpperBuffer,
|
|
mOpenLowerBuffer,
|
|
mHighUpperBuffer,
|
|
mHighLowerBuffer,
|
|
mLowUpperBuffer,
|
|
mLowLowerBuffer,
|
|
mCloseUpperBuffer,
|
|
mCloseLowerBuffer //
|
|
);
|
|
|
|
//
|
|
// LONG ...
|
|
CalculateCycle(
|
|
//
|
|
bar_index,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
//
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume,
|
|
//
|
|
mLMarketLength,
|
|
//
|
|
lOpenUpperBuffer,
|
|
lOpenLowerBuffer,
|
|
lHighUpperBuffer,
|
|
lHighLowerBuffer,
|
|
lLowUpperBuffer,
|
|
lLowLowerBuffer,
|
|
lCloseUpperBuffer,
|
|
lCloseLowerBuffer //
|
|
);
|
|
|
|
//
|
|
// HIND ...
|
|
CalculateCycle(
|
|
//
|
|
bar_index,
|
|
prevCalculated,
|
|
ratesTotal,
|
|
//
|
|
open,
|
|
high,
|
|
close,
|
|
low,
|
|
tickVolume,
|
|
//
|
|
mHMarketLength,
|
|
//
|
|
hOpenUpperBuffer,
|
|
hOpenLowerBuffer,
|
|
hHighUpperBuffer,
|
|
hHighLowerBuffer,
|
|
hLowUpperBuffer,
|
|
hLowLowerBuffer,
|
|
hCloseUpperBuffer,
|
|
hCloseLowerBuffer //
|
|
);
|
|
}
|
|
|
|
//
|
|
void CalculateCycle(
|
|
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 _length,
|
|
//
|
|
double &_ouBuffer[],
|
|
double &_olBuffer[],
|
|
double &_huBuffer[],
|
|
double &_hlBuffer[],
|
|
double &_luBuffer[],
|
|
double &_llBuffer[],
|
|
double &_cuBuffer[],
|
|
double &_clBuffer[] //
|
|
)
|
|
{
|
|
//
|
|
double iUpper = 0;
|
|
double iLower = 0;
|
|
|
|
//
|
|
// OPEN ...
|
|
|
|
//
|
|
iUpper = open[ArrayMaximum(open, bar_index - _length + 1, _length)];
|
|
iLower = open[ArrayMinimum(open, bar_index - _length + 1, _length)];
|
|
|
|
//
|
|
_ouBuffer[bar_index] = iUpper;
|
|
_olBuffer[bar_index] = iLower;
|
|
|
|
//
|
|
// HIGH ...
|
|
|
|
//
|
|
iUpper = high[ArrayMaximum(high, bar_index - _length + 1, _length)];
|
|
iLower = high[ArrayMinimum(high, bar_index - _length + 1, _length)];
|
|
|
|
//
|
|
_huBuffer[bar_index] = iUpper;
|
|
_hlBuffer[bar_index] = iLower;
|
|
|
|
//
|
|
// LOW ...
|
|
|
|
//
|
|
iUpper = low[ArrayMaximum(low, bar_index - _length + 1, _length)];
|
|
iLower = low[ArrayMinimum(low, bar_index - _length + 1, _length)];
|
|
|
|
//
|
|
_luBuffer[bar_index] = iUpper;
|
|
_llBuffer[bar_index] = iLower;
|
|
|
|
//
|
|
// CLOSE ...
|
|
|
|
//
|
|
iUpper = close[ArrayMaximum(close, bar_index - _length + 1, _length)];
|
|
iLower = close[ArrayMinimum(close, bar_index - _length + 1, _length)];
|
|
|
|
//
|
|
_cuBuffer[bar_index] = iUpper;
|
|
_clBuffer[bar_index] = iLower;
|
|
}
|
|
|
|
// |