cleanup and refocused workspace for using on XCATBEA Projects ...

This commit is contained in:
2025-05-28 15:20:54 +03:30
parent 4c6be67a2d
commit 72e8b34da5
32 changed files with 18021 additions and 6061 deletions
-788
View File
@@ -1,788 +0,0 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// -------------------------------------------------
// Name: X121 X3MA
// Description: X3MA ...
//
//
// 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 X3MA Indicator"
#property strict
//
// Definitions ...
//
#define ShortName "X121 X3MA"
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// Inputs ...
//
// Fast ...
input group "Fast";
input int fastLength = 6; // Length
input ENUM_MA_METHOD fastMethod = MODE_SMA; // Method
input ENUM_APPLIED_PRICE fastAppliedTo = PRICE_CLOSE; // Applied To
//
// Medium ...
input group "Medium";
input int mediumLength = 21; // Length
input ENUM_MA_METHOD mediumMethod = MODE_SMA; // Method
input ENUM_APPLIED_PRICE mediumAppliedTo = PRICE_CLOSE; // Applied To
//
// Slow ...
input group "Slow";
input int slowLength = 34; // Length
input ENUM_MA_METHOD slowMethod = MODE_SMA; // Method
input ENUM_APPLIED_PRICE slowAppliedTo = PRICE_CLOSE; // Applied To
//
// Presentation ...
input group "Presentation";
//
input int startCalculationForLastBars = 1000; // Calculate Last n Bars
//
input bool applyColor = false;
//
input bool showFast = true; // Show Fast
input bool showMedium = true; // Show Medium
input bool showSlow = true; // Show Slow
//
// Buffers ...
//
#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
//
#property indicator_chart_window
//
#property indicator_buffers 9
#property indicator_plots 3
//
// Plot Buffers ...
//
// FAST ...
//
#define fastBufferIndex 0
double fastBuffer[];
//
#define fastColorBufferIndex 1
double fastColorBuffer[];
//
#property indicator_label1 "X121 X3MA Fast"
#property indicator_type1 DRAW_COLOR_LINE
#property indicator_color1 CLR_NONE, clrYellow, clrChocolate, clrGray
#property indicator_style1 STYLE_SOLID
#property indicator_width1 2
//
// MEDIUM ...
//
#define mediumBufferIndex 2
double mediumBuffer[];
//
#define mediumColorBufferIndex 3
double mediumColorBuffer[];
//
#property indicator_label2 "X121 X3MA Medium"
#property indicator_type2 DRAW_COLOR_LINE
#property indicator_color2 CLR_NONE, clrAqua, clrMagenta, clrGray
#property indicator_style2 STYLE_DASHDOTDOT
#property indicator_width2 2
//
// SLOW ...
//
#define slowBufferIndex 4
double slowBuffer[];
//
#define slowColorBufferIndex 5
double slowColorBuffer[];
//
#property indicator_label3 "X121 X3MA Slow"
#property indicator_type3 DRAW_COLOR_LINE
#property indicator_color3 CLR_NONE, clrLime, clrRed, clrGray
#property indicator_style3 STYLE_DASH
#property indicator_width3 2
//
// Data Buffers ...
#define mLastBufferIndex 5
//
#define fastStateBufferIndex mLastBufferIndex + 1
double fastStateBuffer[];
//
#define mediumStateBufferIndex mLastBufferIndex + 2
double mediumStateBuffer[];
//
#define slowStateBufferIndex mLastBufferIndex + 3
double slowStateBuffer[];
//
// Variables, Properties and etc ...
//
// this counts Available Bars ...
int limit;
//
int maxLength;
//
int fastHandler = INVALID_HANDLE;
int mediumHandler = INVALID_HANDLE;
int slowHandler = INVALID_HANDLE;
//
// Event Handlers ...
/**
* Initialize Indicator ...
*
* @return ( int )
*/
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// Initialize Indicator Handlers ...
//
// FAST ...
fastHandler = iMA(
_Symbol,
_Period,
fastLength,
0,
fastMethod,
fastAppliedTo //
);
bool isInited = fastHandler != INVALID_HANDLE;
if (!isInited)
{
return INIT_FAILED;
}
//
// MEDIUM ...
mediumHandler = iMA(
_Symbol,
_Period,
mediumLength,
0,
mediumMethod,
mediumAppliedTo //
);
isInited = mediumHandler != INVALID_HANDLE;
if (!isInited)
{
return INIT_FAILED;
}
//
// SLOW ...
slowHandler = iMA(
_Symbol,
_Period,
slowLength,
0,
slowMethod,
slowAppliedTo //
);
isInited = slowHandler != INVALID_HANDLE;
if (!isInited)
{
return INIT_FAILED;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
/**
* De Initialize Indicator ...
*
* @param reason: Integer, De Initialization Reason ...
*/
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
IndicatorRelease(fastHandler);
IndicatorRelease(mediumHandler);
IndicatorRelease(slowHandler);
}
/**
* 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 ...
//
// FAST ...
int fastCalculatedBars = BarsCalculated(fastHandler);
//
// MEDIUM ...
int mediumCalculatedBars = BarsCalculated(mediumHandler);
//
// SLOW ...
int slowCalculatedBars = BarsCalculated(slowHandler);
//
bool isPassedRequiredCalculatedBars =
//
// FAST ...
fastCalculatedBars >= maxLength &&
//
// MEDIUM ...
mediumCalculatedBars >= maxLength &&
//
// SLOW ...
slowCalculatedBars >= maxLength
//
;
if (!isPassedRequiredCalculatedBars)
{
return prev_calculated;
}
//
limit = (prev_calculated > rates_total || prev_calculated <= 0)
? rates_total
: (rates_total - prev_calculated) + 1;
//
// Buffers Copy ...
//
// FAST ...
int copiedFasts = CopyBuffer(fastHandler, 0, 0, limit, fastBuffer);
//
// MEDIUM ...
int copiedMediumss = CopyBuffer(mediumHandler, 0, 0, limit, mediumBuffer);
//
// SLOW ...
int copiedSlows = CopyBuffer(slowHandler, 0, 0, limit, slowBuffer);
//
// Validate Copied Items ...
bool isPassedRequiredCopiedItems =
//
// FAST ...
copiedFasts >= limit &&
//
// MEDIUM ...
copiedMediumss >= limit &&
//
// SLOW ...
copiedSlows >= 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 //
);
}
//
return rates_total;
}
//
// Functions ...
/**
* Validate Input Args for Initialization ...
*
* @return ( bool )
*/
bool ValidateInputs()
{
//
bool result = false;
//
result =
//
fastLength > 2 &&
mediumLength > 2 &&
slowLength > 2 &&
mediumLength > fastLength &&
mediumLength < slowLength
//
;
//
return result;
}
/**
* Extract Max Length of Inputs ...
*
* @return ( int )
*/
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
result = MathMax(fastLength, mediumLength);
result = MathMax(result, slowLength);
//
return result;
}
/**
* Define Required Buffers ...
*/
void DefineBuffers()
{
//
// Plot Buffers ...
//
// FAST ...
//
ArraySetAsSeries(fastBuffer, true);
SetIndexBuffer(fastBufferIndex, fastBuffer, INDICATOR_DATA);
//
PlotIndexSetInteger(fastBufferIndex, PLOT_SHOW_DATA, showFast);
//
PlotIndexSetDouble(fastBufferIndex, PLOT_EMPTY_VALUE, emptyValue);
//
ArraySetAsSeries(fastColorBuffer, true);
SetIndexBuffer(fastColorBufferIndex, fastColorBuffer, INDICATOR_COLOR_INDEX);
//
// MEDIUM ...
//
ArraySetAsSeries(mediumBuffer, true);
SetIndexBuffer(mediumBufferIndex, mediumBuffer, INDICATOR_DATA);
//
PlotIndexSetInteger(mediumBufferIndex, PLOT_SHOW_DATA, showMedium);
//
PlotIndexSetDouble(mediumBufferIndex, PLOT_EMPTY_VALUE, emptyValue);
//
ArraySetAsSeries(mediumColorBuffer, true);
SetIndexBuffer(mediumColorBufferIndex, mediumColorBuffer, INDICATOR_COLOR_INDEX);
//
// SLOW ...
//
ArraySetAsSeries(slowBuffer, true);
SetIndexBuffer(slowBufferIndex, slowBuffer, INDICATOR_DATA);
//
PlotIndexSetInteger(slowBufferIndex, PLOT_SHOW_DATA, showSlow);
//
PlotIndexSetDouble(slowBufferIndex, PLOT_EMPTY_VALUE, emptyValue);
//
ArraySetAsSeries(slowColorBuffer, true);
SetIndexBuffer(slowColorBufferIndex, slowColorBuffer, INDICATOR_COLOR_INDEX);
//
// Data Buffers ...
//
// FAST State ...
ArraySetAsSeries(fastStateBuffer, true);
SetIndexBuffer(fastStateBufferIndex, fastStateBuffer, INDICATOR_CALCULATIONS);
//
// MEDIUM State ...
ArraySetAsSeries(mediumStateBuffer, true);
SetIndexBuffer(mediumStateBufferIndex, mediumStateBuffer, INDICATOR_CALCULATIONS);
//
// SLOW State ...
ArraySetAsSeries(slowStateBuffer, true);
SetIndexBuffer(slowStateBufferIndex, slowStateBuffer, INDICATOR_CALCULATIONS);
}
/**
* Set Indicator Short Name and also we can define Buffers Labels ...
*/
void SetIndicatorName()
{
//
IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
/**
* Calculate Custom Buffers ...
*
* @param bar_index: Integer, Represent Current Bar ...
* @param prevCalculated: Integer, Represent Previous Calculated Bars ...
* @param ratesTotal: Integer, Represents All Available Bars ...
* @param open: Double Array, History of Open Prices ...
* @param high: Double Array, History of High Prices ...
* @param close: Double Array, History of Close Prices ...
* @param low: Double Array, History of Low Prices ...
* @param tickVolume: Long, History of Tick Volumes on Bar ...
*/
void CalculateBuffers(
int bar_index, // Selected Bar Index
const int prevCalculated,
const int ratesTotal,
const double &open[],
const double &high[],
const double &close[],
const double &low[],
const long &tickVolume[] //
)
{
//
int barsLimit = startCalculationForLastBars > 0
? startCalculationForLastBars
: 0;
//
// bool canCalculate = true;
bool canCalculate =
barsLimit == 0 ||
bar_index <= barsLimit;
if (canCalculate)
{
//
// Calculate Values ...
CalculateValues(
bar_index,
prevCalculated,
ratesTotal,
open,
high,
close,
low,
tickVolume //
);
}
else
{
FillBuffersZero(bar_index);
}
}
/**
* Fill All Bufers to Zero Vlue for Specified Bar Index ...
*
* @param barIndex: Integer ...
*/
void FillBuffersZero(int barIndex)
{
//
// FAST ...
fastBuffer[barIndex] = emptyValue;
fastColorBuffer[barIndex] = hideColorIDX;
fastStateBuffer[barIndex] = neuturalState;
//
// MEDIUM ...
mediumBuffer[barIndex] = emptyValue;
mediumColorBuffer[barIndex] = hideColorIDX;
mediumStateBuffer[barIndex] = neuturalState;
//
// SLOW ...
slowBuffer[barIndex] = emptyValue;
slowColorBuffer[barIndex] = hideColorIDX;
slowStateBuffer[barIndex] = neuturalState;
}
/**
* Calculate Values ...
*
* @param bar_index: 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 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[] //
)
{
//
// Check Prev Bar ...
//
int lastBarIndex = bar_index + 1;
bool isFirstBar =
startCalculationForLastBars > 0
? bar_index == startCalculationForLastBars
: bar_index == ratesTotal;
//
double iLow = low[bar_index];
double iHigh = high[bar_index];
double iClose = close[bar_index];
//
// FAST ...
//
double iFast = fastBuffer[bar_index];
//
double iFastState =
iLow > iFast
? bullishState
: iHigh < iFast
? bearishState
: neuturalState;
double iFastColor = hideColorIDX;
if (showFast)
{
//
if (applyColor)
{
//
iFastColor =
iFastState == bullishState
? bullishColorIDX
: iFastState == bearishState
? bearishColorIDX
: neuturalColorIDX;
}
else
{
iFastColor = bullishColorIDX;
}
}
fastColorBuffer[bar_index] = iFastColor;
fastStateBuffer[bar_index] = iFastState;
//
// MEDIUM ...
//
double iMedium = mediumBuffer[bar_index];
//
double iMediumState =
iLow > iMedium
? bullishState
: iHigh < iMedium
? bearishState
: neuturalState;
double iMediumColor = hideColorIDX;
if (showMedium)
{
//
if (applyColor)
{
//
iMediumColor =
iMediumState == bullishState
? bullishColorIDX
: iMediumState == bearishState
? bearishColorIDX
: neuturalColorIDX;
}
else
{
iMediumColor = bullishColorIDX;
}
}
mediumColorBuffer[bar_index] = iMediumColor;
mediumStateBuffer[bar_index] = iMediumState;
//
// SLOW ...
//
double iSlow = slowBuffer[bar_index];
//
double iSlowState =
iLow > iSlow
? bullishState
: iHigh < iSlow
? bearishState
: neuturalState;
double iSlowColor = hideColorIDX;
if (showSlow)
{
//
if (applyColor)
{
//
iSlowColor =
iSlowState == bullishState
? bullishColorIDX
: iSlowState == bearishState
? bearishColorIDX
: neuturalColorIDX;
}
else
{
iSlowColor = bullishColorIDX;
}
}
slowColorBuffer[bar_index] = iSlowColor;
slowStateBuffer[bar_index] = iSlowState;
}
//
-882
View File
@@ -1,882 +0,0 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Indicator
// -------------------------------------------------
// Name: X121 XATR
// Description: XATR ...
//
//
// 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 XATR Indicator"
#property strict
//
// Definitions ...
//
#define ShortName "X121 XATR"
//
// Includes Common Library ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// Inputs ...
//
// Market ...
input group "Market";
//
input group "RSI Detection";
input int rsiLength = 14; // Length
input ENUM_X_PRICE rsiPriceType = X_PRICE_CLOSE; // Applied To
input ENUM_X_MA_METHOD rsiSmoothingMethod = X_MA_MODE_SMA; // Smoothing Method;
//
input group "ATR Detection";
input int atrLength = 14; // Length
input double atrMultiplier = 1; // Multiplier
input ENUM_X_PRICE atrUpperPriceType = X_PRICE_HIGH; // Upper Zone Applied To
input ENUM_X_PRICE atrLowerPriceType = X_PRICE_LOW; // Lower Zone Applied To
input ENUM_X_MA_METHOD atrSmoothingMethod = X_MA_MODE_SMA; // Smoothing Method
//
input group "Price Change";
input int priceChangeSmoothingLength = 14; // Length
input ENUM_X_PRICE priceChangeType = X_PRICE_CLOSE; // Price Type
input ENUM_X_MA_METHOD priceChangeSmoothingMethod = X_MA_MODE_SMA; // Moving Average Moethod
//
input group "Presentation";
//
input int startCalculationForLastBars = 1000; // Calculate Last n Bars
//
input bool showAtrUpper = true; // Show Upper Zone
input bool showAtrLower = true; // Show Lower Zone
input bool showSmoothedAtrUpper = true; // Show Smoothed Upper Zone
input bool showSmoothedAtrLower = true; // Show Smoothed Lower Zone
input bool showRSIChange = true; // Show RSI Change
input bool showSmoothedRSIChange = true; // ShowSmoothed RSI Change
input bool showPriceChange = true; // Show Price Change
input bool showSmoothedPriceChange = true; // ShowSmoothed Price Change
//
// Buffers ...
//
#define hideColorIDX 0
#define bullishColorIDX 1
#define bearishColorIDX 2
#define neuturalColorIDX 3
//
#property indicator_chart_window
//
#property indicator_buffers 10
#property indicator_plots 8
//
// ATR ...
//
// Upper ...
//
#define atrUpperBufferIndex 0
double atrUpperBuffer[];
#property indicator_label1 "X121 ATRU"
#property indicator_type1 DRAW_LINE
#property indicator_color1 clrYellow
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//
// Lower ...
//
#define atrLowerBufferIndex 1
double atrLowerBuffer[];
#property indicator_label2 "X121 ATRL"
#property indicator_type2 DRAW_LINE
#property indicator_color2 clrYellow
#property indicator_style2 STYLE_SOLID
#property indicator_width2 1
//
// ATR Smoothed ...
//
// Upper ...
//
#define atrSmoothedUpperBufferIndex 2
double atrSmoothedUpperBuffer[];
#property indicator_label3 "X121 ATRUSM"
#property indicator_type3 DRAW_LINE
#property indicator_color3 clrYellow
#property indicator_style3 STYLE_DASH
#property indicator_width3 1
//
// Lower ...
//
#define atrSmoothedLowerBufferIndex 3
double atrSmoothedLowerBuffer[];
#property indicator_label4 "X121 ATRLSM"
#property indicator_type4 DRAW_LINE
#property indicator_color4 clrYellow
#property indicator_style4 STYLE_DASH
#property indicator_width4 1
//
// Price Change ...
//
#define priceChangeBufferIndex 4
double priceChangeBuffer[];
#property indicator_label5 "X121 PCH"
#property indicator_type5 DRAW_LINE
#property indicator_color5 clrOrchid
#property indicator_style5 STYLE_SOLID
#property indicator_width5 1
//
// Price Change Smoothed ...
//
#define priceChangeSmoothedBufferIndex 5
double priceChangeSmoothedBuffer[];
#property indicator_label6 "X121 PCHSM"
#property indicator_type6 DRAW_LINE
#property indicator_color6 clrOrchid
#property indicator_style6 STYLE_SOLID
#property indicator_width6 1
//
// RSI Change ...
//
#define rsiChangeBufferIndex 6
double rsiChangeBuffer[];
#property indicator_label7 "X121 RSICH"
#property indicator_type7 DRAW_LINE
#property indicator_color7 clrCornflowerBlue
#property indicator_style7 STYLE_SOLID
#property indicator_width7 1
//
// RSI Change Smoothed ...
//
#define rsiChangeSmoothedBufferIndex 7
double rsiChangeSmoothedBuffer[];
#property indicator_label8 "X121 RSICHSM"
#property indicator_type8 DRAW_LINE
#property indicator_color8 clrCornflowerBlue
#property indicator_style8 STYLE_SOLID
#property indicator_width8 1
//
// Data Buffers ...
//
int mLastBufferIndex = 7;
//
// ATR ...
#define atrBufferIndex mLastBufferIndex + 1
double atrBuffer[];
//
// RSI ...
#define rsiBufferIndex mLastBufferIndex + 2
double rsiBuffer[];
//
// Variables, Properties and etc ...
//
// this counts Available Bars ...
int limit;
//
int maxLength;
//
// RSI Handler ...
int rsiHandler = INVALID_HANDLE;
//
// ATR Handler ...
int atrHandler = INVALID_HANDLE;
//
ENUM_APPLIED_PRICE rsiAppliedTo = ToAppliedPrice(rsiPriceType);
//
// Event Handlers ...
/**
* Initialize Indicator ...
*
* @return ( int )
*/
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// Initialize Indicator Handlers ...
//
// RSI ...
rsiHandler = iRSI(
_Symbol,
_Period,
rsiLength,
rsiAppliedTo //
);
bool isInited = rsiHandler != INVALID_HANDLE;
if (!isInited)
{
return INIT_FAILED;
}
//
// ATR ...
atrHandler = iATR(
_Symbol,
_Period,
atrLength //
);
isInited = atrHandler != INVALID_HANDLE;
if (!isInited)
{
return INIT_FAILED;
}
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
//
// Init Succeed ...
return INIT_SUCCEEDED;
}
/**
* De Initialize Indicator ...
*
* @param reason: Integer, De Initialization Reason ...
*/
void OnDeinit(const int reason)
{
//
// REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function
// REASON_REMOVE 1 Program removed from a chart
// REASON_RECOMPILE 2 Program recompiled
// REASON_CHARTCHANGE 3 A symbol or a chart period is changed
// REASON_CHARTCLOSE 4 Chart closed
// REASON_PARAMETERS 5 Inputs changed by a user
// REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings
// REASON_TEMPLATE 7 Another chart template applied
// REASON_INITFAILED 8 The OnInit() handler returned a non-zero value
// REASON_CLOSE 9 Terminal closed
//
IndicatorRelease(rsiHandler);
IndicatorRelease(atrHandler);
}
/**
* 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);
//
// Fill All Buffers by Zero ...
if (prev_calculated == 0)
{
}
//
// Validate Calculated Bars ...
//
// RSI ...
int rsiCalculatedBars = BarsCalculated(rsiHandler);
//
// ATR ...
int atrCalculatedBars = BarsCalculated(atrHandler);
//
bool isPassedRequiredCalculatedBars =
//
// RSI ...
rsiCalculatedBars >= maxLength &&
//
// ATR ...
atrCalculatedBars >= maxLength
//
;
if (!isPassedRequiredCalculatedBars)
{
return prev_calculated;
}
//
limit = (prev_calculated > rates_total || prev_calculated <= 0)
? rates_total
: (rates_total - prev_calculated) + 1;
//
// Buffers Copy ...
//
// RSI ...
int copiedRsis = CopyBuffer(rsiHandler, 0, 0, limit, rsiBuffer);
//
// ATR ...
int copiedAtrs = CopyBuffer(atrHandler, 0, 0, limit, atrBuffer);
//
// Validate Copied Items ...
bool isPassedRequiredCopiedItems =
//
//
// RSI ...
copiedRsis > 0 &&
//
// ATR ...
copiedAtrs > 0
//
;
if (!isPassedRequiredCopiedItems)
{
return prev_calculated;
}
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
//
CalculateBuffers(
i,
prev_calculated,
rates_total,
//
open,
high,
close,
low,
tick_volume //
);
}
//
return rates_total;
}
//
// Functions ...
/**
* Validate Input Args for Initialization ...
*
* @return ( bool )
*/
bool ValidateInputs()
{
//
bool result =
//
// RSI ...
rsiLength > 0 &&
//
// ATR ...
atrLength > 0 &&
atrMultiplier > 0 &&
//
priceChangeSmoothingLength > 0 &&
//
IsValid(rsiPriceType) &&
IsValid(priceChangeType) &&
IsValid(atrUpperPriceType) &&
IsValid(atrLowerPriceType)
//
;
//
return result;
}
/**
* Extract Max Length of Inputs ...
*
* @return ( int )
*/
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
result = MathMax(rsiLength, atrLength);
result = MathMax(result, priceChangeSmoothingLength);
//
return result;
}
/**
* Define Required Buffers ...
*/
void DefineBuffers()
{
//
// ATR ...
//
// UPPER ...
ENUM_DRAW_TYPE atrUpperDrawType = showAtrUpper ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(atrUpperBuffer, true);
SetIndexBuffer(atrUpperBufferIndex, atrUpperBuffer, INDICATOR_DATA);
PlotIndexSetDouble(atrUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(atrUpperBufferIndex, PLOT_SHOW_DATA, showAtrUpper);
PlotIndexSetInteger(atrUpperBufferIndex, PLOT_DRAW_TYPE, atrUpperDrawType);
//
// LOWER ...
ENUM_DRAW_TYPE atrLowerDrawType = showAtrLower ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(atrLowerBuffer, true);
SetIndexBuffer(atrLowerBufferIndex, atrLowerBuffer, INDICATOR_DATA);
PlotIndexSetDouble(atrLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(atrLowerBufferIndex, PLOT_SHOW_DATA, showAtrLower);
PlotIndexSetInteger(atrLowerBufferIndex, PLOT_DRAW_TYPE, atrLowerDrawType);
//
// ATR Smoothed ...
//
// UPPER ...
ENUM_DRAW_TYPE atrSmoothedUpperDrawType = showSmoothedAtrUpper ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(atrSmoothedUpperBuffer, true);
SetIndexBuffer(atrSmoothedUpperBufferIndex, atrSmoothedUpperBuffer, INDICATOR_DATA);
PlotIndexSetDouble(atrSmoothedUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(atrSmoothedUpperBufferIndex, PLOT_SHOW_DATA, showSmoothedAtrUpper);
PlotIndexSetInteger(atrSmoothedUpperBufferIndex, PLOT_DRAW_TYPE, atrSmoothedUpperDrawType);
//
// LOWER ...
ENUM_DRAW_TYPE atrSmoothedLowerDrawType = showSmoothedAtrLower ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(atrSmoothedLowerBuffer, true);
SetIndexBuffer(atrSmoothedLowerBufferIndex, atrSmoothedLowerBuffer, INDICATOR_DATA);
PlotIndexSetDouble(atrSmoothedLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(atrSmoothedLowerBufferIndex, PLOT_SHOW_DATA, showSmoothedAtrLower);
PlotIndexSetInteger(atrSmoothedLowerBufferIndex, PLOT_DRAW_TYPE, atrSmoothedLowerDrawType);
//
// PriceChange ...
ENUM_DRAW_TYPE priceChangeDrawType = showPriceChange ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(priceChangeBuffer, true);
SetIndexBuffer(priceChangeBufferIndex, priceChangeBuffer, INDICATOR_DATA);
PlotIndexSetDouble(priceChangeBufferIndex, PLOT_EMPTY_VALUE, 0.0);
PlotIndexSetInteger(priceChangeBufferIndex, PLOT_SHOW_DATA, showPriceChange);
PlotIndexSetInteger(priceChangeBufferIndex, PLOT_DRAW_TYPE, priceChangeDrawType);
//
// PriceChange Smoothed ...
ENUM_DRAW_TYPE priceChangeSmoothedaDrawType = showSmoothedPriceChange ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(priceChangeSmoothedBuffer, true);
SetIndexBuffer(priceChangeSmoothedBufferIndex, priceChangeSmoothedBuffer, INDICATOR_DATA);
PlotIndexSetDouble(priceChangeSmoothedBufferIndex, PLOT_EMPTY_VALUE, 0.0);
PlotIndexSetInteger(priceChangeSmoothedBufferIndex, PLOT_SHOW_DATA, showSmoothedPriceChange);
PlotIndexSetInteger(priceChangeSmoothedBufferIndex, PLOT_DRAW_TYPE, priceChangeSmoothedaDrawType);
//
// RSIChange ...
ENUM_DRAW_TYPE rsiChangeDrawType = showRSIChange ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(rsiChangeBuffer, true);
SetIndexBuffer(rsiChangeBufferIndex, rsiChangeBuffer, INDICATOR_DATA);
PlotIndexSetDouble(rsiChangeBufferIndex, PLOT_EMPTY_VALUE, 0.0);
PlotIndexSetInteger(rsiChangeBufferIndex, PLOT_SHOW_DATA, showRSIChange);
PlotIndexSetInteger(rsiChangeBufferIndex, PLOT_DRAW_TYPE, rsiChangeDrawType);
//
// RSIChangeMa ...
ENUM_DRAW_TYPE rsiChangeMaDrawType = showSmoothedRSIChange ? DRAW_LINE : DRAW_NONE;
ArraySetAsSeries(rsiChangeSmoothedBuffer, true);
SetIndexBuffer(rsiChangeSmoothedBufferIndex, rsiChangeSmoothedBuffer, INDICATOR_DATA);
PlotIndexSetDouble(rsiChangeSmoothedBufferIndex, PLOT_EMPTY_VALUE, 0.0);
PlotIndexSetInteger(rsiChangeSmoothedBufferIndex, PLOT_SHOW_DATA, showSmoothedRSIChange);
PlotIndexSetInteger(rsiChangeSmoothedBufferIndex, PLOT_DRAW_TYPE, rsiChangeMaDrawType);
//
// Data Buffers ...
//
// ATR ...
ArraySetAsSeries(atrBuffer, true);
SetIndexBuffer(atrBufferIndex, atrBuffer, INDICATOR_CALCULATIONS);
//
// RSI ...
ArraySetAsSeries(rsiBuffer, true);
SetIndexBuffer(rsiBufferIndex, rsiBuffer, INDICATOR_CALCULATIONS);
}
/**
* Set Indicator Short Name and also we can define Buffers Labels ...
*/
void SetIndicatorName()
{
//
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
IndicatorSetInteger(INDICATOR_DIGITS, 2);
}
/**
* Calculate Custom Buffers ...
*
* @param bar_index: Integer, Represent Current Bar ...
* @param prevCalculated: Integer, Represent Previous Calculated Bars ...
* @param ratesTotal: Integer, Represents All Available Bars ...
* @param open: Double Array, History of Open Prices ...
* @param high: Double Array, History of High Prices ...
* @param close: Double Array, History of Close Prices ...
* @param low: Double Array, History of Low Prices ...
* @param tickVolume: Long, History of Tick Volumes on Bar ...
*/
void CalculateBuffers(
int bar_index, // Selected Bar Index
const int prevCalculated,
const int ratesTotal,
const double &open[],
const double &high[],
const double &close[],
const double &low[],
const long &tickVolume[] //
)
{
//
int barsLimit = startCalculationForLastBars > 0
? startCalculationForLastBars
: 0;
//
// bool canCalculate = true;
bool canCalculate =
barsLimit == 0 ||
bar_index <= barsLimit;
if (canCalculate)
{
//
CalculateAtrZones(
bar_index,
prevCalculated,
ratesTotal,
open,
high,
close,
low //
);
}
else
{
FillBuffersZero(bar_index);
}
}
//
// Custom ...
/**
* Fill All Bufers to Zero Vlue for Specified Bar Index ...
*
* @param barIndex: Integer ...
*/
void FillBuffersZero(int barIndex)
{
//
rsiBuffer[barIndex] = 0;
atrBuffer[barIndex] = 0;
atrUpperBuffer[barIndex] = 0;
atrLowerBuffer[barIndex] = 0;
rsiChangeBuffer[barIndex] = 0;
priceChangeBuffer[barIndex] = 0;
atrSmoothedUpperBuffer[barIndex] = 0;
atrSmoothedLowerBuffer[barIndex] = 0;
rsiChangeSmoothedBuffer[barIndex] = 0;
priceChangeSmoothedBuffer[barIndex] = 0;
}
/**
* Calculate ATR Zones ...
*
* @param bar_index: Integer, Represent Current Bar ...
* @param prevCalculated: Integer, Represent Previous Calculated Bars ...
* @param ratesTotal: Integer, Represents All Available Bars ...
* @param open: Double Array, History of Open Prices ...
* @param high: Double Array, History of High Prices ...
* @param close: Double Array, History of Close Prices ...
* @param low: Double Array, History of Low Prices ...
*/
void CalculateAtrZones(
int bar_index, // Selected Bar Index
const int prevCalculated,
const int ratesTotal,
const double &open[],
const double &high[],
const double &close[],
const double &low[] //
)
{
//
double points = GetPoints(_Symbol);
//
// ATR Calculations ...
double iAtr = atrBuffer[bar_index];
double iMultiPliedAtr = iAtr * atrMultiplier;
//
// Select Upper Price ...
double iUpperPrice = GetAppliedPrice(
atrUpperPriceType,
open,
high,
low,
close,
bar_index //
);
//
// Select Lower Price ...
double iLowerPrice = GetAppliedPrice(
atrLowerPriceType,
open,
high,
low,
close,
bar_index //
);
//
// Calculate Atrs ...
//
double iAtrUpper = iUpperPrice + iMultiPliedAtr;
double iAtrLower = iLowerPrice - iMultiPliedAtr;
//
atrUpperBuffer[bar_index] = iAtrUpper;
atrLowerBuffer[bar_index] = iAtrLower;
//
bool canSmoothAtr = atrSmoothingMethod != X_MA_MODE_NONE;
if (canSmoothAtr)
{
//
// Upper ...
iMAOnBuffer(
ratesTotal,
prevCalculated,
bar_index,
atrLength,
atrUpperBuffer,
atrSmoothedUpperBuffer,
atrSmoothingMethod //
);
//
// Lower ...
iMAOnBuffer(
ratesTotal,
prevCalculated,
bar_index,
atrLength,
atrLowerBuffer,
atrSmoothedLowerBuffer,
atrSmoothingMethod //
);
}
else
{
//
atrSmoothedUpperBuffer[bar_index] = iAtrUpper;
atrSmoothedLowerBuffer[bar_index] = iAtrLower;
}
//
// RSI Change Calculations ...
//
double iRsi = rsiBuffer[bar_index];
double iRsiP = rsiBuffer[bar_index + 1];
double iRsiPrice = GetAppliedPrice(
rsiPriceType,
open,
high,
low,
close,
bar_index //
);
//
double iRsiChanged = iRsi - iRsiP;
double iRsiPointsChanged = iRsiChanged / points;
//
double iRChange = iRsiPrice + (iRsiChanged * points);
rsiChangeBuffer[bar_index] = iRChange;
//
bool canSmoothRsi = rsiSmoothingMethod != X_MA_MODE_NONE;
if (canSmoothRsi)
{
//
// Upper ...
iMAOnBuffer(
ratesTotal,
prevCalculated,
bar_index,
atrLength,
rsiChangeBuffer,
rsiChangeSmoothedBuffer,
rsiSmoothingMethod //
);
}
else
{
rsiChangeSmoothedBuffer[bar_index] = iRChange;
}
//
// PRICE Change Calculation ...
//
double iPChangePrice = GetAppliedPrice(
priceChangeType,
open,
high,
low,
close,
bar_index //
);
double iPPChangePrice = GetAppliedPrice(
priceChangeType,
open,
high,
low,
close,
bar_index + 1 //
);
//
double iPriceChange = iPChangePrice - iPPChangePrice;
double iPricePointsChanged = iPriceChange / points;
double iVolatilityChange = iPriceChange / iAtr;
//
double iPChange = iPChangePrice + (iPricePointsChanged * points);
priceChangeBuffer[bar_index] = iPChange;
//
bool canSmoothPriceChange = priceChangeSmoothingMethod != X_MA_MODE_NONE;
if (canSmoothPriceChange)
{
//
// Upper ...
iMAOnBuffer(
ratesTotal,
prevCalculated,
bar_index,
atrLength,
priceChangeBuffer,
priceChangeSmoothedBuffer,
priceChangeSmoothingMethod //
);
}
else
{
priceChangeSmoothedBuffer[bar_index] = iPChange;
}
}
//
File diff suppressed because it is too large Load Diff
-126
View File
@@ -47,7 +47,6 @@
#include "../Classes/x-saherelm.x-bar.analyser.class.mq5"
#include "../Classes/x-saherelm.x-poi.drawer.class.mq5"
#include "../Libraries/x-saherelm.common.lib.mq5"
#include "../Libraries/x-saherelm.x121.xcatb.lib.mq5"
//
// Inputs ...
@@ -1938,131 +1937,6 @@ void CalculateValues(
low,
tickVolume //
);
//
// Try To Detect Trigger Block ...
//
// Prevent Calculation ...
if (maxBarIndex - barIndex < maxLength)
{
return;
}
//
XTriggerBlock tb;
bool has = DetectTriggerBlock(
//
_Symbol,
_Period,
//
tb,
//
mBarAnalyser,
//
// Required Buffers ...
atrBuffer,
rsiBuffer,
adxBuffer,
adxpBuffer,
adxnBuffer,
peakBuffer,
valeBuffer,
deltaBuffer,
sarBuffer,
sarStateBuffer,
trendBuffer,
trendStateBuffer,
atrUpperBuffer,
atrLowerBuffer,
sBarOpenBuffer,
sBarCloseBuffer,
hkSBarOpenBuffer,
hkSBarCloseBuffer,
peakGoldenBuffer,
valeGoldenBuffer,
deltaSignalBuffer,
bullishVolumeSignalBuffer,
bearishVolumeSignalBuffer,
//
barIndex,
//
// Signalling ...
signalR2R,
slAtrMultiplier,
//
// Configs ...
rsiOBLevel,
rsiOSLevel,
adxThreshold,
//
// Validators ...
forceObBarType,
forceOBFVGBarType,
forceHasSwing,
forceHasFLiquidity,
forceHasRLiquidity,
validateGapSequence,
validateBlockEdgeBreakout,
//
// Filters ...
filterBasedOnPV,
filterBasedOnSar,
filterBasedOnRSI,
filterBasedOnADX,
filterBasedOnATR,
filterBasedOnTrend,
filterBasedOnDelta,
filterBasedOnVolume,
filterBasedOnSignalBar,
filterBasedOnHKSignalBar //
);
if (has)
{
//
// Draw ...
if (drawTriggerBlock)
{
//
has = DrawTriggerBlock(
tb,
mDrawer,
mObjects,
NULL,
drawSignals //
);
}
//
// Alert ...
bool canAlert =
mEnableAlerts &&
prevCalculated > 0;
bool canLogOnly =
mEnableAlerts &&
prevCalculated == 0;
if (has &&
(canAlert ||
canLogOnly))
{
//
string message =
tb.trigger.symbol + "," +
ToString(tb.trigger.period) + "> " +
ToString(tb.trigger.dir) +
" Zone Detected at: " + ToString(tb.trigger.to);
//
if (canLogOnly)
{
mAlert.LogAlert(message);
}
else if (canAlert)
{
mAlert.SendAlert(message);
}
}
}
}
//
-550
View File
@@ -1,550 +0,0 @@
///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Ocillator
// -------------------------------------------------
// Name: X121 XDelta
// Description: Detect Comulative Volumes Delta ...
//
//
// 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 XDelta Ocillator"
#property strict
//
// Definitions ...
//
#define ShortName "X121_XDELTA"
//
// Imports ...
#include "../Libraries/x-saherelm.common.lib.mq5"
//
// Inputs ...
//
// Makret ...
input group "Market";
input int maLength = 14; // Moving Averge Length
input ENUM_X_MA_METHOD maMethod = X_MA_MODE_EMA; // Moving Averge Method
//
// Presentation ...
input group "Presentation";
input int startCalculationForLastBars = 1000; // Calculate Last n Bars
input bool showDeltaLine = true; // Show Delta Line
input bool showDeltaHistogram = true; // Show Delta Histogram
input bool showDeltaMa = true; // Show Delta Moving Average
//
// Buffers Props ...
//
#property indicator_separate_window
//
#property indicator_buffers 6
#property indicator_plots 3
//
#define hideColorIDX 0
#define bullishColorIDX 1
#define bearishColorIDX 2
//
// Buffers ...
//
#define deltaLineBufferIndex 0
double deltaLineBuffer[];
#property indicator_label1 "Delta Line"
#property indicator_type1 DRAW_LINE
#property indicator_color1 clrYellow
#property indicator_style1 STYLE_SOLID
#property indicator_width1 1
//
#define deltaHistogramBufferIndex 1
double deltaHistogramBuffer[];
//
#define deltaHistogramColorBufferIndex 2
double deltaHistogramColorBuffer[];
#property indicator_label2 "Delta Histogram"
#property indicator_type2 DRAW_COLOR_HISTOGRAM
#property indicator_color2 CLR_NONE, clrGreen, clrDarkRed
#property indicator_style2 STYLE_DOT
#property indicator_width2 1
//
#define deltaMaBufferIndex 3
double deltaMaBuffer[];
#property indicator_label3 "Delta MA"
#property indicator_type3 DRAW_LINE
#property indicator_color3 clrOrchid
#property indicator_style3 STYLE_SOLID
#property indicator_width3 1
//
// Data Buffers ...
#define mLastBufferIndex 3
//
#define rawDeltaBufferIndex mLastBufferIndex + 1
double rawDeltaBuffer[];
//
#define deltaStateBufferIndex mLastBufferIndex + 2
double deltaStateBuffer[];
//
// Variables, Properties and etc ...
//
// this counts Available Bars ...
int limit;
//
int maxLength;
//
int firstBarIndex;
//
// Event Handlers ...
/**
* Initialize Indicator ...
*
* @return ( int )
*/
int OnInit()
{
//
// Validate Inputs ...
if (!ValidateInputs())
{
return INIT_PARAMETERS_INCORRECT;
}
//
// Initialize Indicator Handlers ...
//
// because in some cases we may have more than one input for
// calculation and we must prevent any calculation
// untill we pass the biggest input length, here we get max Input length
// and then wait until pass it ...
maxLength = ExtractMaxLengthOfInputs();
//
// Define Index Buffers ...
DefineBuffers();
//
// Set Indicator ShortName ...
SetIndicatorName();
IndicatorSetInteger(INDICATOR_DIGITS, 2);
//
// 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
}
/**
* 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);
//
limit = (prev_calculated > rates_total || prev_calculated <= 0)
? rates_total
: (rates_total - prev_calculated) + 1;
//
// Main Loop ...
for (int i = limit - 1; i >= 0 && !IsStopped(); i--)
{
//
CalculateBuffers(
//
i,
prev_calculated,
rates_total,
//
open,
high,
close,
low,
tick_volume //
);
}
//
return rates_total;
}
//
// Functions ...
/**
* Validate Input Args for Initialization ...
*
* @return ( bool )
*/
bool ValidateInputs()
{
//
bool result = false;
//
result = maLength > 0 &&
IsValid(maMethod);
//
return result;
}
/**
* Extract Max Length of Inputs ...
*
* @return ( int )
*/
int ExtractMaxLengthOfInputs()
{
//
int result = 0;
//
result = MathMax(0, maLength);
//
return result;
}
/**
* Set Indicator Short Name and also we can define Buffers Labels ...
*/
void SetIndicatorName()
{
IndicatorSetString(INDICATOR_SHORTNAME, ShortName);
}
/**
* Define Required Buffers ...
*/
void DefineBuffers()
{
//
// Plot Buffers ...
//
// Delta Line ...
ENUM_DRAW_TYPE deltaLineDrawType = showDeltaLine ? DRAW_LINE : DRAW_NONE;
//
ArraySetAsSeries(deltaLineBuffer, true);
SetIndexBuffer(deltaLineBufferIndex, deltaLineBuffer, INDICATOR_DATA);
PlotIndexSetDouble(deltaLineBufferIndex, PLOT_EMPTY_VALUE, 0.0);
PlotIndexSetInteger(deltaLineBufferIndex, PLOT_SHOW_DATA, showDeltaLine);
PlotIndexSetInteger(deltaLineBufferIndex, PLOT_DRAW_TYPE, deltaLineDrawType);
//
// Delta Histogram ...
ENUM_DRAW_TYPE deltaHistogramDrawType = showDeltaHistogram ? DRAW_COLOR_HISTOGRAM : DRAW_NONE;
//
ArraySetAsSeries(deltaHistogramBuffer, true);
SetIndexBuffer(deltaHistogramBufferIndex, deltaHistogramBuffer, INDICATOR_DATA);
PlotIndexSetDouble(deltaHistogramBufferIndex, PLOT_EMPTY_VALUE, 0.0);
PlotIndexSetInteger(deltaHistogramBufferIndex, PLOT_SHOW_DATA, showDeltaHistogram);
PlotIndexSetInteger(deltaHistogramBufferIndex, PLOT_DRAW_TYPE, deltaHistogramDrawType);
//
ArraySetAsSeries(deltaHistogramColorBuffer, true);
SetIndexBuffer(deltaHistogramColorBufferIndex, deltaHistogramColorBuffer, INDICATOR_COLOR_INDEX);
//
// Delta Ma ...
ENUM_DRAW_TYPE deltaMaDrawType = showDeltaMa ? DRAW_LINE : DRAW_NONE;
//
ArraySetAsSeries(deltaMaBuffer, true);
SetIndexBuffer(deltaMaBufferIndex, deltaMaBuffer, INDICATOR_DATA);
PlotIndexSetDouble(deltaMaBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE);
PlotIndexSetInteger(deltaMaBufferIndex, PLOT_SHOW_DATA, showDeltaMa);
PlotIndexSetInteger(deltaMaBufferIndex, PLOT_DRAW_TYPE, deltaMaDrawType);
//
// Data Buffers ...
//
ArraySetAsSeries(rawDeltaBuffer, true);
SetIndexBuffer(rawDeltaBufferIndex, rawDeltaBuffer, INDICATOR_CALCULATIONS);
//
ArraySetAsSeries(deltaStateBuffer, true);
SetIndexBuffer(deltaStateBufferIndex, deltaStateBuffer, INDICATOR_CALCULATIONS);
}
/**
* Calculate Custom Buffers ...
*
* @param bar_index: Integer, Represent Current Bar ...
* @param prevCalculated: Integer, Represent Previous Calculated Bars ...
* @param ratesTotal: Integer, Represents All Available Bars ...
* @param open: Double Array, History of Open Prices ...
* @param high: Double Array, History of High Prices ...
* @param close: Double Array, History of Close Prices ...
* @param low: Double Array, History of Low Prices ...
* @param tickVolume: Long, History of Tick Volumes on Bar ...
*/
void CalculateBuffers(
int bar_index, // Selected Bar Index
const int prevCalculated,
const int ratesTotal,
const double &open[],
const double &high[],
const double &close[],
const double &low[],
const long &tickVolume[] //
)
{
//
int barsLimit = startCalculationForLastBars > 0
? startCalculationForLastBars
: 0;
if (barsLimit == 0)
{
//
barsLimit = ratesTotal;
firstBarIndex = barsLimit - 1;
}
else
{
//
firstBarIndex = startCalculationForLastBars;
}
//
// bool canCalculate = true;
bool canCalculate =
bar_index <= barsLimit;
if (canCalculate)
{
//
CalculateValues(
bar_index,
prevCalculated,
ratesTotal,
open,
high,
close,
low,
tickVolume //
);
}
else
{
FillBuffersZero(bar_index);
}
}
/**
* Fill All Bufers to Zero Vlue for Specified Bar Index ...
*
* @param barIndex: Integer ...
*/
void FillBuffersZero(int barIndex)
{
//
rawDeltaBuffer[barIndex] = 0.0;
deltaLineBuffer[barIndex] = 0.0;
deltaStateBuffer[barIndex] = 0.0;
deltaHistogramBuffer[barIndex] = 0.0;
deltaMaBuffer[barIndex] = 0.0;
deltaHistogramColorBuffer[barIndex] = hideColorIDX;
}
/**
* Calculate Vales ...
*
* @param bar_index: Integer, Represent Current Bar ...
* @param prevCalculated: Integer, Represent Previous Calculated Bars ...
* @param ratesTotal: Integer, Represents All Available Bars ...
* @param open: Double Array, History of Open Prices ...
* @param high: Double Array, History of High Prices ...
* @param close: Double Array, History of Close Prices ...
* @param low: Double Array, History of Low Prices ...
* @param tickVolume: Long, History of Tick Volumes on Bar ...
*/
void CalculateValues(
int bar_index, // Selected Bar Index
const int prevCalculated,
const int ratesTotal,
const double &open[],
const double &high[],
const double &close[],
const double &low[],
const long &tickVolume[] //
)
{
//
// Check Prev Bar ...
int lastBarIndex = bar_index + 1;
bool isFirstBar =
startCalculationForLastBars > 0
? bar_index == startCalculationForLastBars
: bar_index == firstBarIndex;
//
XOHCL bar;
bool has = bar.Init(
_Symbol,
_Period,
bar_index //
);
if (!has)
{
return;
}
//
double iDelta = 0.0;
//
// Detecting Delta Volume ...
if (bar.IsBullish())
{
iDelta = (double)bar.volume;
}
else if (bar.IsBearish())
{
iDelta = -(double)bar.volume;
}
//
// Setting iDelta Value ...
if (isFirstBar)
{
//
rawDeltaBuffer[bar_index] = iDelta;
deltaLineBuffer[bar_index] = iDelta;
deltaHistogramBuffer[bar_index] = iDelta;
}
else
{
//
iDelta += deltaLineBuffer[bar_index + 1];
//
rawDeltaBuffer[bar_index] = iDelta;
deltaLineBuffer[bar_index] = iDelta;
deltaHistogramBuffer[bar_index] = iDelta;
}
//
// Setting iDelta State ...
double iState = iDelta > 0
? bullishColorIDX
: iDelta < 0
? bearishColorIDX
: hideColorIDX;
//
// Setting iDelta Color ...
double iDeltaColor = iDelta > 0
? bullishColorIDX
: iDelta < 0
? bearishColorIDX
: hideColorIDX;
//
deltaStateBuffer[bar_index] = iState;
deltaHistogramColorBuffer[bar_index] = iDeltaColor;
//
// Calculate Moving Averages ...
int deltaMAsCount = iMAOnBuffer(
ratesTotal,
prevCalculated,
bar_index,
maLength,
rawDeltaBuffer,
deltaMaBuffer,
maMethod //
);
//
bar.Clean();
}
//
File diff suppressed because it is too large Load Diff