From b675e80b278357d8c82cec9ffb9e4f36970e7c34 Mon Sep 17 00:00:00 2001 From: Hadi Khazaee Asl Date: Fri, 3 Oct 2025 00:53:51 +0330 Subject: [PATCH] Last works ... --- Documents/BKP/xfima.ind.tmp.mq5 | 2648 +++++++++++++++++ Helpers/x-saherelm.xfima.helper.mq5 | 239 ++ Indicators/x-saherelm.xfima.mq5 | 251 +- Libraries/x-saherelm.x-enums.lib.mq5 | 74 + Libraries/x-saherelm.x-poi.lib.mq5 | 71 + .../x-saherelm.xfima.signaller.class.mq5 | 53 +- .../x-saherelm.xfima.x-poi.detector.class.mq5 | 132 - 7 files changed, 3267 insertions(+), 201 deletions(-) create mode 100644 Documents/BKP/xfima.ind.tmp.mq5 diff --git a/Documents/BKP/xfima.ind.tmp.mq5 b/Documents/BKP/xfima.ind.tmp.mq5 new file mode 100644 index 00000000..f83b06de --- /dev/null +++ b/Documents/BKP/xfima.ind.tmp.mq5 @@ -0,0 +1,2648 @@ +/////////////////////////////////////////////////////// +// +// SaherElm IT Center MQL5 Indicator +// ------------------------------------------------- +// Name: XFIMA +// Description: Integrates All Requirements inside +// this indicator for analyse Markets Based on OM1 ... +// +// +// 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 XFIMA Indicator" +#property icon "../Images/SaherElm_Logo_Color.ico" +#property strict + +// +// Definitions ... + +// +// Definitions ... +enum ENUM_X_ZG_SEARCH_MODE +{ + X_ZG_SEARCH_EXTREMUM = 0, // searching for the first extremum + X_ZG_SEARCH_PEAK = 1, // searching for the next ZigZag peak + X_ZG_SEARCH_VALE = -1 // searching for the next ZigZag vale +}; + +// +#define ShortName "XFIMA" + +// +// Imports ... +#include "../Classes/x-saherelm.x-poi.drawer.class.mq5" +#include "../Libraries/x-saherelm.common.lib.mq5" + +// +// Inputs ... + +// +input group "Calculation"; + +// +// Short ... +input ENUM_X_PERIOD_METHOD scMethod = X_PERIOD_AUTO; // How to Find Short Period +input ENUM_TIMEFRAMES scPeriod = NULL; // Short Period + +// +// Medium ... +input ENUM_X_PERIOD_METHOD mcMethod = X_PERIOD_AUTO; // How to Find Medium Period +input ENUM_TIMEFRAMES mcPeriod = NULL; // Medium Period + +// +// Long ... +input ENUM_X_PERIOD_METHOD lcMethod = X_PERIOD_AUTO; // How to Find Long Period +input ENUM_TIMEFRAMES lcPeriod = NULL; // Long Period + +// +// Hind ... +input ENUM_X_PERIOD_METHOD hcMethod = X_PERIOD_AUTO; // How to Find Hind Period +input ENUM_TIMEFRAMES hcPeriod = NULL; // Hind Period + +// +// PV ... +input ENUM_SERIESMODE upperMode = MODE_HIGH; // Peak Method +input ENUM_SERIESMODE lowerMode = MODE_LOW; // Vale Method + +// +// Others ... +input ENUM_X_FIBO_LEVELS fiboUpperZoneLevel = X_FIBO_LEVEL_236; // Upper Zone Level +input ENUM_X_FIBO_LEVELS fiboMiddleZoneLevel = X_FIBO_LEVEL_500; // Upper Zone Level +input ENUM_X_FIBO_LEVELS fiboLowerZoneLevel = X_FIBO_LEVEL_764; // Lower Zone Level +input double sarStep = 0.02; // SAR Step +input double sarMax = 0.2; // SAR Maximum +input ENUM_MA_METHOD maMethod = MODE_EMA; // MA Method +input ENUM_APPLIED_PRICE maAppliedTo = PRICE_CLOSE; // MA Applied To +input int maFastLength = 7; // Fast MA Length +input int maSlowLength = 21; // Slow MA Length +input int maBondLength = 21; // MA Bond Length +input int zigzagDepth = 12; // ZigZag Depth +input int zigzagDeviation = 5; // ZigZag Deviation +input int zigzagBackStep = 3; // ZigZag Back Step +input ENUM_X_PRICE zigzagUppersMode = X_PRICE_HIGH; // ZigZag High Detect Mode +input ENUM_X_PRICE zigzagLowersMode = X_PRICE_LOW; // ZigZag Low Detect Mode +input bool hkIgnoreShadows = true; // HK Remove noises +input int hkSmoothingLength = 21; // HK Smoothing Length +input ENUM_X_MA_METHOD hkSmoothingMode = X_MA_MODE_EMA; // HK Smoothing Method + +// +// Presentation ... +input group "Presentation"; +input bool showPV = true; // Show PV +input bool showHK = true; // Show HK +input bool showSAR = true; // Show Sar +input bool showMAFast = true; // Show MA Fast +input bool showMASlow = true; // Show MA Slow +input bool showMABond = true; // Show MA Bond +input bool showHKBond = true; // Show HK Bond +input bool showZigZag = true; // Show ZigZag +input bool showFiboZone = true; // Show Fibo Zone + +// +input int startCalculationForLastBars = 1500; // Calculate Last n Bars + +// +input int sarArrowCode = 159; // Parabolic Sar Arrow Code +input int peakArrowCode = 159; // Peaks Arrow Code +input int valeArrowCode = 159; // Vales Arrow Code + +// +// Non Inputs ... + +// +#define hideColorIDX 0 +#define bullishColorIDX 1 +#define bearishColorIDX 2 +#define neuturalColorIDX 3 + +// +#define bullishState 1 +#define neuturalState 0 +#define bearishState -1 + +// +#define emptyValue 0.0 + +// +// Buffers ... + +// +#property indicator_chart_window + +// +#property indicator_buffers 44 +#property indicator_plots 16 + +// +// Plot Buffers ... + +// +// Fast MA ... + +// +#define maFastBufferIndex 0 +#define maFastBufferPlotIndex 0 +double maFastBuffer[]; + +// +#define maFastColorBufferIndex 1 +double maFastColorBuffer[]; + +// +#property indicator_label1 "FastMA" +#property indicator_type1 DRAW_COLOR_LINE +#property indicator_color1 CLR_NONE, clrLime, clrLime, clrLime // clrYellow, clrOrangeRed, clrGray +#property indicator_width1 3 + +// +// Slow MA ... + +// +#define maSlowBufferIndex 2 +#define maSlowBufferPlotIndex 1 +double maSlowBuffer[]; + +// +#define maSlowColorBufferIndex 3 +double maSlowColorBuffer[]; + +// +#property indicator_label2 "SlowMA" +#property indicator_type2 DRAW_COLOR_LINE +#property indicator_color2 CLR_NONE, clrRed, clrRed, clrRed // clrLime, clrRed, clrGray +#property indicator_width2 3 + +// +// SAR ... + +// +#define sarBufferIndex 4 +#define sarBufferPlotIndex 2 +double sarBuffer[]; + +// +#define sarColorBufferIndex 5 +double sarColorBuffer[]; + +// +#property indicator_label3 "SAR" +#property indicator_type3 DRAW_COLOR_ARROW +#property indicator_color3 CLR_NONE, clrLime, clrRed, clrGray +#property indicator_width3 2 + +// +// PEAKS ... + +// +#define peakBufferIndex 6 +#define peakBufferPlotIndex 3 +double peakBuffer[]; + +// +#property indicator_label4 "PEAK" +#property indicator_type4 DRAW_ARROW +#property indicator_color4 clrMagenta +#property indicator_width4 3 + +// +// VALES ... + +// +#define valeBufferIndex 7 +#define valeBufferPlotIndex 4 +double valeBuffer[]; + +// +#property indicator_label5 "VALE" +#property indicator_type5 DRAW_ARROW +#property indicator_color5 clrAqua +#property indicator_width5 3 + +// +// FIBO Upper ... + +// +#define fiboUpperBufferIndex 8 +#define fiboUpperBufferPlotIndex 5 +double fiboUpperBuffer[]; + +// +#property indicator_label6 "FIBUP" +#property indicator_type6 DRAW_LINE +#property indicator_color6 clrAqua +#property indicator_width6 2 + +// +// FIBO Middle ... + +// +#define fiboMiddleBufferIndex 9 +#define fiboMiddleBufferPlotIndex 6 +double fiboMiddleBuffer[]; + +// +#property indicator_label7 "FIBMID" +#property indicator_type7 DRAW_LINE +#property indicator_color7 clrBrown +#property indicator_width7 2 + +// +// FIBO Lower ... + +// +#define fiboLowerBufferIndex 10 +#define fiboLowerBufferPlotIndex 7 +double fiboLowerBuffer[]; + +// +#property indicator_label8 "FIBLO" +#property indicator_type8 DRAW_LINE +#property indicator_color8 clrMagenta +#property indicator_width8 2 + +// +// ZigZag ... + +// +#define zigzagBufferIndex 11 +#define zigzagBufferPlotIndex 8 +double zigzagBuffer[]; + +// +#property indicator_label9 "XZG" +#property indicator_type9 DRAW_SECTION +#property indicator_color9 clrYellow +#property indicator_width9 2 + +// +// MA Upper ... + +// +#define maUpperBufferIndex 12 +#define maUpperBufferPlotIndex 9 +double maUpperBuffer[]; + +// +#property indicator_label10 "UpperMA" +#property indicator_type10 DRAW_LINE +#property indicator_color10 clrLime +#property indicator_width10 3 + +// +// MA Lower ... + +// +#define maLowerBufferIndex 13 +#define maLowerBufferPlotIndex 10 +double maLowerBuffer[]; + +// +#property indicator_label11 "LowerMA" +#property indicator_type11 DRAW_LINE +#property indicator_color11 clrRed +#property indicator_width11 3 + +// +// XHK ... + +// +#define hkOpenBufferIndex 14 +double hkOpenBuffer[]; + +// +#define hkHighBufferIndex 15 +double hkHighBuffer[]; + +// +#define hkLowBufferIndex 16 +double hkLowBuffer[]; + +// +#define hkCloseBufferIndex 17 +double hkCloseBuffer[]; + +// +#define hkColorBufferIndex 18 +double hkColorBuffer[]; + +// +#define hkBufferPlotIndex 11 +#property indicator_label12 "XHK Open;XHK High;XHK Low;XHK Close" +#property indicator_type12 DRAW_COLOR_CANDLES +#property indicator_color12 CLR_NONE, clrAqua, clrMagenta, clrGray + +// +#define hkBondUpperBufferIndex 19 +double hkBondUpperBuffer[]; + +// +#define hkBondUpperBufferPlotIndex 12 +#property indicator_label13 "UpperHK" +#property indicator_type13 DRAW_LINE +#property indicator_color13 clrAqua +#property indicator_width13 3 + +// +#define hkBondLowerBufferIndex 20 +double hkBondLowerBuffer[]; + +// +#define hkBondLowerBufferPlotIndex 13 +#property indicator_label14 "LowerHK" +#property indicator_type14 DRAW_LINE +#property indicator_color14 clrMagenta +#property indicator_width14 3 + +// +// XPB ... + +// +#define pbUpperBufferIndex 21 +double pbUpperBuffer[]; + +// +#define pbUpperBufferPlotIndex 14 +#property indicator_label15 "UpperPB" +#property indicator_type15 DRAW_LINE +#property indicator_color15 clrAqua +#property indicator_width15 3 + +// +#define pbLowerBufferIndex 22 +double pbLowerBuffer[]; + +// +#define pbLowerBufferPlotIndex 15 +#property indicator_label16 "LowerPB" +#property indicator_type16 DRAW_LINE +#property indicator_color16 clrMagenta +#property indicator_width16 3 + +// +// Data Buffers ... + +// +#define mLastBufferIndex 22 + +// +// MA ... + +// +#define maFastStateBufferIndex mLastBufferIndex + 1 +double maFastStateBuffer[]; + +// +#define maSlowStateBufferIndex mLastBufferIndex + 2 +double maSlowStateBuffer[]; + +// +// SAR ... + +// +#define sarStateBufferIndex mLastBufferIndex + 3 +double sarStateBuffer[]; + +// +// CYCLES ... + +// +// SC ... + +// +#define sHHBufferIndex mLastBufferIndex + 4 +double sHHBuffer[]; + +// +#define sLLBufferIndex mLastBufferIndex + 5 +double sLLBuffer[]; + +// +// MC ... + +// +#define mHHBufferIndex mLastBufferIndex + 6 +double mHHBuffer[]; + +// +#define mLLBufferIndex mLastBufferIndex + 7 +double mLLBuffer[]; + +// +// LC ... + +// +#define lHHBufferIndex mLastBufferIndex + 8 +double lHHBuffer[]; + +// +#define lLLBufferIndex mLastBufferIndex + 9 +double lLLBuffer[]; + +// +// HC ... + +// +#define hHHBufferIndex mLastBufferIndex + 10 +double hHHBuffer[]; + +// +#define hLLBufferIndex mLastBufferIndex + 11 +double hLLBuffer[]; + +// +// ZigZag ... + +// +#define highsBufferIndex mLastBufferIndex + 12 +double highsBuffer[]; + +// +#define highsTimeBufferIndex mLastBufferIndex + 13 +double highsTimeBuffer[]; + +// +#define lowsBufferIndex mLastBufferIndex + 14 +double lowsBuffer[]; + +// +#define lowsTimeBufferIndex mLastBufferIndex + 15 +double lowsTimeBuffer[]; + +// +// XHK Data ... + +// +#define hkRawHighBufferIndex mLastBufferIndex + 16 +double hkRawHighBuffer[]; + +// +#define hkRawOpenBufferIndex mLastBufferIndex + 17 +double hkRawOpenBuffer[]; + +// +#define hkRawLowBufferIndex mLastBufferIndex + 18 +double hkRawLowBuffer[]; + +// +#define hkRawCloseBufferIndex mLastBufferIndex + 19 +double hkRawCloseBuffer[]; + +// +// XPB ... + +// +#define pbRawUpperBufferIndex mLastBufferIndex + 20 +double pbRawUpperBuffer[]; + +// +#define pbRawLowerBufferIndex mLastBufferIndex + 21 +double pbRawLowerBuffer[]; + +// +// Variables, Properties and etc ... + +// +// XMarketCycle sc; +int mSCLength = 0; +ENUM_TIMEFRAMES mSCPeriod = NULL; + +// +// XMarketCycle mc; +int mMCLength = 0; +ENUM_TIMEFRAMES mMCPeriod = NULL; + +// +// XMarketCycle lc; +int mLCLength = 0; +ENUM_TIMEFRAMES mLCPeriod = NULL; + +// +// XMarketCycle hc; +int mHCLength = 0; +ENUM_TIMEFRAMES mHCPeriod = NULL; + +// +int sarHandler = INVALID_HANDLE; +int maFastHandler = INVALID_HANDLE; +int maSlowHandler = INVALID_HANDLE; +int maUpperHandler = INVALID_HANDLE; +int maLowerHandler = INVALID_HANDLE; + +// +int limit; + +// +int maxLength; + +// +int firstBarIndex; + +// +// Requirements ... +CArrayObj mObjects; +XCPOIDrawer *mDrawer; + +// +double zigzagUppers[]; +double zigzagLowers[]; +int zigzagLowersCount = 0; +int zigzagUppersCount = 0; +int zigzagRecalc = 3; // Number of last extremes for recalculation + +// +double lastZigZagPeak = 0; +datetime lastZigZagPeakTime = NULL; + +// +double lastZigZagVale = 0; +datetime lastZigZagValeTime = NULL; + +// +// Event Handlers ... + +/** + * Initialize Indicator ... + * + * @return ( int ) + */ +int OnInit() +{ + // + bool has = false; + + // + // Validate Inputs ... + has = ValidateInputs(); + if (!has) + { + return INIT_PARAMETERS_INCORRECT; + } + + // + has = InitCycles(); + if (!has) + { + return INIT_FAILED; + } + + // + // because in some cases we may have more than one input for + // calculation and we must prevent any calculation + // untill we pass the biggest input length, here we get max Input length + // and then wait until pass it ... + maxLength = ExtractMaxLengthOfInputs(); + + // + // Initial Requirements ... + has = InitRequirements(); + if (!has) + { + return INIT_FAILED; + } + + // + // 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 + + // + delete mDrawer; + ZeroMemory(mDrawer); + + // + mObjects.Clear(); + + // + // De Initialize all Handlers and etc ... + IndicatorRelease(sarHandler); + IndicatorRelease(maFastHandler); + IndicatorRelease(maSlowHandler); + IndicatorRelease(maUpperHandler); + IndicatorRelease(maLowerHandler); +} + +/** + * 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[] // +) +{ + // + // Do ZigZag Calculations Before ArraySet As Series ... + int calculatedZigZags = CalculateZigZag( + 0, + prev_calculated, + rates_total, + open, + high, + close, + low, + tick_volume // + ); + if (calculatedZigZags != rates_total) + { + return prev_calculated; + } + + // + // Prepare Buffers ... + ArraySetAsSeries(time, true); + ArraySetAsSeries(open, true); + ArraySetAsSeries(high, true); + ArraySetAsSeries(low, true); + ArraySetAsSeries(close, true); + ArraySetAsSeries(tick_volume, true); + ArraySetAsSeries(volume, true); + ArraySetAsSeries(spread, true); + + // + // Validate Calculated Bars ... + + // + // MA ... + int maFastCalculatedBars = BarsCalculated(maFastHandler); + int maSlowCalculatedBars = BarsCalculated(maSlowHandler); + int maUpperCalculatedBars = BarsCalculated(maUpperHandler); + int maLowerCalculatedBars = BarsCalculated(maLowerHandler); + + // + // SAR ... + int sarCalculatedBars = BarsCalculated(sarHandler); + + // + bool isPassedRequiredCalculatedBars = + // + // MA ... + maFastCalculatedBars >= maxLength && + maSlowCalculatedBars >= maxLength && + maUpperCalculatedBars >= maxLength && + maLowerCalculatedBars >= maxLength && + // + // SAR ... + sarCalculatedBars >= maxLength + // + ; + if (!isPassedRequiredCalculatedBars) + { + return prev_calculated; + } + + // + limit = (prev_calculated > rates_total || prev_calculated <= 0) + ? rates_total + : (rates_total - prev_calculated) + 1; + + // + // Buffers Copy ... + + // + // MA ... + int copiedMAFasts = CopyBuffer(maFastHandler, MAIN_LINE, 0, limit, maFastBuffer); + int copiedMASlows = CopyBuffer(maSlowHandler, MAIN_LINE, 0, limit, maSlowBuffer); + int copiedMAUppers = CopyBuffer(maUpperHandler, MAIN_LINE, 0, limit, maUpperBuffer); + int copiedMALowers = CopyBuffer(maLowerHandler, MAIN_LINE, 0, limit, maLowerBuffer); + + // + // SAR ... + int copiedSARs = CopyBuffer(sarHandler, MAIN_LINE, 0, limit, sarBuffer); + + // + // Validate Copied Items ... + bool isPassedRequiredCopiedItems = + // + // MA ... + copiedMAFasts >= limit && + copiedMASlows >= limit && + copiedMAUppers >= limit && + copiedMALowers >= limit && + // + // SAR ... + copiedSARs >= 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; +} + +// +// Custom Functions ... + +/** + * Set Indicator Short Name and also we can define Buffers Labels ... + */ +void SetIndicatorName() +{ + // + IndicatorSetInteger(INDICATOR_DIGITS, _Digits); + IndicatorSetString(INDICATOR_SHORTNAME, ShortName); +} + +/** + * Validate Input Args for Initialization ... + * + * @return ( bool ) + */ +bool ValidateInputs() +{ + // + bool result = false; + + // + result = + // + // MA ... + maFastLength >= 2 && + maSlowLength >= 2 && + maBondLength >= 2 && + maSlowLength > maFastLength && + // + // SAR ... + sarMax > 0 && + sarStep > 0 && + sarMax > sarStep && + // + // CYCLES ... + (IsValid(scMethod, scPeriod) && + IsValid(mcMethod, mcPeriod) && + IsValid(lcMethod, lcPeriod) && + IsValid(hcMethod, hcPeriod)) && + // + // ZIGZAG ... + zigzagDepth > 0 && + zigzagDeviation > 0 && + zigzagBackStep > 0 && + // + // Validate Upper Mode Detection ... + IsXValid(zigzagUppersMode) && + // + // Validate Lower Mode Detection ... + IsXValid(zigzagLowersMode) + // + ; + + // + return result; +} + +/** + * Extract Max Length of Inputs ... + * + * @return ( int ) + */ +int ExtractMaxLengthOfInputs() +{ + // + int result = 0; + + // + result = MathMax(mSCLength, mMCLength); + result = MathMax(result, mLCLength); + result = MathMax(result, mHCLength); + result = MathMax(result, maFastLength); + result = MathMax(result, maSlowLength); + result = MathMax(result, maBondLength); + + // + return result; +} + +/** + * Define Required Buffers ... + */ +void DefineBuffers() +{ + // + // Fast MA ... + + // + ArraySetAsSeries(maFastBuffer, true); + SetIndexBuffer(maFastBufferIndex, maFastBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(maFastBufferPlotIndex, PLOT_SHOW_DATA, showMAFast); + PlotIndexSetDouble(maFastBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + + // + ArraySetAsSeries(maFastColorBuffer, true); + SetIndexBuffer(maFastColorBufferIndex, maFastColorBuffer, INDICATOR_COLOR_INDEX); + + // + ArraySetAsSeries(maFastStateBuffer, true); + SetIndexBuffer(maFastStateBufferIndex, maFastStateBuffer, INDICATOR_CALCULATIONS); + + // + // Slow MA ... + + // + ArraySetAsSeries(maSlowBuffer, true); + SetIndexBuffer(maSlowBufferIndex, maSlowBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(maSlowBufferPlotIndex, PLOT_SHOW_DATA, showMASlow); + PlotIndexSetDouble(maSlowBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + + // + ArraySetAsSeries(maSlowColorBuffer, true); + SetIndexBuffer(maSlowColorBufferIndex, maSlowColorBuffer, INDICATOR_COLOR_INDEX); + + // + ArraySetAsSeries(maSlowStateBuffer, true); + SetIndexBuffer(maSlowStateBufferIndex, maSlowStateBuffer, INDICATOR_CALCULATIONS); + + // + // SAR ... + + // + ArraySetAsSeries(sarBuffer, true); + SetIndexBuffer(sarBufferIndex, sarBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(sarBufferPlotIndex, PLOT_SHOW_DATA, showSAR); + PlotIndexSetDouble(sarBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + PlotIndexSetInteger(sarBufferPlotIndex, PLOT_ARROW, sarArrowCode); + + // + ArraySetAsSeries(sarColorBuffer, true); + SetIndexBuffer(sarColorBufferIndex, sarColorBuffer, INDICATOR_COLOR_INDEX); + + // + ArraySetAsSeries(sarStateBuffer, true); + SetIndexBuffer(sarStateBufferIndex, sarStateBuffer, INDICATOR_CALCULATIONS); + + // + // PEAK / VALE ... + + // + ENUM_DRAW_TYPE pvDrawType = showPV ? DRAW_ARROW : DRAW_NONE; + + // + // PEAK ... + + // + ArraySetAsSeries(peakBuffer, true); + SetIndexBuffer(peakBufferIndex, peakBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(peakBufferPlotIndex, PLOT_SHOW_DATA, showPV); + PlotIndexSetInteger(peakBufferPlotIndex, PLOT_DRAW_TYPE, pvDrawType); + + // + PlotIndexSetDouble(peakBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + PlotIndexSetInteger(peakBufferPlotIndex, PLOT_ARROW, peakArrowCode); + + // + // VALE ... + + // + ArraySetAsSeries(valeBuffer, true); + SetIndexBuffer(valeBufferIndex, valeBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(valeBufferPlotIndex, PLOT_SHOW_DATA, showPV); + PlotIndexSetInteger(valeBufferPlotIndex, PLOT_DRAW_TYPE, pvDrawType); + + // + PlotIndexSetDouble(valeBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + PlotIndexSetInteger(valeBufferPlotIndex, PLOT_ARROW, valeArrowCode); + + // + // FIBO Zone ... + + // + ENUM_DRAW_TYPE fiboZoneDrawType = showFiboZone ? DRAW_LINE : DRAW_NONE; + + // + // Upper ... + ArraySetAsSeries(fiboUpperBuffer, true); + SetIndexBuffer(fiboUpperBufferIndex, fiboUpperBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(fiboUpperBufferPlotIndex, PLOT_SHOW_DATA, showFiboZone); + PlotIndexSetInteger(fiboUpperBufferPlotIndex, PLOT_DRAW_TYPE, fiboZoneDrawType); + PlotIndexSetDouble(fiboUpperBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + + // + // Middle ... + ArraySetAsSeries(fiboMiddleBuffer, true); + SetIndexBuffer(fiboMiddleBufferIndex, fiboMiddleBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(fiboMiddleBufferPlotIndex, PLOT_SHOW_DATA, showFiboZone); + PlotIndexSetInteger(fiboMiddleBufferPlotIndex, PLOT_DRAW_TYPE, fiboZoneDrawType); + PlotIndexSetDouble(fiboMiddleBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + + // + // Lower ... + ArraySetAsSeries(fiboLowerBuffer, true); + SetIndexBuffer(fiboLowerBufferIndex, fiboLowerBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(fiboLowerBufferPlotIndex, PLOT_SHOW_DATA, showFiboZone); + PlotIndexSetInteger(fiboLowerBufferPlotIndex, PLOT_DRAW_TYPE, fiboZoneDrawType); + PlotIndexSetDouble(fiboLowerBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + + // + // ZigZag ... + + // + ENUM_DRAW_TYPE zigzagDrawType = showZigZag ? DRAW_SECTION : DRAW_NONE; + + // + SetIndexBuffer(zigzagBufferIndex, zigzagBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(zigzagBufferPlotIndex, PLOT_SHOW_DATA, showZigZag); + PlotIndexSetInteger(zigzagBufferPlotIndex, PLOT_DRAW_TYPE, zigzagDrawType); + + PlotIndexSetInteger(zigzagBufferPlotIndex, PLOT_DRAW_BEGIN, 0); + PlotIndexSetDouble(zigzagBufferPlotIndex, PLOT_EMPTY_VALUE, 0); + + // + // MA Bond ... + + // + ENUM_DRAW_TYPE maBondDrawType = showMABond ? DRAW_LINE : DRAW_NONE; + + // + // MA Upper Bond ... + + // + ArraySetAsSeries(maUpperBuffer, true); + SetIndexBuffer(maUpperBufferIndex, maUpperBuffer, INDICATOR_DATA); + + // // + // PlotIndexSetInteger(maUpperBufferPlotIndex, PLOT_SHOW_DATA, showMABond); + // PlotIndexSetInteger(maUpperBufferPlotIndex, PLOT_DRAW_TYPE, maBondDrawType); + + // PlotIndexSetInteger(maUpperBufferPlotIndex, PLOT_DRAW_BEGIN, 0); + // PlotIndexSetDouble(maUpperBufferPlotIndex, PLOT_EMPTY_VALUE, 0); + + // + // MA Lower Bond ... + + // + ArraySetAsSeries(maLowerBuffer, true); + SetIndexBuffer(maLowerBufferIndex, maLowerBuffer, INDICATOR_DATA); + + // // + // PlotIndexSetInteger(maLowerBufferPlotIndex, PLOT_SHOW_DATA, showMABond); + // PlotIndexSetInteger(maLowerBufferPlotIndex, PLOT_DRAW_TYPE, maBondDrawType); + + // PlotIndexSetInteger(maLowerBufferPlotIndex, PLOT_DRAW_BEGIN, 0); + // PlotIndexSetDouble(maLowerBufferPlotIndex, PLOT_EMPTY_VALUE, 0); + + // + // XHK ... + + // + // XHK Color ... + ArraySetAsSeries(hkColorBuffer, true); + SetIndexBuffer(hkColorBufferIndex, hkColorBuffer, INDICATOR_COLOR_INDEX); + + // + // Set EMPTY_VALUE on XHK Bar Buffer ... + PlotIndexSetDouble(hkBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + PlotIndexSetInteger(hkBufferPlotIndex, PLOT_SHOW_DATA, false); + + // + // Open ... + ArraySetAsSeries(hkOpenBuffer, true); + SetIndexBuffer(hkOpenBufferIndex, hkOpenBuffer, INDICATOR_DATA); + + // + // High ... + ArraySetAsSeries(hkHighBuffer, true); + SetIndexBuffer(hkHighBufferIndex, hkHighBuffer, INDICATOR_DATA); + + // + // Low ... + ArraySetAsSeries(hkLowBuffer, true); + SetIndexBuffer(hkLowBufferIndex, hkLowBuffer, INDICATOR_DATA); + + // + // Close ... + ArraySetAsSeries(hkCloseBuffer, true); + SetIndexBuffer(hkCloseBufferIndex, hkCloseBuffer, INDICATOR_DATA); + + // + // XHK Bond ... + + // + ENUM_DRAW_TYPE hkBondDrawType = showHKBond ? DRAW_LINE : DRAW_NONE; + + // + // Upper ... + ArraySetAsSeries(hkBondUpperBuffer, true); + SetIndexBuffer(hkBondUpperBufferIndex, hkBondUpperBuffer, INDICATOR_DATA); + + // // + // PlotIndexSetInteger(hkBondUpperBufferPlotIndex, PLOT_SHOW_DATA, showHKBond); + // PlotIndexSetInteger(hkBondUpperBufferPlotIndex, PLOT_DRAW_TYPE, hkBondDrawType); + + // PlotIndexSetInteger(hkBondUpperBufferPlotIndex, PLOT_DRAW_BEGIN, 0); + // PlotIndexSetDouble(hkBondUpperBufferPlotIndex, PLOT_EMPTY_VALUE, 0); + + // + // Lower ... + ArraySetAsSeries(hkBondLowerBuffer, true); + SetIndexBuffer(hkBondLowerBufferPlotIndex, hkBondLowerBuffer, INDICATOR_DATA); + + // // + // PlotIndexSetInteger(hkBondLowerBufferPlotIndex, PLOT_SHOW_DATA, showHKBond); + // PlotIndexSetInteger(hkBondLowerBufferPlotIndex, PLOT_DRAW_TYPE, hkBondDrawType); + + // PlotIndexSetInteger(hkBondLowerBufferPlotIndex, PLOT_DRAW_BEGIN, 0); + // PlotIndexSetDouble(hkBondLowerBufferPlotIndex, PLOT_EMPTY_VALUE, 0); + + // + // XPB Bond ... + + // + // Upper ... + ArraySetAsSeries(pbUpperBuffer, true); + SetIndexBuffer(pbUpperBufferIndex, pbUpperBuffer, INDICATOR_DATA); + + // // + // PlotIndexSetInteger(pbUpperBufferIndex, PLOT_SHOW_DATA, showMABond); + // PlotIndexSetInteger(pbUpperBufferIndex, PLOT_DRAW_TYPE, maBondDrawType); + + // PlotIndexSetInteger(pbUpperBufferIndex, PLOT_DRAW_BEGIN, 0); + // PlotIndexSetDouble(pbUpperBufferIndex, PLOT_EMPTY_VALUE, 0); + + // + // Lower ... + ArraySetAsSeries(pbLowerBuffer, true); + SetIndexBuffer(pbLowerBufferIndex, pbLowerBuffer, INDICATOR_DATA); + + // // + // PlotIndexSetInteger(pbLowerBufferIndex, PLOT_SHOW_DATA, showMABond); + // PlotIndexSetInteger(pbLowerBufferIndex, PLOT_DRAW_TYPE, maBondDrawType); + + // PlotIndexSetInteger(pbLowerBufferIndex, PLOT_DRAW_BEGIN, 0); + // PlotIndexSetDouble(pbLowerBufferIndex, PLOT_EMPTY_VALUE, 0); + + // + // Data Buffers ... + + // + // CYCLES ... + + // + // SC ... + + // + ArraySetAsSeries(sHHBuffer, true); + SetIndexBuffer(sHHBufferIndex, sHHBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(sLLBuffer, true); + SetIndexBuffer(sLLBufferIndex, sLLBuffer, INDICATOR_CALCULATIONS); + + // + // MC ... + + // + ArraySetAsSeries(mHHBuffer, true); + SetIndexBuffer(mHHBufferIndex, mHHBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(mLLBuffer, true); + SetIndexBuffer(mLLBufferIndex, mLLBuffer, INDICATOR_CALCULATIONS); + + // + // LC ... + + // + ArraySetAsSeries(lHHBuffer, true); + SetIndexBuffer(lHHBufferIndex, lHHBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(lLLBuffer, true); + SetIndexBuffer(lLLBufferIndex, lLLBuffer, INDICATOR_CALCULATIONS); + + // + // HC ... + + // + ArraySetAsSeries(hHHBuffer, true); + SetIndexBuffer(hHHBufferIndex, hHHBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(hLLBuffer, true); + SetIndexBuffer(hLLBufferIndex, hLLBuffer, INDICATOR_CALCULATIONS); + + // + // Highs ... + SetIndexBuffer(highsBufferIndex, highsBuffer, INDICATOR_CALCULATIONS); + SetIndexBuffer(highsTimeBufferIndex, highsTimeBuffer, INDICATOR_CALCULATIONS); + + // + // Lows ... + SetIndexBuffer(lowsBufferIndex, lowsBuffer, INDICATOR_CALCULATIONS); + SetIndexBuffer(lowsTimeBufferIndex, lowsTimeBuffer, INDICATOR_CALCULATIONS); + + // + // XHK Data ... + + // + ArraySetAsSeries(hkRawHighBuffer, true); + SetIndexBuffer(hkRawHighBufferIndex, hkRawHighBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(hkRawOpenBuffer, true); + SetIndexBuffer(hkRawOpenBufferIndex, hkRawOpenBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(hkRawLowBuffer, true); + SetIndexBuffer(hkRawLowBufferIndex, hkRawLowBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(hkRawCloseBuffer, true); + SetIndexBuffer(hkRawCloseBufferIndex, hkRawCloseBuffer, INDICATOR_CALCULATIONS); + + // + // XPB Bond ... + + // + // Upper ... + ArraySetAsSeries(pbRawUpperBuffer, true); + SetIndexBuffer(pbRawUpperBufferIndex, pbRawUpperBuffer, INDICATOR_CALCULATIONS); + + // + // Lower ... + ArraySetAsSeries(pbRawLowerBuffer, true); + SetIndexBuffer(pbRawLowerBufferIndex, pbRawLowerBuffer, INDICATOR_CALCULATIONS); + + // +} + +/** + * Initial Market Cycles ... + * + * @return ( bool ) + */ +bool InitCycles() +{ + // + bool result = false; + + // + int cPeriodSeconds = PeriodSeconds(_Period); + + // + // Find Cycle Period ... + if (scMethod == X_PERIOD_AUTO) + { + // + // Select Period ... + mSCPeriod = GetCyclePeriod( + X_MARKET_CYCLE_SHORT, + _Period // + ); + } + else + { + mSCPeriod = scPeriod; + } + + // + if (IsValid(mSCPeriod)) + { + mSCLength = PeriodSeconds(mSCPeriod) / cPeriodSeconds; + } + + // + // Find Cycle Period ... + if (mcMethod == X_PERIOD_AUTO) + { + // + // Select Period ... + mMCPeriod = GetCyclePeriod( + X_MARKET_CYCLE_MEDIUM, + _Period // + ); + } + else + { + mMCPeriod = mcPeriod; + } + + // + if (IsValid(mMCPeriod)) + { + mMCLength = PeriodSeconds(mMCPeriod) / cPeriodSeconds; + } + + // + // Find Cycle Period ... + if (lcMethod == X_PERIOD_AUTO) + { + // + // Select Period ... + mLCPeriod = GetCyclePeriod( + X_MARKET_CYCLE_LONG, + _Period // + ); + } + else + { + mLCPeriod = lcPeriod; + } + + // + if (IsValid(mLCPeriod)) + { + mLCLength = PeriodSeconds(mLCPeriod) / cPeriodSeconds; + } + + // + // Find Cycle Period ... + if (hcMethod == X_PERIOD_AUTO) + { + // + // Select Period ... + mHCPeriod = GetCyclePeriod( + X_MARKET_CYCLE_HIND, + _Period // + ); + } + else + { + mHCPeriod = hcPeriod; + } + + // + if (IsValid(mHCPeriod)) + { + mHCLength = PeriodSeconds(mHCPeriod) / cPeriodSeconds; + } + + // + result = mSCLength > 0 && + mMCLength > mSCLength && + mLCLength > mMCLength && + mHCLength > mLCLength; + + // + return result; +} + +/** + * Initial all Indicator Requirements ... + * + * @return ( false ) + * + */ +bool InitRequirements() +{ + // + bool result = false; + + // + // Handlers ... + + // + // Fast MA ... + maFastHandler = iMA( + _Symbol, + _Period, + maFastLength, + 0, + maMethod, + maAppliedTo // + ); + result = maFastHandler != INVALID_HANDLE; + if (!result) + { + return result; + } + + // + // Slow MA ... + maSlowHandler = iMA( + _Symbol, + _Period, + maSlowLength, + 0, + maMethod, + maAppliedTo // + ); + result = maSlowHandler != INVALID_HANDLE; + if (!result) + { + return result; + } + + // + // MA Bond Upper ... + maUpperHandler = iMA( + _Symbol, + _Period, + maBondLength, + 0, + maMethod, + PRICE_HIGH // + ); + result = maUpperHandler != INVALID_HANDLE; + if (!result) + { + return result; + } + + // + // MA Bond Lower ... + maLowerHandler = iMA( + _Symbol, + _Period, + maBondLength, + 0, + maMethod, + PRICE_LOW // + ); + result = maLowerHandler != INVALID_HANDLE; + if (!result) + { + return result; + } + + // + // SAR ... + sarHandler = iSAR( + _Symbol, + _Period, + sarStep, + sarMax // + ); + result = sarHandler != INVALID_HANDLE; + if (!result) + { + return result; + } + + // + mDrawer = new XCPOIDrawer(); + + // + return result; +} + +/** + * Calculate Custom Buffers ... + * + * @param barIndex: Integer, Represent Current Bar ... + * @param prevCalculated: Integer, Represent Previous Calculated Bars ... + * @param ratesTotal: Integer, Represents All Available Bars ... + * @param open: Double Array, History of Open Prices ... + * @param high: Double Array, History of High Prices ... + * @param close: Double Array, History of Close Prices ... + * @param low: Double Array, History of Low Prices ... + * @param tickVolume: Long, History of Tick Volumes on Bar ... + */ +void CalculateBuffers( + int barIndex, + const int prevCalculated, + const int ratesTotal, + const double &open[], + const double &high[], + const double &close[], + const double &low[], + const long &tickVolume[] // +) +{ + // + // Calculate Bars Limit and First Bar Index ... + int barsLimit = startCalculationForLastBars > 0 + ? startCalculationForLastBars + : 0; + if (barsLimit == 0) + { + // + barsLimit = ratesTotal; + firstBarIndex = barsLimit - 1; + } + else + { + firstBarIndex = startCalculationForLastBars; + } + + // + // bool canCalculate = true; + bool canCalculate = + barIndex <= barsLimit; + if (canCalculate) + { + // + // Calculate Values ... + CalculateValues( + barIndex, + prevCalculated, + ratesTotal, + open, + high, + close, + low, + tickVolume // + ); + } + else + { + FillBuffersZero(barIndex); + } +} + +/** + * Fill All Bufers to Zero Vlue for Specified Bar Index ... + * + * @param barIndex: Integer ... + */ +void FillBuffersZero(int barIndex) +{ + // + // TODO: Fill Buffers as Empty ... +} + +/** + * Calculate Values ... + * + * @param barIndex: int, Specified Bar Index ... + * @param prevCalculated: int, Provides Previous Calculated Bars ... + * @param ratesTotal: int, Provides All Availabled Bars ... + * @param open: double Collection, Provides Open Prices Time Series ... + * @param high: double Collection, Provides High Prices Time Series ... + * @param close: double Collection, Provides Close Prices Time Series ... + * @param low: double Collection, Provides Low Prices Time Series ... + * @param tickVolume: long Collection, Provides Ticks Volume Prices Time Series ... + */ +void CalculateValues( + int barIndex, + const int prevCalculated, + const int ratesTotal, + const double &open[], + const double &high[], + const double &close[], + const double &low[], + const long &tickVolume[] // +) +{ + // + int lastBarIndex = barIndex + 1; + int maxBarIndex = startCalculationForLastBars > 0 + ? startCalculationForLastBars + : ratesTotal; + bool isFirstBar = + startCalculationForLastBars > 0 + ? barIndex == startCalculationForLastBars + : barIndex == firstBarIndex; + + // + // Common Requirements ... + + // + // CYCLES Ranges ... + CalculateCycleRanges( + barIndex, + prevCalculated, + ratesTotal, + open, + high, + close, + low, + tickVolume // + ); + + // + // PV ... + CalculatePV( + barIndex, + prevCalculated, + ratesTotal, + open, + high, + close, + low, + tickVolume // + ); + + // + // XHK ... + CalculateHKBar( + barIndex, + prevCalculated, + ratesTotal, + open, + high, + close, + low, + tickVolume // + ); + + // + // Fast MA ... + double iFastMa = maFastBuffer[barIndex]; + double maFastState = close[barIndex] > iFastMa + ? bullishState + : close[barIndex] < iFastMa + ? bearishState + : neuturalState; + double maFastColor = close[barIndex] > iFastMa + ? bullishColorIDX + : close[barIndex] < iFastMa + ? bearishColorIDX + : neuturalColorIDX; + maFastStateBuffer[barIndex] = maFastState; + maFastColorBuffer[barIndex] = showMAFast + ? maFastColor + : hideColorIDX; + + // + // Slow MA ... + double iSlowMa = maSlowBuffer[barIndex]; + double maSlowState = close[barIndex] > iSlowMa + ? bullishState + : close[barIndex] < iSlowMa + ? bearishState + : neuturalState; + double maSlowColor = close[barIndex] > iSlowMa + ? bullishColorIDX + : close[barIndex] < iSlowMa + ? bearishColorIDX + : neuturalColorIDX; + maSlowStateBuffer[barIndex] = maSlowState; + maSlowColorBuffer[barIndex] = showMASlow + ? maSlowColor + : hideColorIDX; + + // // + // double iPBUpper = MathMax(open[barIndex], close[barIndex]); + // double iPBLower = MathMin(open[barIndex], close[barIndex]); + + // // + // pbRawUpperBuffer[barIndex] = iPBUpper; + // pbRawLowerBuffer[barIndex] = iPBLower; + + // // + // // Upper ... + // iMAOnBuffer( + // ratesTotal, + // prevCalculated, + // barIndex, + // maBondLength, + // pbRawUpperBuffer, + // pbUpperBuffer, + // ToXMaMethod(maMethod) // + // ); + + // // + // // Lower ... + // iMAOnBuffer( + // ratesTotal, + // prevCalculated, + // barIndex, + // maBondLength, + // pbRawLowerBuffer, + // pbLowerBuffer, + // ToXMaMethod(maMethod) // + // ); + + // + // SAR ... + double iSar = sarBuffer[barIndex]; + double sarState = low[barIndex] > iSar + ? bullishState + : high[barIndex] < iSar + ? bearishState + : neuturalState; + double sarColor = low[barIndex] > iSar + ? bullishColorIDX + : high[barIndex] < iSar + ? bearishColorIDX + : neuturalColorIDX; + sarStateBuffer[barIndex] = sarState; + sarColorBuffer[barIndex] = showSAR + ? sarColor + : hideColorIDX; + + // + // FIBO Zone ... + + // + double iPeak = peakBuffer[barIndex]; + double iVale = valeBuffer[barIndex]; + + // + double iFiboUp = GetFibonacciLevel( + iPeak, + iVale, + fiboUpperZoneLevel, + X_DIRECTION_BULLISH // + ); + + // + double iFiboMid = GetFibonacciLevel( + iPeak, + iVale, + fiboMiddleZoneLevel, + X_DIRECTION_BULLISH // + ); + + // + double iFiboLo = GetFibonacciLevel( + iPeak, + iVale, + fiboLowerZoneLevel, + X_DIRECTION_BULLISH // + ); + + // + fiboUpperBuffer[barIndex] = iFiboUp; + fiboMiddleBuffer[barIndex] = iFiboMid; + fiboLowerBuffer[barIndex] = iFiboLo; +} + +// +void CalculatePV( + int barIndex, + const int prevCalculated, + const int ratesTotal, + const double &open[], + const double &high[], + const double &close[], + const double &low[], + const long &tickVolume[] // +) +{ + // + int lastBarIndex = barIndex + 1; + bool isFirstBar = + startCalculationForLastBars > 0 + ? barIndex == startCalculationForLastBars + : barIndex == firstBarIndex; + + // + double iSHH = sHHBuffer[barIndex]; + double iSLL = sLLBuffer[barIndex]; + + // + double iMHH = mHHBuffer[barIndex]; + double iMLL = mLLBuffer[barIndex]; + + // + double iLHH = lHHBuffer[barIndex]; + double iLLL = lLLBuffer[barIndex]; + + // + double iHHH = hHHBuffer[barIndex]; + double iHLL = hLLBuffer[barIndex]; + + // + // Calculate VALE ... + bool isVale = iSLL == iMLL && + iMLL == iLLL && + iLLL == iHLL; + double iPVale = + isFirstBar + ? emptyValue + : valeBuffer[lastBarIndex]; + double iVale = + isVale + ? iSLL + : iPVale; + valeBuffer[barIndex] = iVale; + + // + // Calculate PEAK ... + bool isPeak = iSHH == iMHH && + iMHH == iLHH && + iLHH == iHHH; + double iPPeak = + isFirstBar + ? emptyValue + : peakBuffer[lastBarIndex]; + double iPeak = + isPeak + ? iSHH + : iPPeak; + peakBuffer[barIndex] = iPeak; +} + +/** + * Calculate Values ... + * + * @param barIndex: int, Specified Bar Index ... + * @param prevCalculated: int, Provides Previous Calculated Bars ... + * @param ratesTotal: int, Provides All Availabled Bars ... + * @param open: double Collection, Provides Open Prices Time Series ... + * @param high: double Collection, Provides High Prices Time Series ... + * @param close: double Collection, Provides Close Prices Time Series ... + * @param low: double Collection, Provides Low Prices Time Series ... + * @param tickVolume: long Collection, Provides Ticks Volume Prices Time Series ... + * + * @return ( int ) + */ +int CalculateZigZag( + int barIndex, + const int prevCalculated, + const int ratesTotal, + const double &open[], + const double &high[], + const double &close[], + const double &low[], + const long &tickVolume[] // +) +{ + // + int result = 0; + + // + // Define Variables ... + int i = 0; + + // + int start = 0; + int extreme_counter = 0; + int extreme_search = X_ZG_SEARCH_EXTREMUM; + int shift = 0; + int back = 0; + int last_high_pos = 0; + int last_low_pos = 0; + + // + double val = 0; + double res = 0; + double curlow = 0; + double curhigh = 0; + double last_high = 0; + double last_low = 0; + + // + // Initializing ... + if (prevCalculated == 0) + { + // + ArrayInitialize(lowsBuffer, 0); + ArrayInitialize(highsBuffer, 0); + ArrayInitialize(zigzagBuffer, 0); + ArrayInitialize(lowsTimeBuffer, 0); + ArrayInitialize(highsTimeBuffer, 0); + + // + start = zigzagDepth; + } + + // + // Preparing ZigZag Calculation High and Lows ... + + // + if (zigzagLowersCount != zigzagUppersCount || zigzagLowersCount != ratesTotal) + { + // + // Filling Upper ... + zigzagUppersCount = FillPrice( + zigzagUppersMode, + zigzagUppers, + open, + high, + close, + low // + ); + + // + // Filling Lower ... + zigzagLowersCount = FillPrice( + zigzagLowersMode, + zigzagLowers, + open, + high, + close, + low // + ); + } + + // + // Already Calculated Before ... + if (prevCalculated > 0) + { + // + i = ratesTotal - 1; + + // + // Searching for the third X_ZG_SEARCH_EXTREMUM from the last UnComplete Bar ... + while (extreme_counter < zigzagRecalc && i > ratesTotal - 100) + { + // + res = zigzagBuffer[i]; + if (res != 0) + { + extreme_counter++; + } + + // + i--; + } + + // + i++; + start = i; + + // + // What type of X_ZG_SEARCH_EXTREMUM we Search for ... + if (lowsBuffer[i] != 0) + { + // + curlow = lowsBuffer[i]; + extreme_search = X_ZG_SEARCH_PEAK; + } + else + { + // + curhigh = highsBuffer[i]; + extreme_search = X_ZG_SEARCH_VALE; + } + + // + // Clear Values ... + for (i = start + 1; i < ratesTotal && !IsStopped(); i++) + { + // + lowsBuffer[i] = 0; + highsBuffer[i] = 0; + zigzagBuffer[i] = 0; + lowsTimeBuffer[i] = 0; + highsTimeBuffer[i] = 0; + } + } + + // + // Search for High and Low Extremes ... + for (shift = start; shift < ratesTotal && !IsStopped(); shift++) + { + // + // Low ... + val = zigzagLowers[Lowest(zigzagLowers, zigzagDepth, shift)]; + if (val == last_low) + { + val = 0; + } + else + { + // + last_low = val; + + // + if ((zigzagLowers[shift] - val) > zigzagDeviation * _Point) + { + val = 0; + } + else + { + // + for (back = 1; back <= zigzagBackStep; back++) + { + // + res = lowsBuffer[shift - back]; + if ((res != 0) && (res > val)) + { + // + lowsBuffer[shift - back] = 0; + lowsTimeBuffer[shift - back] = 0; + } + } + } + } + + // + if (zigzagLowers[shift] == val) + { + // + lowsBuffer[shift] = val; + lowsTimeBuffer[shift] = GetZigZagBarTime(shift); + } + else + { + // + lowsBuffer[shift] = 0; + lowsTimeBuffer[shift] = 0; + } + + // + // High ... + val = zigzagUppers[Highest(zigzagUppers, zigzagDepth, shift)]; + if (val == last_high) + { + val = 0; + } + else + { + // + last_high = val; + + // + if ((val - zigzagUppers[shift]) > zigzagDeviation * _Point) + { + val = 0; + } + else + { + // + for (back = 1; back <= zigzagBackStep; back++) + { + // + res = highsBuffer[shift - back]; + if ((res != 0) && (res < val)) + { + // + highsBuffer[shift - back] = 0; + highsTimeBuffer[shift - back] = 0; + } + } + } + } + + // + if (zigzagUppers[shift] == val) + { + // + highsBuffer[shift] = val; + highsTimeBuffer[shift] = GetZigZagBarTime(shift); + } + else + { + highsBuffer[shift] = 0; + highsTimeBuffer[shift] = 0; + } + } + + // + // Set Last Value ... + if (extreme_search == 0) // Undefined Values ... + { + // + last_low = 0; + last_high = 0; + } + else + { + // + last_low = curlow; + last_high = curhigh; + } + + // + // Final Selection of Extreme Points for ZigZag ... + for (shift = start; shift < ratesTotal && !IsStopped(); shift++) + { + // + res = 0; + + // + switch (extreme_search) + { + // + case X_ZG_SEARCH_EXTREMUM: + // + if (last_low == 0 && last_high == 0) + { + // + if (highsBuffer[shift] != 0) + { + // + last_high_pos = shift; + last_high = zigzagUppers[shift]; + + // + extreme_search = X_ZG_SEARCH_VALE; + + // + zigzagBuffer[shift] = last_high; + + // + res = 1; + } + + // + if (lowsBuffer[shift] != 0) + { + // + last_low_pos = shift; + last_low = zigzagLowers[shift]; + + // + extreme_search = X_ZG_SEARCH_PEAK; + + // + zigzagBuffer[shift] = last_low; + + // + res = 1; + } + } + break; + + // + case X_ZG_SEARCH_PEAK: + // + if (lowsBuffer[shift] != 0 && lowsBuffer[shift] < last_low && highsBuffer[shift] == 0) + { + // + zigzagBuffer[last_low_pos] = 0; + + // + last_low_pos = shift; + last_low = lowsBuffer[shift]; + + // + zigzagBuffer[shift] = last_low; + + // + res = 1; + } + + // + if (highsBuffer[shift] != 0 && lowsBuffer[shift] == 0) + { + // + last_high_pos = shift; + last_high = highsBuffer[shift]; + + // + zigzagBuffer[shift] = last_high; + + // + extreme_search = X_ZG_SEARCH_VALE; + + // + res = 1; + } + break; + + // + case X_ZG_SEARCH_VALE: + // + if (highsBuffer[shift] != 0 && highsBuffer[shift] > last_high && lowsBuffer[shift] == 0) + { + // + zigzagBuffer[last_high_pos] = 0; + + // + last_high_pos = shift; + last_high = highsBuffer[shift]; + + // + zigzagBuffer[shift] = last_high; + } + + // + if (lowsBuffer[shift] != 0 && highsBuffer[shift] == 0) + { + // + last_low_pos = shift; + last_low = lowsBuffer[shift]; + + // + zigzagBuffer[shift] = last_low; + + // + extreme_search = X_ZG_SEARCH_PEAK; + } + break; + } + } + + // + result = ratesTotal; + + // + return result; +} + +// +void CalculateHKBar( + int barIndex, + const int prevCalculated, + const int ratesTotal, + const double &open[], + const double &high[], + const double &close[], + const double &low[], + const long &tickVolume[] // +) +{ + // + int lastBarIndex = barIndex + 1; + bool isFirstBar = + startCalculationForLastBars > 0 + ? barIndex == startCalculationForLastBars + : barIndex == firstBarIndex; + + // + double lastHKOpen = + isFirstBar + ? emptyValue + : hkOpenBuffer[lastBarIndex]; + double lastHKClose = + isFirstBar + ? emptyValue + : hkCloseBuffer[lastBarIndex]; + + // + double iHKOpenValue = (lastHKOpen + lastHKClose) / 2; + double iHKCloseValue = (open[barIndex] + high[barIndex] + close[barIndex] + low[barIndex]) / 4; + double iHKHighValue = MathMax(high[barIndex], MathMax(iHKOpenValue, iHKCloseValue)); + double iHKLowValue = MathMin(low[barIndex], MathMin(iHKOpenValue, iHKCloseValue)); + + // + bool isBullish = iHKOpenValue < iHKCloseValue; + bool isBearish = iHKOpenValue > iHKCloseValue; + + // + if (hkIgnoreShadows) + { + // + iHKHighValue = isBullish + ? iHKCloseValue + : iHKOpenValue; + + // + iHKLowValue = isBullish + ? iHKOpenValue + : iHKCloseValue; + } + + // + // XHK Buffers ... + hkOpenBuffer[barIndex] = iHKOpenValue; + hkHighBuffer[barIndex] = iHKHighValue; + hkLowBuffer[barIndex] = iHKLowValue; + hkCloseBuffer[barIndex] = iHKCloseValue; + + // + // XHK Raw Bufferss ... + hkRawOpenBuffer[barIndex] = iHKOpenValue; + hkRawHighBuffer[barIndex] = iHKHighValue; + hkRawLowBuffer[barIndex] = iHKLowValue; + hkRawCloseBuffer[barIndex] = iHKCloseValue; + + // + // Smoothing ... + if (IsXValid(hkSmoothingMode) && hkSmoothingLength > 0) + { + // + // XHK Signal ... + + // + // High ... + iMAOnBuffer( + ratesTotal, + prevCalculated, + barIndex, + hkSmoothingLength, + hkRawHighBuffer, + hkHighBuffer, + hkSmoothingMode // + ); + + // + // Open ... + iMAOnBuffer( + ratesTotal, + prevCalculated, + barIndex, + hkSmoothingLength, + hkRawOpenBuffer, + hkOpenBuffer, + hkSmoothingMode // + ); + + // + // Close ... + iMAOnBuffer( + ratesTotal, + prevCalculated, + barIndex, + hkSmoothingLength, + hkRawLowBuffer, + hkLowBuffer, + hkSmoothingMode // + ); + + // + // Close ... + iMAOnBuffer( + ratesTotal, + prevCalculated, + barIndex, + hkSmoothingLength, + hkRawCloseBuffer, + hkCloseBuffer, + hkSmoothingMode // + ); + } + + // + hkBondUpperBuffer[barIndex] = hkHighBuffer[barIndex]; + hkBondLowerBuffer[barIndex] = hkLowBuffer[barIndex]; + + // + // Calculate HK Color ... + double iHKColorValue = + isBullish + ? bullishColorIDX + : isBearish + ? bearishColorIDX + : neuturalColorIDX; + hkColorBuffer[barIndex] = + showHK + ? iHKColorValue + : hideColorIDX; +} + +// +void CalculateCycleRanges( + int barIndex, + const int prevCalculated, + const int ratesTotal, + const double &open[], + const double &high[], + const double &close[], + const double &low[], + const long &tickVolume[] // +) +{ + // + // SHORT ... + CalculateCycle( + barIndex, + X_MARKET_CYCLE_SHORT, + sHHBuffer, + sLLBuffer // + ); + + // + // MEDIUM ... + CalculateCycle( + barIndex, + X_MARKET_CYCLE_MEDIUM, + mHHBuffer, + mLLBuffer // + ); + + // + // LONG ... + CalculateCycle( + barIndex, + X_MARKET_CYCLE_LONG, + lHHBuffer, + lLLBuffer // + ); + + // + // HIND ... + CalculateCycle( + barIndex, + X_MARKET_CYCLE_HIND, + hHHBuffer, + hLLBuffer // + ); +} + +/** + * Calculate Specified Market Cycle Info ... + * + * @param barIndex: Integer, Bar Index ... + * @param cycle: ENUM_X_MARKET_CYCLES member, Specified Cycle ... + * @param hhBuffer: Highest High Buffer Reference ... + * @param llBuffer: Lowest Low Buffer Reference ... + */ +void CalculateCycle( + int barIndex, + ENUM_X_MARKET_CYCLES cycle, + double &hhBuffer[], + double &llBuffer[] // +) +{ + // + XOHCL bar; + bool isBarInited = bar.Init( + _Symbol, + _Period, + barIndex + // + ); + if (!isBarInited) + { + return; + } + + // + int mLength = 0; + switch (cycle) + { + // + case X_MARKET_CYCLE_SHORT: + mLength = mSCLength; + break; + + // + case X_MARKET_CYCLE_MEDIUM: + mLength = mMCLength; + break; + + // + case X_MARKET_CYCLE_LONG: + mLength = mLCLength; + break; + + // + case X_MARKET_CYCLE_HIND: + mLength = mHCLength; + break; + } + + // + if (mLength == 0) + { + return; + } + + // + // Find Highest High ... + double hhValue = bar.FindHighest( + mLength, + upperMode // + ); + hhBuffer[barIndex] = hhValue; + + // + // Find Lowest Low ... + double llValue = bar.FindLowest( + mLength, + lowerMode // + ); + llBuffer[barIndex] = llValue; + + // + bar.Clean(); +} + +// +// +// + +// +// Get Specified Bar Time as Double ... +double GetZigZagBarTime(int barIndex) +{ + // + if (barIndex <= 0) + { + barIndex = 0; + } + + // + datetime time = iTime(_Symbol, _Period, barIndex); + + // + double result = (double)((int)time); + + // + return result; +} + +// +// Filling Required Prices Based on MODE ... +int FillPrice( + ENUM_X_PRICE mode, + double &dest[], + const double &open[], + const double &high[], + const double &close[], + const double &low[] // +) +{ + // + int result = 0; + + // + SpecifiedClean(dest); + + // + if (!IsXValid(mode)) + { + return result; + } + + // + switch (mode) + { + // + case X_PRICE_HIGH: + // + result = ArrayCopy( + dest, + high // + ); + break; + + // + case X_PRICE_LOW: + // + result = ArrayCopy( + dest, + low // + ); + break; + + // + case X_PRICE_OPEN: + // + result = ArrayCopy( + dest, + open // + ); + break; + + // + case X_PRICE_CLOSE: + // + result = ArrayCopy( + dest, + close // + ); + break; + + // + default: + // + result = ArrayCopy( + dest, + close // + ); + break; + } + + // + return result; +} + +// +// Search for the index of the highest bar ... +int Highest( + const double &mArray[], + const int mDepth, + const int mStart // +) +{ + // + int result = 0; + + // + if (mStart < 0) + { + return result; + } + + // + double max = mArray[mStart]; + result = mStart; + + // + // Start searching ... + for (int i = mStart - 1; i > mStart - mDepth && i >= 0; i--) + { + // + if (mArray[i] > max) + { + // + result = i; + max = mArray[i]; + } + } + + // + // Return index of the highest bar + return result; +} + +// +// Search for the index of the lowest bar ... +int Lowest( + const double &mArray[], + const int mDepth, + const int mStart // +) +{ + // + int result = 0; + + // + if (mStart < 0) + { + return result; + } + + // + double min = mArray[mStart]; + result = mStart; + + // + // Start searching ... + for (int i = mStart - 1; i > mStart - mDepth && i >= 0; i--) + { + // + if (mArray[i] < min) + { + // + result = i; + min = mArray[i]; + } + } + + // + // Return index of the lowest bar + return result; +} + +// \ No newline at end of file diff --git a/Helpers/x-saherelm.xfima.helper.mq5 b/Helpers/x-saherelm.xfima.helper.mq5 index 73bb99a4..2f055088 100644 --- a/Helpers/x-saherelm.xfima.helper.mq5 +++ b/Helpers/x-saherelm.xfima.helper.mq5 @@ -1393,6 +1393,15 @@ class XCXFIMAHelper : public XCBaseHelper return result; } + /** + * Check for Fibo Push Exists or not ... + * + * @param dir: ENUM_X_DIRECTION, reference to hold result ... + * @param barIndex: int, Specified Bar Index ... + * @param validationLength: int, Validation Length ... + * + * @return ( bool ) + */ bool HasFiboPush( ENUM_X_DIRECTION &dir, int barIndex = 0, @@ -2946,6 +2955,236 @@ class XCXFIMAHelper : public XCBaseHelper return result; } + /** + * Detect Zones (Support / Resistance) based on XFIMA Validators ... + * + * @param zones: XBoxZone, reference to Collection for holding Detected Zones ... + * @param barIndex: int, Specified Start Looking Bar Index ... + * @param requiredNumberOfZones: int, Specified how many zones looking for ... + * @param shadowMultiplier: double, a valid zone's Shadow side multiplier ... + * @param maxAllowedLoopbackLength: int, Specified Max Allowed Looping back trhough Bars for Detection ... + * + * @return ( int ) + */ + int DetectXFIMAZones( + XBoxZone &zones[], + int barIndex = 0, + bool onlyValidZones = false, + int requiredNumberOfZones = 50, + double shadowMultiplier = 4, + int validationLength = 7, + int maxAllowedLoopbackLength = 1500 // + ) + { + // + int result = 0; + + // + // Prepare ... + XClean(zones); + + // + // Normalize ... + barIndex = NormalizeBarIndex(barIndex); + validationLength = NormalizeInt(validationLength, 3); + shadowMultiplier = NormalizeDouble(shadowMultiplier, 2); + requiredNumberOfZones = NormalizeInt(requiredNumberOfZones, 5); + maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50); + + // + // Validate ... + XOHCL bar; + bool has = IsValid() && + bar.Init( + mSymbol, + mPeriod, + barIndex + 1 // + ); + if (!has) + { + return result; + } + + // + // Define Requirements ... + XOHCL iBar; + XBoxZone iBox; + bool isBullish = false; + bool isBearish = false; + double iUpper = EMPTY_VALUE; + double iLower = EMPTY_VALUE; + double iHKUpper = EMPTY_VALUE; + double iHKLower = EMPTY_VALUE; + double iMAUpper = EMPTY_VALUE; + double iMALower = EMPTY_VALUE; + ENUM_X_DIRECTION iDir = X_DIRECTION_NONE; + + // + // Create a Loop to Detect Zones ... + int start = barIndex; + int idx = start - 1; + int end = start + maxAllowedLoopbackLength; + while (ArraySize(zones) < requiredNumberOfZones && idx < end) + { + // + idx++; + + // + // Initialize Indexed Bar ... + has = bar.BarAt(idx, iBar); + if (!has) + { + continue; + } + + // + // Reading Bars ... + iMAUpper = GetMABondUpper(idx); + iMALower = GetMABondLower(idx); + iHKUpper = GetHKBondUpper(idx); + iHKLower = GetHKBondLower(idx); + + // + iUpper = MathMax(iMAUpper, iHKUpper); + iLower = MathMin(iMALower, iHKLower); + + // + // Check Bar State ... + has = + NotEmptyZero(iUpper) && + NotEmptyZero(iLower); + if (!has) + { + continue; + } + + // + // Check Direction of Zone ... + isBullish = iBar.low < iLower; + isBearish = iBar.high > iUpper; + has = (isBullish && !isBearish) || + (isBearish && !isBullish); + if (!has) + { + continue; + } + + // + // Validate Price Based on Bar ... + // Validate Shadow Multiplier ... + has = + isBullish + ? iBar.low < bar.low + : iBar.high > bar.high; + has = + has && + (isBullish + ? iBar.GetLowShadow() > iBar.GetHighShadow() * shadowMultiplier + : iBar.GetHighShadow() > iBar.GetLowShadow() * shadowMultiplier); + if (!has) + { + continue; + } + + // + iDir = isBullish + ? X_DIRECTION_BULLISH + : X_DIRECTION_BEARISH; + + // + // Fill Bax ... + iBox.dir = iDir; + iBox.symbol = mSymbol; + iBox.period = mPeriod; + iBox.upper = + isBullish + ? iBar.GetDown() + : iBar.high; + iBox.lower = + isBullish + ? iBar.low + : iBar.GetUp(); + iBox.type = + (isBullish ? "XFIMSup" : "XFIMARes") + "_" + + ToXString(NormalizePrice(iBox.upper, iBox.symbol)) + "_" + + ToXString(NormalizePrice(iBox.lower, iBox.symbol)); + + // + iBox.at = iBar.time; + iBox.to = bar.time; + + // + // Loopback to Detect From Time ... + XOHCL pBar; + datetime fromTime = NULL; + has = iBar.GetPreviousBar(pBar); + if (has) + { + // + while (!IsXValid(fromTime)) + { + // + // Check Price Inside ... + has = + isBullish + ? pBar.GetDown() < iBox.lower + : pBar.GetUp() > iBox.upper; + if (has) + { + fromTime = pBar.time; + } + + // + // Retrieve PrevBar ... + has = pBar.GetPreviousBar(pBar); + if (!has) + { + break; + } + } + } + has = IsXValid(fromTime); + if (has) + { + iBox.from = fromTime; + } + + // + // Validate Zone Length ... + has = iBox.IsValid() && + (iBox.FromIndex() - iBox.AtIndex() >= validationLength); + if (has) + { + // + AddIfNotExists( + iBox, + zones // + ); + } + + // + // Cleanup Resources ... + iBar.Clean(); + pBar.Clean(); + iBox.Clean(); + } + + // + result = ArraySize(zones); + + // + // Cleanup Resources ... + if (!result) + { + XClean(zones); + } + iBar.Clean(); + iBox.Clean(); + + // + return result; + } + // // Values Retrievers ... diff --git a/Indicators/x-saherelm.xfima.mq5 b/Indicators/x-saherelm.xfima.mq5 index 217d07dc..0cb7e44a 100644 --- a/Indicators/x-saherelm.xfima.mq5 +++ b/Indicators/x-saherelm.xfima.mq5 @@ -83,7 +83,7 @@ input ENUM_MA_METHOD maMethod = MODE_EMA; // MA Method input ENUM_APPLIED_PRICE maAppliedTo = PRICE_CLOSE; // MA Applied To input int maFastLength = 7; // Fast MA Length input int maSlowLength = 21; // Slow MA Length -input int maBandLength = 21; // MA Bond Length +input int maBondLength = 21; // MA Bond Length input int zigzagDepth = 12; // ZigZag Depth input int zigzagDeviation = 5; // ZigZag Deviation input int zigzagBackStep = 3; // ZigZag Back Step @@ -101,7 +101,7 @@ input bool showHK = true; // Show HK input bool showSAR = true; // Show Sar input bool showMAFast = true; // Show MA Fast input bool showMASlow = true; // Show MA Slow -input bool showMABand = true; // Show MA Bond +input bool showMABond = true; // Show MA Bond input bool showHKBond = true; // Show HK Bond input bool showZigZag = true; // Show ZigZag input bool showFiboZone = true; // Show Fibo Zone @@ -138,8 +138,8 @@ input int valeArrowCode = 159; // Vales Arrow Code #property indicator_chart_window // -#property indicator_buffers 40 -#property indicator_plots 14 +#property indicator_buffers 44 +#property indicator_plots 16 // // Plot Buffers ... @@ -286,9 +286,9 @@ double zigzagBuffer[]; // MA Upper ... // -#define maUpperBufferIndex 12 -#define maUpperBufferPlotIndex 9 -double maUpperBuffer[]; +#define maBondUpperBufferIndex 12 +#define maBondUpperBufferPlotIndex 9 +double maBondUpperBuffer[]; // #property indicator_label10 "UpperMA" @@ -300,9 +300,9 @@ double maUpperBuffer[]; // MA Lower ... // -#define maLowerBufferIndex 13 -#define maLowerBufferPlotIndex 10 -double maLowerBuffer[]; +#define maBondLowerBufferIndex 13 +#define maBondLowerBufferPlotIndex 10 +double maBondLowerBuffer[]; // #property indicator_label11 "LowerMA" @@ -361,11 +361,39 @@ double hkBondLowerBuffer[]; #property indicator_color14 clrMagenta #property indicator_width14 3 +// +// PB Upper ... + +// +#define pbBondUpperBufferIndex 21 +double pbBondUpperBuffer[]; + +// +#define pbBondUpperBufferPlotIndex 14 +#property indicator_label15 "UpperPB" +#property indicator_type15 DRAW_LINE +#property indicator_color15 clrRoyalBlue +#property indicator_width15 3 + +// +// PB Lower ... + +// +#define pbBondLowerBufferIndex 22 +double pbBondLowerBuffer[]; + +// +#define pbBondLowerBufferPlotIndex 15 +#property indicator_label16 "LowerPB" +#property indicator_type16 DRAW_LINE +#property indicator_color16 clrOrangeRed +#property indicator_width16 3 + // // Data Buffers ... // -#define mLastBufferIndex 20 +#define mLastBufferIndex 22 // // MA ... @@ -470,6 +498,17 @@ double hkRawLowBuffer[]; #define hkRawCloseBufferIndex mLastBufferIndex + 19 double hkRawCloseBuffer[]; +// +// XPB Data ... + +// +#define pbBondRawUpperBufferIndex mLastBufferIndex + 20 +double pbBondRawUpperBuffer[]; + +// +#define pbBondRawLowerBufferIndex mLastBufferIndex + 21 +double pbBondRawLowerBuffer[]; + // // Variables, Properties and etc ... @@ -529,6 +568,9 @@ datetime lastZigZagPeakTime = NULL; double lastZigZagVale = 0; datetime lastZigZagValeTime = NULL; +// +ENUM_X_MA_METHOD iPBMethod = X_MA_MODE_NONE; + // // Event Handlers ... @@ -550,6 +592,10 @@ int OnInit() return INIT_PARAMETERS_INCORRECT; } + // + // Prepare Price Buffer Smoothing Method ... + iPBMethod = ToXMaMethod(maMethod); + // has = InitCycles(); if (!has) @@ -723,8 +769,8 @@ int OnCalculate( // MA ... int copiedMAFasts = CopyBuffer(maFastHandler, MAIN_LINE, 0, limit, maFastBuffer); int copiedMASlows = CopyBuffer(maSlowHandler, MAIN_LINE, 0, limit, maSlowBuffer); - int copiedMAUppers = CopyBuffer(maUpperHandler, MAIN_LINE, 0, limit, maUpperBuffer); - int copiedMALowers = CopyBuffer(maLowerHandler, MAIN_LINE, 0, limit, maLowerBuffer); + int copiedMAUppers = CopyBuffer(maUpperHandler, MAIN_LINE, 0, limit, maBondUpperBuffer); + int copiedMALowers = CopyBuffer(maLowerHandler, MAIN_LINE, 0, limit, maBondLowerBuffer); // // SAR ... @@ -800,7 +846,7 @@ bool ValidateInputs() // MA ... maFastLength >= 2 && maSlowLength >= 2 && - maBandLength >= 2 && + maBondLength >= 2 && maSlowLength > maFastLength && // // SAR ... @@ -847,7 +893,7 @@ int ExtractMaxLengthOfInputs() result = MathMax(result, mHCLength); result = MathMax(result, maFastLength); result = MathMax(result, maSlowLength); - result = MathMax(result, maBandLength); + result = MathMax(result, maBondLength); // return result; @@ -873,10 +919,6 @@ void DefineBuffers() ArraySetAsSeries(maFastColorBuffer, true); SetIndexBuffer(maFastColorBufferIndex, maFastColorBuffer, INDICATOR_COLOR_INDEX); - // - ArraySetAsSeries(maFastStateBuffer, true); - SetIndexBuffer(maFastStateBufferIndex, maFastStateBuffer, INDICATOR_CALCULATIONS); - // // Slow MA ... @@ -892,10 +934,6 @@ void DefineBuffers() ArraySetAsSeries(maSlowColorBuffer, true); SetIndexBuffer(maSlowColorBufferIndex, maSlowColorBuffer, INDICATOR_COLOR_INDEX); - // - ArraySetAsSeries(maSlowStateBuffer, true); - SetIndexBuffer(maSlowStateBufferIndex, maSlowStateBuffer, INDICATOR_CALCULATIONS); - // // SAR ... @@ -912,10 +950,6 @@ void DefineBuffers() ArraySetAsSeries(sarColorBuffer, true); SetIndexBuffer(sarColorBufferIndex, sarColorBuffer, INDICATOR_COLOR_INDEX); - // - ArraySetAsSeries(sarStateBuffer, true); - SetIndexBuffer(sarStateBufferIndex, sarStateBuffer, INDICATOR_CALCULATIONS); - // // PEAK / VALE ... @@ -1008,35 +1042,60 @@ void DefineBuffers() // MA Bond ... // - ENUM_DRAW_TYPE maBandDrawType = showMABand ? DRAW_LINE : DRAW_NONE; + ENUM_DRAW_TYPE maBondDrawType = showMABond ? DRAW_LINE : DRAW_NONE; // - // MA Upper Bond ... + // Upper Bond ... // - ArraySetAsSeries(maUpperBuffer, true); - SetIndexBuffer(maUpperBufferIndex, maUpperBuffer, INDICATOR_DATA); + ArraySetAsSeries(maBondUpperBuffer, true); + SetIndexBuffer(maBondUpperBufferIndex, maBondUpperBuffer, INDICATOR_DATA); // - PlotIndexSetInteger(maUpperBufferPlotIndex, PLOT_SHOW_DATA, showMABand); - PlotIndexSetInteger(maUpperBufferPlotIndex, PLOT_DRAW_TYPE, maBandDrawType); - - PlotIndexSetInteger(maUpperBufferPlotIndex, PLOT_DRAW_BEGIN, 0); - PlotIndexSetDouble(maUpperBufferPlotIndex, PLOT_EMPTY_VALUE, 0); + PlotIndexSetInteger(maBondUpperBufferPlotIndex, PLOT_SHOW_DATA, showMABond); + PlotIndexSetInteger(maBondUpperBufferPlotIndex, PLOT_DRAW_TYPE, maBondDrawType); + PlotIndexSetInteger(maBondUpperBufferPlotIndex, PLOT_DRAW_BEGIN, 0); + PlotIndexSetDouble(maBondUpperBufferPlotIndex, PLOT_EMPTY_VALUE, 0); // - // MA Lower Bond ... + // Lower Bond ... // - ArraySetAsSeries(maLowerBuffer, true); - SetIndexBuffer(maLowerBufferIndex, maLowerBuffer, INDICATOR_DATA); + ArraySetAsSeries(maBondLowerBuffer, true); + SetIndexBuffer(maBondLowerBufferIndex, maBondLowerBuffer, INDICATOR_DATA); // - PlotIndexSetInteger(maLowerBufferPlotIndex, PLOT_SHOW_DATA, showMABand); - PlotIndexSetInteger(maLowerBufferPlotIndex, PLOT_DRAW_TYPE, maBandDrawType); + PlotIndexSetInteger(maBondLowerBufferPlotIndex, PLOT_SHOW_DATA, showMABond); + PlotIndexSetInteger(maBondLowerBufferPlotIndex, PLOT_DRAW_TYPE, maBondDrawType); + PlotIndexSetInteger(maBondLowerBufferPlotIndex, PLOT_DRAW_BEGIN, 0); + PlotIndexSetDouble(maBondLowerBufferPlotIndex, PLOT_EMPTY_VALUE, 0); - PlotIndexSetInteger(maLowerBufferPlotIndex, PLOT_DRAW_BEGIN, 0); - PlotIndexSetDouble(maLowerBufferPlotIndex, PLOT_EMPTY_VALUE, 0); + // + // XPB Bond ... + + // + // Upper Bond ... + + // + ArraySetAsSeries(pbBondUpperBuffer, true); + SetIndexBuffer(pbBondUpperBufferIndex, pbBondUpperBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(pbBondUpperBufferPlotIndex, PLOT_SHOW_DATA, showMABond); + PlotIndexSetInteger(pbBondUpperBufferPlotIndex, PLOT_DRAW_TYPE, maBondDrawType); + PlotIndexSetDouble(pbBondUpperBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + + // + // Lower Bond ... + + // + ArraySetAsSeries(pbBondLowerBuffer, true); + SetIndexBuffer(pbBondLowerBufferIndex, pbBondLowerBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(pbBondLowerBufferPlotIndex, PLOT_SHOW_DATA, showMABond); + PlotIndexSetInteger(pbBondLowerBufferPlotIndex, PLOT_DRAW_TYPE, maBondDrawType); + PlotIndexSetDouble(pbBondLowerBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // XHK ... @@ -1073,20 +1132,44 @@ void DefineBuffers() // // XHK Bond ... + // + ENUM_DRAW_TYPE hkBondDrawType = showHKBond ? DRAW_LINE : DRAW_NONE; // // Upper ... ArraySetAsSeries(hkBondUpperBuffer, true); SetIndexBuffer(hkBondUpperBufferIndex, hkBondUpperBuffer, INDICATOR_DATA); + // + PlotIndexSetInteger(hkBondUpperBufferPlotIndex, PLOT_SHOW_DATA, showHKBond); + PlotIndexSetInteger(hkBondUpperBufferPlotIndex, PLOT_DRAW_TYPE, hkBondDrawType); + PlotIndexSetDouble(hkBondUpperBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + // // Lower ... ArraySetAsSeries(hkBondLowerBuffer, true); SetIndexBuffer(hkBondLowerBufferIndex, hkBondLowerBuffer, INDICATOR_DATA); + // + PlotIndexSetInteger(hkBondLowerBufferPlotIndex, PLOT_SHOW_DATA, showHKBond); + PlotIndexSetInteger(hkBondLowerBufferPlotIndex, PLOT_DRAW_TYPE, hkBondDrawType); + PlotIndexSetDouble(hkBondLowerBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); + // // Data Buffers ... + // + ArraySetAsSeries(maFastStateBuffer, true); + SetIndexBuffer(maFastStateBufferIndex, maFastStateBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(maSlowStateBuffer, true); + SetIndexBuffer(maSlowStateBufferIndex, maSlowStateBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(sarStateBuffer, true); + SetIndexBuffer(sarStateBufferIndex, sarStateBuffer, INDICATOR_CALCULATIONS); + // // CYCLES ... @@ -1095,44 +1178,44 @@ void DefineBuffers() // ArraySetAsSeries(sHHBuffer, true); - SetIndexBuffer(sHHBufferIndex, sHHBuffer, INDICATOR_DATA); + SetIndexBuffer(sHHBufferIndex, sHHBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(sLLBuffer, true); - SetIndexBuffer(sLLBufferIndex, sLLBuffer, INDICATOR_DATA); + SetIndexBuffer(sLLBufferIndex, sLLBuffer, INDICATOR_CALCULATIONS); // // MC ... // ArraySetAsSeries(mHHBuffer, true); - SetIndexBuffer(mHHBufferIndex, mHHBuffer, INDICATOR_DATA); + SetIndexBuffer(mHHBufferIndex, mHHBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(mLLBuffer, true); - SetIndexBuffer(mLLBufferIndex, mLLBuffer, INDICATOR_DATA); + SetIndexBuffer(mLLBufferIndex, mLLBuffer, INDICATOR_CALCULATIONS); // // LC ... // ArraySetAsSeries(lHHBuffer, true); - SetIndexBuffer(lHHBufferIndex, lHHBuffer, INDICATOR_DATA); + SetIndexBuffer(lHHBufferIndex, lHHBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(lLLBuffer, true); - SetIndexBuffer(lLLBufferIndex, lLLBuffer, INDICATOR_DATA); + SetIndexBuffer(lLLBufferIndex, lLLBuffer, INDICATOR_CALCULATIONS); // // HC ... // ArraySetAsSeries(hHHBuffer, true); - SetIndexBuffer(hHHBufferIndex, hHHBuffer, INDICATOR_DATA); + SetIndexBuffer(hHHBufferIndex, hHHBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(hLLBuffer, true); - SetIndexBuffer(hLLBufferIndex, hLLBuffer, INDICATOR_DATA); + SetIndexBuffer(hLLBufferIndex, hLLBuffer, INDICATOR_CALCULATIONS); // // Highs ... @@ -1149,19 +1232,30 @@ void DefineBuffers() // ArraySetAsSeries(hkRawHighBuffer, true); - SetIndexBuffer(hkRawHighBufferIndex, hkRawHighBuffer, INDICATOR_DATA); + SetIndexBuffer(hkRawHighBufferIndex, hkRawHighBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(hkRawOpenBuffer, true); - SetIndexBuffer(hkRawOpenBufferIndex, hkRawOpenBuffer, INDICATOR_DATA); + SetIndexBuffer(hkRawOpenBufferIndex, hkRawOpenBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(hkRawLowBuffer, true); - SetIndexBuffer(hkRawLowBufferIndex, hkRawLowBuffer, INDICATOR_DATA); + SetIndexBuffer(hkRawLowBufferIndex, hkRawLowBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(hkRawCloseBuffer, true); - SetIndexBuffer(hkRawCloseBufferIndex, hkRawCloseBuffer, INDICATOR_DATA); + SetIndexBuffer(hkRawCloseBufferIndex, hkRawCloseBuffer, INDICATOR_CALCULATIONS); + + // + // XPB Data ... + + // + ArraySetAsSeries(pbBondRawUpperBuffer, true); + SetIndexBuffer(pbBondRawUpperBufferIndex, pbBondRawUpperBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(pbBondRawLowerBuffer, true); + SetIndexBuffer(pbBondRawLowerBufferIndex, pbBondRawLowerBuffer, INDICATOR_CALCULATIONS); // } @@ -1328,7 +1422,7 @@ bool InitRequirements() maUpperHandler = iMA( _Symbol, _Period, - maBandLength, + maBondLength, 0, maMethod, PRICE_HIGH // @@ -1344,7 +1438,7 @@ bool InitRequirements() maLowerHandler = iMA( _Symbol, _Period, - maBandLength, + maBondLength, 0, maMethod, PRICE_LOW // @@ -1615,6 +1709,49 @@ void CalculateValues( fiboUpperBuffer[barIndex] = iFiboUp; fiboMiddleBuffer[barIndex] = iFiboMid; fiboLowerBuffer[barIndex] = iFiboLo; + + // + // XPB ... + + // + double iPBUpper = MathMax(close[barIndex], open[barIndex]); + double iPBLower = MathMin(close[barIndex], open[barIndex]); + + // + pbBondUpperBuffer[barIndex] = iPBUpper; + pbBondRawUpperBuffer[barIndex] = iPBUpper; + + // + pbBondLowerBuffer[barIndex] = iPBLower; + pbBondRawLowerBuffer[barIndex] = iPBLower; + + // + if (IsXValid(iPBMethod) && maBondLength > 0) + { + // + // XPB Upper ... + iMAOnBuffer( + ratesTotal, + prevCalculated, + barIndex, + maBondLength, + pbBondRawUpperBuffer, + pbBondUpperBuffer, + iPBMethod // + ); + + // + // XPB Lower ... + iMAOnBuffer( + ratesTotal, + prevCalculated, + barIndex, + maBondLength, + pbBondRawLowerBuffer, + pbBondLowerBuffer, + iPBMethod // + ); + } } // diff --git a/Libraries/x-saherelm.x-enums.lib.mq5 b/Libraries/x-saherelm.x-enums.lib.mq5 index 343c63fa..4d96a7d0 100644 --- a/Libraries/x-saherelm.x-enums.lib.mq5 +++ b/Libraries/x-saherelm.x-enums.lib.mq5 @@ -1361,6 +1361,80 @@ string ToXString(ENUM_X_MA_METHOD value) return ToString(value); } +/** + * Converts MA Method ... + **/ +ENUM_MA_METHOD ToXMaMethod(ENUM_X_MA_METHOD value) +{ + // + ENUM_MA_METHOD result = MODE_SMA; + + // + if (!IsXValid(value)) + { + return result; + } + + // + switch (value) + { + // + case X_MA_MODE_EMA: + result = MODE_EMA; + break; + + // + case X_MA_MODE_SMA: + result = MODE_SMA; + break; + + // + case X_MA_MODE_LWMA: + result = MODE_LWMA; + break; + + // + case X_MA_MODE_SMMA: + result = MODE_SMMA; + break; + } + + // + return result; +} +ENUM_X_MA_METHOD ToXMaMethod(ENUM_MA_METHOD value) +{ + // + ENUM_X_MA_METHOD result = X_MA_MODE_NONE; + + // + switch (value) + { + // + case MODE_EMA: + result = X_MA_MODE_EMA; + break; + + // + case MODE_SMA: + result = X_MA_MODE_SMA; + break; + + // + case MODE_LWMA: + result = X_MA_MODE_LWMA; + break; + + // + case MODE_SMMA: + result = X_MA_MODE_SMMA; + break; + } + + // + return result; +} + // // END Ma Methods ... // diff --git a/Libraries/x-saherelm.x-poi.lib.mq5 b/Libraries/x-saherelm.x-poi.lib.mq5 index cdea57f2..48ab8708 100644 --- a/Libraries/x-saherelm.x-poi.lib.mq5 +++ b/Libraries/x-saherelm.x-poi.lib.mq5 @@ -946,6 +946,77 @@ struct XBoxZone return result; } + /** + * At Bar Index ... + * + * @return ( int ) + */ + int AtIndex( + ENUM_TIMEFRAMES forPeriod = NULL // + ) + { + // + int result = -1; + + // + if (!IsValid() || !IsXValid(at)) + { + return result; + } + + // + if (!IsSpecifiedValid(forPeriod)) + { + forPeriod = period; + } + + // + result = GetBarIndex( + symbol, + forPeriod, + at // + ); + + // + return result; + } + + /** + * Retrieve At Bar ... + * + * @return ( bool ) + */ + bool AtBar(XOHCL &bar) + { + // + bool result = false; + + // + bar.Clean(); + + // + int idx = AtIndex(); + + // + result = + IsValid() && + IsValidIndex(idx); + if (!result) + { + return result; + } + + // + result = bar.Init( + symbol, + period, + idx // + ); + + // + return result; + } + /** * From Bar Index ... * diff --git a/XFIMAEA/Classes/x-saherelm.xfima.signaller.class.mq5 b/XFIMAEA/Classes/x-saherelm.xfima.signaller.class.mq5 index 991c0342..0d2bdaa3 100644 --- a/XFIMAEA/Classes/x-saherelm.xfima.signaller.class.mq5 +++ b/XFIMAEA/Classes/x-saherelm.xfima.signaller.class.mq5 @@ -639,20 +639,49 @@ class XCXFIMAStrategy1Signaller : public XCXFIMABaseSignaller // // Detecte Fibo Section Changes ... - // - has = fimaHelper.IsFiboSectionChanged(iDir, iBar.Index()); - has = has && - IsXBullish(iDir) && - fimaHelper.IsValeOverLast(iBar.Index()); + // // + // has = fimaHelper.IsFiboSectionChanged(iDir, iBar.Index()); + // has = has && + // IsXBullish(iDir) && + // fimaHelper.IsValeOverLast(iBar.Index()); + + // // + // has = fimaHelper.IsFiboSectionChanged(iDir, iBar.Index()); + // has = has && + // IsXBearish(iDir) && + // fimaHelper.IsPeakUnderLast(iBar.Index()); + + // // + // has = fimaHelper.HasFiboPush(iDir, iBar.Index(), 5); // - has = fimaHelper.IsFiboSectionChanged(iDir, iBar.Index()); - has = has && - IsXBearish(iDir) && - fimaHelper.IsPeakUnderLast(iBar.Index()); - - // - has = fimaHelper.HasFiboPush(iDir, iBar.Index(), 5); + XBoxZone fimaZones[]; + int fimaZonesCount = fimaHelper.DetectXFIMAZones( + fimaZones, + iBar.Index(), + true, // Only Valid Zones ... + 50, // Number of Zones ... + 5, // Shadow Multiplier ... + 500 // Loopback + ); + has = IsValidSize(fimaZonesCount); + if (has) + { + // + // Draw Detected Zones ... + CArrayObj zoneObjects; + for (int i = 0; i < fimaZonesCount; i++) + { + // + XCBoxObject *iObj; + has = poiDrawer.DrawBox( + fimaZones[i], + iObj, + false, // Ignore At ... + fimaZones[i].type // Specified Name ... + ); + } + } // if (has) diff --git a/XFIMAEA/Classes/x-saherelm.xfima.x-poi.detector.class.mq5 b/XFIMAEA/Classes/x-saherelm.xfima.x-poi.detector.class.mq5 index 7f596944..db3977a9 100644 --- a/XFIMAEA/Classes/x-saherelm.xfima.x-poi.detector.class.mq5 +++ b/XFIMAEA/Classes/x-saherelm.xfima.x-poi.detector.class.mq5 @@ -476,138 +476,6 @@ class XCXFIMAPOIDetector : public XCMarketPatternDetector return result; } - int ExtractXFIMAZones( - XBoxZone &zones[], - int barIndex = 0, - int requiredNumberOfZones = 50, - double shadowMultiplier = 4, - int maxAllowedLoopbackLength = 1500 // - ) - { - // - int result = 0; - - // - // Prepare ... - XClean(zones); - - // - // Normalize ... - barIndex = NormalizeInt(barIndex, 0); - shadowMultiplier = NormalizeDouble(shadowMultiplier, 2); - requiredNumberOfZones = NormalizeInt(requiredNumberOfZones, 5); - maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50); - - // - // Validate ... - bool has = - fimaHelper != NULL && - fimaHelper.IsValid(); - if (!has) - { - return result; - } - - // - // Create a Loop ... - XOHCL iBar; - XBoxZone iBox; - bool isBullish = false; - bool isBearish = false; - double iUpper = EMPTY_VALUE; - double iLower = EMPTY_VALUE; - double iHKUpper = EMPTY_VALUE; - double iHKLower = EMPTY_VALUE; - double iMAUpper = EMPTY_VALUE; - double iMALower = EMPTY_VALUE; - string symbol = fimaHelper.GetSymbol(); - ENUM_X_DIRECTION iDir = X_DIRECTION_NONE; - ENUM_TIMEFRAMES period = fimaHelper.GetPeriod(); - - // - int start = barIndex; - int idx = start - 1; - int end = start + maxAllowedLoopbackLength; - while (ArraySize(zones) < requiredNumberOfZones && idx < end) - { - // - idx++; - - // - // Initialize Indexed Bar ... - has = iBar.Init( - symbol, - period, - idx // - ); - if (!has) - { - continue; - } - - // - // Reading Bars ... - iMAUpper = fimaHelper.GetMABondUpper(idx); - iMALower = fimaHelper.GetMABondLower(idx); - iHKUpper = fimaHelper.GetHKBondUpper(idx); - iHKLower = fimaHelper.GetHKBondLower(idx); - - // - iUpper = MathMax(iMAUpper, iHKUpper); - iLower = MathMin(iMALower, iHKLower); - - // - // Check Bar State ... - has = - NotEmptyZero(iUpper) && - NotEmptyZero(iLower); - if (!has) - { - continue; - } - - // - // Check Direction of Zone ... - isBullish = iBar.low < iLower; - isBearish = iBar.high > iUpper; - has = (isBullish && !isBearish) || - (isBearish && !isBullish); - if (!has) - { - continue; - } - - // - // Validate Shadow Multiplier ... - has = - isBullish - ? iBar.GetLowShadow() > iBar.GetHighShadow() * shadowMultiplier - : iBar.GetHighShadow() > iBar.GetLowShadow() * shadowMultiplier; - if (!has) - { - continue; - } - - // - iDir = isBullish - ? X_DIRECTION_BULLISH - : X_DIRECTION_BEARISH; - - // - - // - // Cleanup Resources ... - iBar.Clean(); - iBox.Clean(); - } - - // - result = ArraySize(zones); - - // - return result; - } - /** * Destroy ... */