/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Indicator // ------------------------------------------------- // Name: X121 XCATB // Description: Integrates All Requirements inside // this indicator for analyse Markets to // Detect Trigger Blocks ... // // - HK Bars; // - ATR Band; // - Signal Bars; // - Parabolic Sar; // - HK Signal Bars; // - Peaks and Vales; // - Peaks and Vales Goldens; // - Trending Average Prices; // // - ATR; // - RSI; // - ADX; // - DELTA; // - VOLUME; // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... #property copyright "Copyright 2023, SaherElm IT Center" #property link "https://saherelm.ir" #property version "1.00" #property description "SaherElm X121 XCATB Indicator" #property icon "../Images/SaherElm_Logo_Color.ico" #property strict // // Definitions ... // #define ShortName "X121 XCATB" // // Imports ... #include "../Classes/x-saherelm.x-bar.analyser.class.mq5" #include "../Classes/x-saherelm.x-poi.drawer.class.mq5" #include "../Libraries/x-saherelm.common.lib.mq5" // // Inputs ... // input group "Market"; // // Short ... input ENUM_X_PERIOD_METHOD scMethod = X_PERIOD_AUTO; // How to Find Short Period input ENUM_TIMEFRAMES scPeriod = NULL; // Short Period // // Medium ... input ENUM_X_PERIOD_METHOD mcMethod = X_PERIOD_AUTO; // How to Find Medium Period input ENUM_TIMEFRAMES mcPeriod = NULL; // Medium Period // // Long ... input ENUM_X_PERIOD_METHOD lcMethod = X_PERIOD_AUTO; // How to Find Long Period input ENUM_TIMEFRAMES lcPeriod = NULL; // Long Period // // Hind ... input ENUM_X_PERIOD_METHOD hcMethod = X_PERIOD_AUTO; // How to Find Hind Period input ENUM_TIMEFRAMES hcPeriod = NULL; // Hind Period // // Select Trending Cycle ... // this Cycle Used for All Calculations ... input ENUM_X_MARKET_CYCLES appliedCycle = X_MARKET_CYCLE_HIND; // Applied Cycle // // Presentation ... input group "Presentation"; input bool showBars = true; // Show Bars input bool showKI = false; // Show KI input bool showPV = false; // Show PV input bool showPVGolden = false; // Show PV Golden input bool showSar = false; // Show Sar input bool showTrend = false; // Show Trend input bool showATRBand = false; // Show ATR Band input bool showSignalBars = false; // Show Signal Bars input bool showHKSignalBars = false; // Show Hiken Ashi Signal Bars // input int startCalculationForLastBars = 1500; // Calculate Last n Bars // // Non Inputs ... double sarStep = 0.02; // Step double sarMax = 0.2; // Maximum double rsiOBLevel = 70.0; // RSI OB Level double rsiOSLevel = 30.0; // RSI OS Level double adxThreshold = 25.0; // ADX Threshold int kiLength = 144; // KI Length int sarArrowCode = 159; // Parabolic Sar Arrow Code int peakArrowCode = 159; // Peaks Arrow Code int valeArrowCode = 159; // Vales Arrow Code double atrMultiplier = 1.5; // ATR Band Multiplier bool showShortCycle = false; // Show Short Cycle Range bool showMediumCycle = false; // Show Medium Cycle Range bool showLongCycle = false; // Show Long Cycle Range bool showHindCycle = false; // Show Hind Cycle Range ENUM_MA_METHOD trendMode = MODE_SMA; // Trend Mode ENUM_SERIESMODE upperMode = MODE_HIGH; // Peak Method ENUM_SERIESMODE lowerMode = MODE_LOW; // Vale Method ENUM_X_PRICE atrUpperPriceType = X_PRICE_HIGH; // ATR Upper Zone Applied To ENUM_X_PRICE atrLowerPriceType = X_PRICE_LOW; // ATR Lower Zone Applied To ENUM_APPLIED_PRICE rsiAppliedTo = PRICE_CLOSE; // RSI Applied To ENUM_APPLIED_PRICE trendAppliedTo = PRICE_MEDIAN; // Trend Applied To ENUM_X_MA_METHOD atrSignalMethod = X_MA_MODE_EMA; // ATR Signalling Method ENUM_X_MA_METHOD barsSignalMethod = X_MA_MODE_EMA; // Bars Signalling Method ENUM_X_MA_METHOD deltaSignalMethod = X_MA_MODE_EMA; // Delta Signalling Method ENUM_X_MA_METHOD hkSignalBarMethod = X_MA_MODE_EMA; // Hiken Ashi Signal Method ENUM_X_MA_METHOD volumeSignalMethod = X_MA_MODE_EMA; // Volume Signalling Method // #define hideColorIDX 0 #define bullishColorIDX 1 #define bearishColorIDX 2 #define neuturalColorIDX 3 // #define bullishState 1 #define neuturalState 0 #define bearishState -1 // #define emptyValue 0.0 // // Buffers ... // #property indicator_chart_window // // Plot: 18 // Color: 4 // Bar: 8 // Data Buffer: 29 #property indicator_buffers 50 #property indicator_plots 19 // // Plot Buffers ... // // SAR ... // #define sarBufferIndex 0 #define sarBufferPlotIndex 0 double sarBuffer[]; // #define sarColorBufferIndex 1 double sarColorBuffer[]; // #property indicator_label1 "SAR" #property indicator_type1 DRAW_COLOR_ARROW #property indicator_color1 CLR_NONE, clrLime, clrRed, clrGray #property indicator_width1 2 // // PEAKS ... // #define peakBufferIndex 2 #define peakBufferPlotIndex 1 double peakBuffer[]; // #property indicator_label2 "PEAK" #property indicator_type2 DRAW_ARROW #property indicator_color2 clrMagenta #property indicator_width2 1 // // VALES ... // #define valeBufferIndex 3 #define valeBufferPlotIndex 2 double valeBuffer[]; // #property indicator_label3 "VALE" #property indicator_type3 DRAW_ARROW #property indicator_color3 clrAqua #property indicator_width3 1 // // PEAKS Golden ... // #define peakGoldenBufferIndex 4 #define peakGoldenBufferPlotIndex 3 double peakGoldenBuffer[]; // #property indicator_label4 "PEAK Golden" #property indicator_type4 DRAW_LINE #property indicator_color4 clrMagenta #property indicator_style4 STYLE_DOT #property indicator_width4 1 // // VALE Golden ... // #define valeGoldenBufferIndex 5 #define valeGoldenBufferPlotIndex 4 double valeGoldenBuffer[]; // #property indicator_label5 "VALES Golden" #property indicator_type5 DRAW_LINE #property indicator_color5 clrAqua #property indicator_style5 STYLE_DOT #property indicator_width5 1 // // ATR ... // // Upper ... // #define atrUpperBufferIndex 6 #define atrUpperBufferPlotIndex 5 double atrUpperBuffer[]; // #property indicator_label6 "XATRU" #property indicator_type6 DRAW_LINE #property indicator_color6 clrYellow #property indicator_style6 STYLE_SOLID #property indicator_width6 1 // // Lower ... // #define atrLowerBufferIndex 7 #define atrLowerBufferPlotIndex 6 double atrLowerBuffer[]; // #property indicator_label7 "XATRL" #property indicator_type7 DRAW_LINE #property indicator_color7 clrYellow #property indicator_style7 STYLE_SOLID #property indicator_width7 1 // // TREND ... // #define trendBufferIndex 8 #define trendBufferPlotIndex 7 double trendBuffer[]; // #define trendColorBufferIndex 9 double trendColorBuffer[]; // #property indicator_label8 "Trend" #property indicator_type8 DRAW_COLOR_LINE #property indicator_color8 CLR_NONE, clrAqua, clrMagenta, clrGray #property indicator_style8 STYLE_SOLID #property indicator_width8 2 // // Signal Bar ... // #define sBarOpenBufferIndex 10 double sBarOpenBuffer[]; // #define sBarHighBufferIndex 11 double sBarHighBuffer[]; // #define sBarLowBufferIndex 12 double sBarLowBuffer[]; // #define sBarCloseBufferIndex 13 double sBarCloseBuffer[]; // #define sBarColorBufferIndex 14 double sBarColorBuffer[]; // #define sBarBufferPlotIndex 8 #property indicator_label9 "XSGB Open;XSGB High;XSGB Low;XSGB Close" #property indicator_type9 DRAW_COLOR_CANDLES #property indicator_color9 CLR_NONE, clrLime, clrRed // // XHK SIGNAL ... // #define hkSBarOpenBufferIndex 15 double hkSBarOpenBuffer[]; // #define hkSBarHighBufferIndex 16 double hkSBarHighBuffer[]; // #define hkSBarLowBufferIndex 17 double hkSBarLowBuffer[]; // #define hkSBarCloseBufferIndex 18 double hkSBarCloseBuffer[]; // #define hkSBarColorBufferIndex 19 double hkSBarColorBuffer[]; // #define hkSBarBufferPlotIndex 9 #property indicator_label10 "XHKSGB Open;XHKSGB High;XHKSGB Low;XHKSGB Close" #property indicator_type10 DRAW_COLOR_CANDLES #property indicator_color10 CLR_NONE, clrAqua, clrMagenta // // CYCLES Range ... // // SHORT ... // #define sHHBufferIndex 20 #define sHHBufferPlotIndex 10 double sHHBuffer[]; // #property indicator_label11 "SH" #property indicator_type11 DRAW_LINE #property indicator_color11 clrGray #property indicator_style11 STYLE_DOT #property indicator_width11 1 // #define sLLBufferIndex 21 #define sLLBufferPlotIndex 11 double sLLBuffer[]; // #property indicator_label12 "SL" #property indicator_type12 DRAW_LINE #property indicator_color12 clrGray #property indicator_style12 STYLE_DOT #property indicator_width12 1 // // MEDIUM ... // #define mHHBufferIndex 22 #define mHHBufferPlotIndex 12 double mHHBuffer[]; // #property indicator_label13 "MH" #property indicator_type13 DRAW_LINE #property indicator_color13 clrIndigo #property indicator_style13 STYLE_DOT #property indicator_width13 1 // #define mLLBufferIndex 23 #define mLLBufferPlotIndex 13 double mLLBuffer[]; // #property indicator_label14 "ML" #property indicator_type14 DRAW_LINE #property indicator_color14 clrIndigo #property indicator_style14 STYLE_DOT #property indicator_width14 1 // // LONG ... // #define lHHBufferIndex 24 #define lHHBufferPlotIndex 14 double lHHBuffer[]; // #property indicator_label15 "LH" #property indicator_type15 DRAW_LINE #property indicator_color15 clrGoldenrod #property indicator_style15 STYLE_DOT #property indicator_width15 1 // #define lLLBufferIndex 25 #define lLLBufferPlotIndex 15 double lLLBuffer[]; // #property indicator_label16 "LL" #property indicator_type16 DRAW_LINE #property indicator_color16 clrGoldenrod #property indicator_style16 STYLE_DOT #property indicator_width16 1 // // HIND ... // #define hHHBufferIndex 26 #define hHHBufferPlotIndex 16 double hHHBuffer[]; // #property indicator_label17 "HH" #property indicator_type17 DRAW_LINE #property indicator_color17 clrBrown #property indicator_style17 STYLE_DOT #property indicator_width17 1 // #define hLLBufferIndex 27 #define hLLBufferPlotIndex 17 double hLLBuffer[]; // #property indicator_label18 "HL" #property indicator_type18 DRAW_LINE #property indicator_color18 clrBrown #property indicator_style18 STYLE_DOT #property indicator_width18 1 // // KI ... // #define kiBufferIndex 28 #define kiBufferPlotIndex 18 double kiBuffer[]; // #define kiColorBufferIndex 29 double kiColorBuffer[]; // #property indicator_label19 "KI" #property indicator_type19 DRAW_COLOR_LINE #property indicator_color19 CLR_NONE, clrGreen, clrRed, clrGray #property indicator_style19 STYLE_DASHDOTDOT #property indicator_width19 2 // // Data Buffers ... // #define mLastBufferIndex 29 // // SAR ... // #define sarStateBufferIndex mLastBufferIndex + 1 double sarStateBuffer[]; // // TREND State ... // #define trendStateBufferIndex mLastBufferIndex + 2 double trendStateBuffer[]; // // RSI ... // #define rsiBufferIndex mLastBufferIndex + 3 double rsiBuffer[]; // // ADX ... // #define adxBufferIndex mLastBufferIndex + 4 double adxBuffer[]; // #define adxpBufferIndex mLastBufferIndex + 5 double adxpBuffer[]; // #define adxnBufferIndex mLastBufferIndex + 6 double adxnBuffer[]; // // DELTA ... // #define deltaBufferIndex mLastBufferIndex + 7 double deltaBuffer[]; // #define deltaSignalBufferIndex mLastBufferIndex + 8 double deltaSignalBuffer[]; // // VOLUMES ... // #define bullishVolumeBufferIndex mLastBufferIndex + 9 double bullishVolumeBuffer[]; // #define bearishVolumeBufferIndex mLastBufferIndex + 10 double bearishVolumeBuffer[]; // #define bullishVolumeSignalBufferIndex mLastBufferIndex + 11 double bullishVolumeSignalBuffer[]; // #define bearishVolumeSignalBufferIndex mLastBufferIndex + 12 double bearishVolumeSignalBuffer[]; // // ATR ... // #define atrBufferIndex mLastBufferIndex + 13 double atrBuffer[]; // #define atrUpperRawBufferIndex mLastBufferIndex + 14 double atrUpperRawBuffer[]; // #define atrLowerRawBufferIndex mLastBufferIndex + 15 double atrLowerRawBuffer[]; // // HK ... // #define openHKBufferIndex mLastBufferIndex + 16 double openHKBuffer[]; // #define highHKBufferIndex mLastBufferIndex + 17 double highHKBuffer[]; // #define lowHKBufferIndex mLastBufferIndex + 18 double lowHKBuffer[]; // #define closeHKBufferIndex mLastBufferIndex + 19 double closeHKBuffer[]; // // KI ... // #define kiStateBufferIndex mLastBufferIndex + 20 double kiStateBuffer[]; // // Variables, Properties and etc ... // int limit; // int maxLength; // int firstBarIndex; // // Bars Color Variables ... color _upColor = clrLime; color _downColor = clrRed; color _lineColor = clrLime; color _bullishColor = clrLime; color _bearishColor = clrRed; // // XMarketCycle sc; int mSCLength = 0; ENUM_TIMEFRAMES mSCPeriod = NULL; // // XMarketCycle mc; int mMCLength = 0; ENUM_TIMEFRAMES mMCPeriod = NULL; // // XMarketCycle lc; int mLCLength = 0; ENUM_TIMEFRAMES mLCPeriod = NULL; // // XMarketCycle hc; int mHCLength = 0; ENUM_TIMEFRAMES mHCPeriod = NULL; // // Applied Cycle ... int mAppliedLength; ENUM_TIMEFRAMES mAppliedPeriod = NULL; // // Handlers ... int atrHandler = INVALID_HANDLE; int sarHandler = INVALID_HANDLE; int rsiHandler = INVALID_HANDLE; int adxHandler = INVALID_HANDLE; int trendHandler = INVALID_HANDLE; // CArrayObj mObjects; XCPOIDrawer *mDrawer; XCBarAnalyser *mBarAnalyser; // // Conditions Variables ... // // Temparory ... int mCount = 0; XSignal mSignal; bool mHas = false; XBoxZone mSignalBox; ENUM_X_DIRECTION mDir; bool mHasSignal = false; bool mIsBullish = false; bool mIsBearish = false; XDirectionShift mDirShift; string mArrowNamePrefix = NULL; // // Signals ... // bool mDrawSignals = false; bool mDrawSignalBoxes = false; bool mDrawSignalArrows = true; bool mDrawSignalBoxAtLines = false; // int _bullishArrowCode = 225; int _bearishArrowCode = 226; // color _bullishArrowColor = clrLime; color _bearishArrowColor = clrRed; // XPOIStyle mBullishSignalBoxStyle; XPOIStyle mBearishSignalBoxStyle; // ENUM_ARROW_ANCHOR mBullishAnchor = ANCHOR_TOP; ENUM_ARROW_ANCHOR mBearishAnchor = ANCHOR_BOTTOM; // // POI(s) ... // // Liquidities ... bool mDrawLiquidities = false; bool mDetectLiquidities = true; XBoxZone mBullishLiquidities[]; XBoxZone mBearishLiquidities[]; XPOIStyle mBullishLiquidityStyle; XPOIStyle mBearishLiquidityStyle; // // Range Breakes ... bool mDrawRangeBreakes = false; bool mDetectRangeBreakes = true; XBoxZone mBullishRangeBreakes[]; XBoxZone mBearishRangeBreakes[]; XPOIStyle mBullishRangeBreakStyle; XPOIStyle mBearishRangeBreakStyle; // // Counters ... // int mSameSBCount = 0; int mSameBullishSBCount = 0; int mSameBearishSBCount = 0; // int mSameKICount = 0; int mSameBullishKICount = 0; int mSameBearishKICount = 0; // int mSameHKSCount = 0; int mSameBullishHKSCount = 0; int mSameBearishHKSCount = 0; // int mSameSarCount = 0; int mSameBullishSarCount = 0; int mSameBearishSarCount = 0; // int mSameTrendCount = 0; int mSameBullishTrendCount = 0; int mSameBearishTrendCount = 0; // int mSamePeakCount = 0; int mSameValeCount = 0; int mSamePeakGoldenCount = 0; int mSameValeGoldenCount = 0; // double mSamePeakGoldenMin = 0; double mSamePeakGoldenMax = 0; double mSameValeGoldenMin = 0; double mSameValeGoldenMax = 0; // // Direction Shift ... // XDirectionShift mBullishKIChanges[]; XDirectionShift mBearishKIChanges[]; // XDirectionShift mBullishSBChanges[]; XDirectionShift mBearishSBChanges[]; // XDirectionShift mBullishHKSChanges[]; XDirectionShift mBearishHKSChanges[]; // XDirectionShift mBullishSarChanges[]; XDirectionShift mBearishSarChanges[]; // XDirectionShift mBullishTrendChanges[]; XDirectionShift mBearishTrendChanges[]; // // Liquidities ... // bool isLiquidity = false; bool isBullishLiquidity = false; bool isBearishLiquidity = false; // // Trigger Bars Conditions ... // bool isTriggerBarCond1 = false; bool isTriggerBarCond1Bullish = false; bool isTriggerBarCond1Bearish = false; // bool isTriggerBarCond2 = false; bool isTriggerBarCond2Bullish = false; bool isTriggerBarCond2Bearish = false; // bool isTriggerBarCond3 = false; bool isTriggerBarCond3Bullish = false; bool isTriggerBarCond3Bearish = false; // bool isTriggerBarCond4 = false; bool isTriggerBarCond4Bullish = false; bool isTriggerBarCond4Bearish = false; // bool isTriggerBarCond5 = false; bool isTriggerBarCond5Bullish = false; bool isTriggerBarCond5Bearish = false; // bool isTriggerBarCond6 = false; bool isTriggerBarCond6Bullish = false; bool isTriggerBarCond6Bearish = false; // bool isTriggerBarCond7 = false; bool isTriggerBarCond7Bullish = false; bool isTriggerBarCond7Bearish = false; // // Summarizing Trigger Bar ... bool isTriggerBar = false; bool isTriggerBarBullish = false; bool isTriggerBarBearish = false; // // XPV ... // bool isSamePeak = false; bool isSamePeakP = false; // bool isSameVale = false; bool isSameValeP = false; // bool isPeakOverLast = false; bool isPeakUnderLast = false; // bool isValeOverLast = false; bool isValeUnderLast = false; // bool isSamePeakOverLast = false; bool isSamePeakUnderLast = false; // bool isSameValeOverLast = false; bool isSameValeUnderLast = false; // bool isSamePeakGolden = false; bool isSamePeakGoldenP = false; // bool isSameValeGolden = false; bool isSameValeGoldenP = false; // bool isPeakGoldenOverLast = false; bool isPeakGoldenUnderLast = false; // bool isValeGoldenOverLast = false; bool isValeGoldenUnderLast = false; // bool isSamePeakGoldenOverLast = false; bool isSamePeakGoldenUnderLast = false; // bool isSameValeGoldenOverLast = false; bool isSameValeGoldenUnderLast = false; // // XSAR ... // bool isSarBullish = false; bool isSarBullishP = false; // bool isSarBearish = false; bool isSarBearishP = false; // bool isSarSwitchedToBullish = false; bool isSarSwitchedToBearish = false; // bool isBullishSarBreakedLast = false; bool isBearishSarBreakedLast = false; // // XSB ... // double mSBMax = 0; double mSBMin = 0; // double mSBPMax = 0; double mSBPMin = 0; // bool isSBBullish = false; bool isSBBullishP = false; // bool isSBBearish = false; bool isSBBearishP = false; // bool isSBSwitchedToBullish = false; bool isSBSwitchedToBearish = false; // bool isBullishSBBreakedLast = false; bool isBearishSBBreakedLast = false; // // XHKS ... // double mHKSMax = 0; double mHKSMin = 0; // double mHKSPMax = 0; double mHKSPMin = 0; // bool isHKSBullish = false; bool isHKSBullishP = false; // bool isHKSBearish = false; bool isHKSBearishP = false; // bool isHKSSwitchedToBullish = false; bool isHKSSwitchedToBearish = false; // bool isBullishHKSBreakedLast = false; bool isBearishHKSBreakedLast = false; // // XKI ... // bool isKIBullish = false; bool isKIBullishP = false; // bool isKIBearish = false; bool isKIBearishP = false; // bool isSameKI = false; bool isSameBullishKI = false; bool isSameBearishKI = false; // bool isKISwitchedToBullish = false; bool isKISwitchedToBearish = false; // bool isBullishKIBreakedLast = false; bool isBearishKIBreakedLast = false; // // XTREND ... // bool isTrendBullish = false; bool isTrendBullishP = false; // bool isTrendBearish = false; bool isTrendBearishP = false; // bool isTrendSwitchedToBullish = false; bool isTrendSwitchedToBearish = false; // bool isBullishTrendBreakedLast = false; bool isBearishTrendBreakedLast = false; // // Event Handlers ... /** * Initialize Indicator ... * * @return ( int ) */ int OnInit() { // bool has = false; // ReadBarStyle(); // // Validate Inputs ... has = ValidateInputs(); if (!has) { return INIT_PARAMETERS_INCORRECT; } // has = InitCycles(); if (!has) { return INIT_FAILED; } // // because in some cases we may have more than one input for // calculation and we must prevent any calculation // untill we pass the biggest input length, here we get max Input length // and then wait until pass it ... maxLength = ExtractMaxLengthOfInputs(); // // Initial Requirements ... has = InitRequirements(); if (!has) { return INIT_FAILED; } // if (showBars) { ShowBars(); } else { HideBars(); } // // Define Index Buffers ... DefineBuffers(); // // Set Indicator ShortName ... SetIndicatorName(); // // Initial Requirements ... mDrawer = new XCPOIDrawer(); mBarAnalyser = new XCBarAnalyser(); // // Preparing Styles ... // // Signals ... // // Bullish ... mBullishSignalBoxStyle.width = 1; mBullishSignalBoxStyle.clr = clrAqua; mBullishSignalBoxStyle.style = STYLE_DOT; // // Bearish ... mBearishSignalBoxStyle.width = 1; mBearishSignalBoxStyle.style = STYLE_DOT; mBearishSignalBoxStyle.clr = clrMagenta; // // Liquidities ... // // Bullish ... mBullishLiquidityStyle.width = 1; mBullishLiquidityStyle.clr = clrLime; // // Bearish ... mBearishLiquidityStyle.width = 1; mBearishLiquidityStyle.clr = clrRed; // // Range Breakes ... // // Bullish ... mBullishRangeBreakStyle.width = 1; mBullishRangeBreakStyle.clr = clrAqua; // // Bearish ... mBearishRangeBreakStyle.width = 1; mBearishRangeBreakStyle.clr = clrMagenta; // // Init Succeed ... return INIT_SUCCEEDED; // } /** * De Initialize Indicator ... * * @param reason: Integer, De Initialization Reason ... */ void OnDeinit(const int reason) { // // REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function // REASON_REMOVE 1 Program removed from a chart // REASON_RECOMPILE 2 Program recompiled // REASON_CHARTCHANGE 3 A symbol or a chart period is changed // REASON_CHARTCLOSE 4 Chart closed // REASON_PARAMETERS 5 Inputs changed by a user // REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings // REASON_TEMPLATE 7 Another chart template applied // REASON_INITFAILED 8 The OnInit() handler returned a non-zero value // REASON_CLOSE 9 Terminal closed // ShowBars(); // // De Initial Requirements ... mObjects.Clear(); // delete mDrawer; ZeroMemory(mDrawer); delete mBarAnalyser; ZeroMemory(mBarAnalyser); // // De Initialize all Handlers and etc ... IndicatorRelease(atrHandler); IndicatorRelease(sarHandler); IndicatorRelease(rsiHandler); IndicatorRelease(adxHandler); IndicatorRelease(trendHandler); // mSignal.Clean(); mDirShift.Clean(); mSignalBox.Clean(); // Clean(mBullishKIChanges); Clean(mBearishKIChanges); Clean(mBullishSBChanges); Clean(mBearishSBChanges); Clean(mBullishHKSChanges); Clean(mBearishHKSChanges); Clean(mBullishSarChanges); Clean(mBearishSarChanges); Clean(mBullishTrendChanges); Clean(mBearishTrendChanges); // Clean(mBullishLiquidities); Clean(mBearishLiquidities); Clean(mBullishRangeBreakes); Clean(mBearishRangeBreakes); // mBullishSignalBoxStyle.Clean(); mBearishSignalBoxStyle.Clean(); // mBullishLiquidityStyle.Clean(); mBearishLiquidityStyle.Clean(); mBullishRangeBreakStyle.Clean(); mBearishRangeBreakStyle.Clean(); // } /** * Calculate Bars ... * * @param rates_total: Integer, Total Bars on Chart ... * @param prev_calculated: Integer, Total Calculated Bars on Charts ... * @param time: DateTime Array, History of Open Time ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param low: Double Array, History of Low Prices ... * @param close: Double Array, History of Close Prices ... * @param tick_volume: Long, History of Tick Volumes on Bar ... * @param volume: Long, History of Trade Volumes ... * @param spread: Double, History of Spread Price ... * * @return ( int ) */ int OnCalculate( const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[] // ) { // // Prepare Buffers ... ArraySetAsSeries(time, true); ArraySetAsSeries(open, true); ArraySetAsSeries(high, true); ArraySetAsSeries(low, true); ArraySetAsSeries(close, true); ArraySetAsSeries(tick_volume, true); ArraySetAsSeries(volume, true); ArraySetAsSeries(spread, true); // // Validate Calculated Bars ... // // ATR ... int atrCalculatedBars = BarsCalculated(atrHandler); // // SAR ... int sarCalculatedBars = BarsCalculated(sarHandler); // // RSI ... int rsiCalculatedBars = BarsCalculated(rsiHandler); // // ADX ... int adxCalculatedBars = BarsCalculated(adxHandler); // // TREND ... int trendCalculatedBars = BarsCalculated(trendHandler); // bool isPassedRequiredCalculatedBars = // // ATR ... atrCalculatedBars >= maxLength && // // SAR ... sarCalculatedBars >= maxLength && // // RSI ... rsiCalculatedBars >= maxLength && // // ADX ... adxCalculatedBars >= maxLength && // // TREND ... trendCalculatedBars >= maxLength // ; if (!isPassedRequiredCalculatedBars) { return prev_calculated; } // limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1; // // Buffers Copy ... // // ATR ... int copiedAtrs = CopyBuffer(atrHandler, MAIN_LINE, 0, limit, atrBuffer); // // SAR ... int copiedSars = CopyBuffer(sarHandler, MAIN_LINE, 0, limit, sarBuffer); // // RSI ... int copiedRSIs = CopyBuffer(rsiHandler, MAIN_LINE, 0, limit, rsiBuffer); // // ADX ... int copiedADXs = CopyBuffer(adxHandler, MAIN_LINE, 0, limit, adxBuffer); // // ADX Plus ... int copiedADXPs = CopyBuffer(adxHandler, PLUSDI_LINE, 0, limit, adxpBuffer); // // ADX Negative ... int copiedADXNs = CopyBuffer(adxHandler, MINUSDI_LINE, 0, limit, adxnBuffer); // // TREND ... int copiedTrends = CopyBuffer(trendHandler, MAIN_LINE, 0, limit, trendBuffer); // // Validate Copied Items ... bool isPassedRequiredCopiedItems = // // ATR ... copiedAtrs >= limit && // // SAR ... copiedSars >= limit && // // RSI ... copiedRSIs >= limit && // // TREND ... copiedTrends >= limit // ; if (!isPassedRequiredCopiedItems) { return prev_calculated; } // if (prev_calculated == 0) { // string message = "History Started ..."; Print(message); } // // Main Loop ... for (int i = limit - 1; i >= 0 && !IsStopped(); i--) { // CalculateBuffers( i, prev_calculated, rates_total, // open, high, close, low, tick_volume // ); } // if (prev_calculated == 0) { // string message = "History Finished ..."; Print(message); } // return rates_total; } // // Custom Functions ... /** * Set Indicator Short Name and also we can define Buffers Labels ... */ void SetIndicatorName() { // IndicatorSetInteger(INDICATOR_DIGITS, _Digits); IndicatorSetString(INDICATOR_SHORTNAME, ShortName); } /** * Validate Input Args for Initialization ... * * @return ( bool ) */ bool ValidateInputs() { // bool result = false; // result = // sarMax > 0 && sarStep > 0 && rsiOBLevel > 0 && rsiOSLevel > 0 && adxThreshold > 0 && sarMax > sarStep && atrMultiplier > 0 && // IsValid(appliedCycle) && // IsValid(atrUpperPriceType) && IsValid(atrLowerPriceType) && // // CYCLES ... (IsValid(scMethod, scPeriod) && IsValid(mcMethod, mcPeriod) && IsValid(lcMethod, lcPeriod) && IsValid(hcMethod, hcPeriod)) // ; // return result; } /** * Extract Max Length of Inputs ... * * @return ( int ) */ int ExtractMaxLengthOfInputs() { // int result = 0; // result = MathMax(mSCLength, mMCLength); result = MathMax(result, mLCLength); result = MathMax(result, mHCLength); // return result; } /** * Define Required Buffers ... */ void DefineBuffers() { // // Plot Buffers ... // // SAR ... // ArraySetAsSeries(sarBuffer, true); SetIndexBuffer(sarBufferIndex, sarBuffer, INDICATOR_DATA); // PlotIndexSetInteger(sarBufferPlotIndex, PLOT_SHOW_DATA, showSar); PlotIndexSetDouble(sarBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); PlotIndexSetInteger(sarBufferPlotIndex, PLOT_ARROW, sarArrowCode); // ArraySetAsSeries(sarColorBuffer, true); SetIndexBuffer(sarColorBufferIndex, sarColorBuffer, INDICATOR_COLOR_INDEX); // ArraySetAsSeries(sarStateBuffer, true); SetIndexBuffer(sarStateBufferIndex, sarStateBuffer, INDICATOR_CALCULATIONS); // // PEAK / VALE ... // ENUM_DRAW_TYPE pvDrawType = showPV ? DRAW_ARROW : DRAW_NONE; // // PEAK ... // ArraySetAsSeries(peakBuffer, true); SetIndexBuffer(peakBufferIndex, peakBuffer, INDICATOR_DATA); // PlotIndexSetInteger(peakBufferPlotIndex, PLOT_SHOW_DATA, showPV); PlotIndexSetInteger(peakBufferPlotIndex, PLOT_DRAW_TYPE, pvDrawType); // PlotIndexSetDouble(peakBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); PlotIndexSetInteger(peakBufferPlotIndex, PLOT_ARROW, peakArrowCode); // // VALE ... // ArraySetAsSeries(valeBuffer, true); SetIndexBuffer(valeBufferIndex, valeBuffer, INDICATOR_DATA); // PlotIndexSetInteger(valeBufferPlotIndex, PLOT_SHOW_DATA, showPV); PlotIndexSetInteger(valeBufferPlotIndex, PLOT_DRAW_TYPE, pvDrawType); // PlotIndexSetDouble(valeBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); PlotIndexSetInteger(valeBufferPlotIndex, PLOT_ARROW, valeArrowCode); // // PV GOLDEN ... // ENUM_DRAW_TYPE pvGoldenDrawType = showPVGolden ? DRAW_LINE : DRAW_NONE; // // PEAK Golden ... // ArraySetAsSeries(peakGoldenBuffer, true); SetIndexBuffer(peakGoldenBufferIndex, peakGoldenBuffer, INDICATOR_DATA); // PlotIndexSetInteger(peakGoldenBufferPlotIndex, PLOT_SHOW_DATA, showPVGolden); PlotIndexSetInteger(peakGoldenBufferPlotIndex, PLOT_DRAW_TYPE, pvGoldenDrawType); // PlotIndexSetDouble(peakGoldenBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // VALE Golden ... // ArraySetAsSeries(valeGoldenBuffer, true); SetIndexBuffer(valeGoldenBufferIndex, valeGoldenBuffer, INDICATOR_DATA); // PlotIndexSetInteger(valeGoldenBufferPlotIndex, PLOT_SHOW_DATA, showPVGolden); PlotIndexSetInteger(valeGoldenBufferPlotIndex, PLOT_DRAW_TYPE, pvGoldenDrawType); // PlotIndexSetDouble(valeGoldenBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // ATR Band ... // // UPPER ... ENUM_DRAW_TYPE atrUpperDrawType = showATRBand ? DRAW_LINE : DRAW_NONE; // ArraySetAsSeries(atrUpperBuffer, true); SetIndexBuffer(atrUpperBufferIndex, atrUpperBuffer, INDICATOR_DATA); // PlotIndexSetDouble(atrUpperBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); PlotIndexSetInteger(atrUpperBufferPlotIndex, PLOT_SHOW_DATA, showATRBand); PlotIndexSetInteger(atrUpperBufferPlotIndex, PLOT_DRAW_TYPE, atrUpperDrawType); // // LOWER ... ENUM_DRAW_TYPE atrLowerDrawType = showATRBand ? DRAW_LINE : DRAW_NONE; // ArraySetAsSeries(atrLowerBuffer, true); SetIndexBuffer(atrLowerBufferIndex, atrLowerBuffer, INDICATOR_DATA); // PlotIndexSetDouble(atrLowerBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); PlotIndexSetInteger(atrLowerBufferPlotIndex, PLOT_SHOW_DATA, showATRBand); PlotIndexSetInteger(atrLowerBufferPlotIndex, PLOT_DRAW_TYPE, atrLowerDrawType); // // TREND ... // ArraySetAsSeries(trendBuffer, true); SetIndexBuffer(trendBufferIndex, trendBuffer, INDICATOR_DATA); // PlotIndexSetInteger(trendBufferPlotIndex, PLOT_SHOW_DATA, showTrend); PlotIndexSetDouble(trendBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // ArraySetAsSeries(trendColorBuffer, true); SetIndexBuffer(trendColorBufferIndex, trendColorBuffer, INDICATOR_COLOR_INDEX); // ArraySetAsSeries(trendStateBuffer, true); SetIndexBuffer(trendStateBufferIndex, trendStateBuffer, INDICATOR_CALCULATIONS); // // SIGNAL Bar ... // // Signal Bars Color ... ArraySetAsSeries(sBarColorBuffer, true); SetIndexBuffer(sBarColorBufferIndex, sBarColorBuffer, INDICATOR_COLOR_INDEX); // // Set EMPTY_VALUE on XHK Bar Buffer ... PlotIndexSetDouble(sBarBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); PlotIndexSetInteger(sBarBufferPlotIndex, PLOT_SHOW_DATA, false); // // Open ... ArraySetAsSeries(sBarOpenBuffer, true); SetIndexBuffer(sBarOpenBufferIndex, sBarOpenBuffer, INDICATOR_DATA); // // High ... ArraySetAsSeries(sBarHighBuffer, true); SetIndexBuffer(sBarHighBufferIndex, sBarHighBuffer, INDICATOR_DATA); // // Low ... ArraySetAsSeries(sBarLowBuffer, true); SetIndexBuffer(sBarLowBufferIndex, sBarLowBuffer, INDICATOR_DATA); // // Close ... ArraySetAsSeries(sBarCloseBuffer, true); SetIndexBuffer(sBarCloseBufferIndex, sBarCloseBuffer, INDICATOR_DATA); // // XHK SIGNAL Bar ... // // HK Bars Color ... ArraySetAsSeries(hkSBarColorBuffer, true); SetIndexBuffer(hkSBarColorBufferIndex, hkSBarColorBuffer, INDICATOR_COLOR_INDEX); // // Set EMPTY_VALUE on XHK Bar Buffer ... PlotIndexSetDouble(hkSBarBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); PlotIndexSetInteger(hkSBarBufferPlotIndex, PLOT_SHOW_DATA, false); // // Open ... ArraySetAsSeries(hkSBarOpenBuffer, true); SetIndexBuffer(hkSBarOpenBufferIndex, hkSBarOpenBuffer, INDICATOR_DATA); // // High ... ArraySetAsSeries(hkSBarHighBuffer, true); SetIndexBuffer(hkSBarHighBufferIndex, hkSBarHighBuffer, INDICATOR_DATA); // // Low ... ArraySetAsSeries(hkSBarLowBuffer, true); SetIndexBuffer(hkSBarLowBufferIndex, hkSBarLowBuffer, INDICATOR_DATA); // // Close ... ArraySetAsSeries(hkSBarCloseBuffer, true); SetIndexBuffer(hkSBarCloseBufferIndex, hkSBarCloseBuffer, INDICATOR_DATA); // // CYCLES ... // // SHORT ... // ENUM_DRAW_TYPE sDrawType = showShortCycle ? DRAW_LINE : DRAW_NONE; // // HH ... // ArraySetAsSeries(sHHBuffer, true); SetIndexBuffer(sHHBufferIndex, sHHBuffer, INDICATOR_DATA); // PlotIndexSetInteger(sHHBufferPlotIndex, PLOT_SHOW_DATA, showShortCycle); PlotIndexSetInteger(sHHBufferPlotIndex, PLOT_DRAW_TYPE, sDrawType); PlotIndexSetDouble(sHHBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // LL ... // ArraySetAsSeries(sLLBuffer, true); SetIndexBuffer(sLLBufferIndex, sLLBuffer, INDICATOR_DATA); // PlotIndexSetInteger(sLLBufferPlotIndex, PLOT_SHOW_DATA, showShortCycle); PlotIndexSetInteger(sLLBufferPlotIndex, PLOT_DRAW_TYPE, sDrawType); PlotIndexSetDouble(sLLBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // MEDIUM ... // ENUM_DRAW_TYPE mDrawType = showMediumCycle ? DRAW_LINE : DRAW_NONE; // // HH ... // ArraySetAsSeries(mHHBuffer, true); SetIndexBuffer(mHHBufferIndex, mHHBuffer, INDICATOR_DATA); // PlotIndexSetInteger(mHHBufferPlotIndex, PLOT_SHOW_DATA, showMediumCycle); PlotIndexSetInteger(mHHBufferPlotIndex, PLOT_DRAW_TYPE, mDrawType); PlotIndexSetDouble(mHHBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // LL ... // ArraySetAsSeries(mLLBuffer, true); SetIndexBuffer(mLLBufferIndex, mLLBuffer, INDICATOR_DATA); // PlotIndexSetInteger(mLLBufferPlotIndex, PLOT_SHOW_DATA, showMediumCycle); PlotIndexSetInteger(mLLBufferPlotIndex, PLOT_DRAW_TYPE, mDrawType); PlotIndexSetDouble(mLLBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // LONG ... // ENUM_DRAW_TYPE lDrawType = showLongCycle ? DRAW_LINE : DRAW_NONE; // // HH ... // ArraySetAsSeries(lHHBuffer, true); SetIndexBuffer(lHHBufferIndex, lHHBuffer, INDICATOR_DATA); // PlotIndexSetInteger(lHHBufferPlotIndex, PLOT_SHOW_DATA, showLongCycle); PlotIndexSetInteger(lHHBufferPlotIndex, PLOT_DRAW_TYPE, lDrawType); PlotIndexSetDouble(lHHBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // LL ... // ArraySetAsSeries(lLLBuffer, true); SetIndexBuffer(lLLBufferIndex, lLLBuffer, INDICATOR_DATA); // PlotIndexSetInteger(lLLBufferPlotIndex, PLOT_SHOW_DATA, showLongCycle); PlotIndexSetInteger(lLLBufferPlotIndex, PLOT_DRAW_TYPE, lDrawType); PlotIndexSetDouble(lLLBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // HIND ... // ENUM_DRAW_TYPE hDrawType = showHindCycle ? DRAW_LINE : DRAW_NONE; // // HH ... // ArraySetAsSeries(hHHBuffer, true); SetIndexBuffer(hHHBufferIndex, hHHBuffer, INDICATOR_DATA); // PlotIndexSetInteger(hHHBufferPlotIndex, PLOT_SHOW_DATA, showHindCycle); PlotIndexSetInteger(hHHBufferPlotIndex, PLOT_DRAW_TYPE, hDrawType); PlotIndexSetDouble(hHHBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // LL ... // ArraySetAsSeries(hLLBuffer, true); SetIndexBuffer(hLLBufferIndex, hLLBuffer, INDICATOR_DATA); // PlotIndexSetInteger(hLLBufferPlotIndex, PLOT_SHOW_DATA, showHindCycle); PlotIndexSetInteger(hLLBufferPlotIndex, PLOT_DRAW_TYPE, hDrawType); PlotIndexSetDouble(hLLBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // // KI ... // ArraySetAsSeries(kiBuffer, true); SetIndexBuffer(kiBufferIndex, kiBuffer, INDICATOR_DATA); // PlotIndexSetInteger(kiBufferPlotIndex, PLOT_SHOW_DATA, showKI); PlotIndexSetDouble(kiBufferPlotIndex, PLOT_EMPTY_VALUE, emptyValue); // ArraySetAsSeries(kiColorBuffer, true); SetIndexBuffer(kiColorBufferIndex, kiColorBuffer, INDICATOR_COLOR_INDEX); // // Data Buffers ... // // RSI ... ArraySetAsSeries(rsiBuffer, true); SetIndexBuffer(rsiBufferIndex, rsiBuffer, INDICATOR_CALCULATIONS); // // ADX ... // ArraySetAsSeries(adxBuffer, true); SetIndexBuffer(adxBufferIndex, adxBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(adxpBuffer, true); SetIndexBuffer(adxpBufferIndex, adxpBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(adxnBuffer, true); SetIndexBuffer(adxnBufferIndex, adxnBuffer, INDICATOR_CALCULATIONS); // // DELTA ... // ArraySetAsSeries(deltaBuffer, true); SetIndexBuffer(deltaBufferIndex, deltaBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(deltaSignalBuffer, true); SetIndexBuffer(deltaSignalBufferIndex, deltaSignalBuffer, INDICATOR_CALCULATIONS); // // VOLUME ... // ArraySetAsSeries(bullishVolumeBuffer, true); SetIndexBuffer(bullishVolumeBufferIndex, bullishVolumeBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(bearishVolumeBuffer, true); SetIndexBuffer(bearishVolumeBufferIndex, bearishVolumeBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(bullishVolumeSignalBuffer, true); SetIndexBuffer(bullishVolumeSignalBufferIndex, bullishVolumeSignalBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(bearishVolumeSignalBuffer, true); SetIndexBuffer(bearishVolumeSignalBufferIndex, bearishVolumeSignalBuffer, INDICATOR_CALCULATIONS); // // ATR ... ArraySetAsSeries(atrBuffer, true); SetIndexBuffer(atrBufferIndex, atrBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(atrUpperRawBuffer, true); SetIndexBuffer(atrUpperRawBufferIndex, atrUpperRawBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(atrLowerRawBuffer, true); SetIndexBuffer(atrLowerRawBufferIndex, atrLowerRawBuffer, INDICATOR_CALCULATIONS); // // XHK ... // ArraySetAsSeries(openHKBuffer, true); SetIndexBuffer(openHKBufferIndex, openHKBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(highHKBuffer, true); SetIndexBuffer(highHKBufferIndex, highHKBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(lowHKBuffer, true); SetIndexBuffer(lowHKBufferIndex, lowHKBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(closeHKBuffer, true); SetIndexBuffer(closeHKBufferIndex, closeHKBuffer, INDICATOR_CALCULATIONS); // // KI ... // ArraySetAsSeries(kiStateBuffer, true); SetIndexBuffer(kiStateBufferIndex, kiStateBuffer, INDICATOR_CALCULATIONS); // } /** * Initial Market Cycles ... * * @return ( bool ) */ bool InitCycles() { // bool result = false; // int cPeriodSeconds = PeriodSeconds(_Period); // // Find Cycle Period ... if (scMethod == X_PERIOD_AUTO) { // // Select Period ... mSCPeriod = GetCyclePeriod( X_MARKET_CYCLE_SHORT, _Period // ); } else { mSCPeriod = scPeriod; } // if (IsValid(mSCPeriod)) { mSCLength = PeriodSeconds(mSCPeriod) / cPeriodSeconds; } // // Find Cycle Period ... if (mcMethod == X_PERIOD_AUTO) { // // Select Period ... mMCPeriod = GetCyclePeriod( X_MARKET_CYCLE_MEDIUM, _Period // ); } else { mMCPeriod = mcPeriod; } // if (IsValid(mMCPeriod)) { mMCLength = PeriodSeconds(mMCPeriod) / cPeriodSeconds; } // // Find Cycle Period ... if (lcMethod == X_PERIOD_AUTO) { // // Select Period ... mLCPeriod = GetCyclePeriod( X_MARKET_CYCLE_LONG, _Period // ); } else { mLCPeriod = lcPeriod; } // if (IsValid(mLCPeriod)) { mLCLength = PeriodSeconds(mLCPeriod) / cPeriodSeconds; } // // Find Cycle Period ... if (hcMethod == X_PERIOD_AUTO) { // // Select Period ... mHCPeriod = GetCyclePeriod( X_MARKET_CYCLE_HIND, _Period // ); } else { mHCPeriod = hcPeriod; } // if (IsValid(mHCPeriod)) { mHCLength = PeriodSeconds(mHCPeriod) / cPeriodSeconds; } // result = mSCLength > 0 && mMCLength > mSCLength && mLCLength > mMCLength && mHCLength > mLCLength; // // Selecte Applied Cycle ... if (result) { // switch (appliedCycle) { // case X_MARKET_CYCLE_SHORT: // mAppliedLength = mSCLength; mAppliedPeriod = mSCPeriod; break; // case X_MARKET_CYCLE_MEDIUM: // mAppliedLength = mMCLength; mAppliedPeriod = mMCPeriod; break; // case X_MARKET_CYCLE_LONG: // mAppliedLength = mLCLength; mAppliedPeriod = mLCPeriod; break; // case X_MARKET_CYCLE_HIND: // mAppliedLength = mHCLength; mAppliedPeriod = mHCPeriod; break; } } // return result; } /** * Initial all Indicator Requirements ... * * @return ( false ) * */ bool InitRequirements() { // bool result = false; // // Handlers ... // // SAR ... sarHandler = iSAR( _Symbol, _Period, sarStep, sarMax // ); result = sarHandler != INVALID_HANDLE; if (!result) { return result; } // // ATR ... atrHandler = iATR( _Symbol, _Period, mAppliedLength // ); result = atrHandler != INVALID_HANDLE; if (!result) { return result; } // // RSI ... rsiHandler = iRSI( _Symbol, _Period, mAppliedLength, rsiAppliedTo // ); result = rsiHandler != INVALID_HANDLE; if (!result) { return result; } // // ADX ... adxHandler = iADX( _Symbol, _Period, mAppliedLength // ); result = adxHandler != INVALID_HANDLE; if (!result) { return result; } // // TREND ... trendHandler = iMA( _Symbol, _Period, mAppliedLength, 0, trendMode, trendAppliedTo // ); result = trendHandler != INVALID_HANDLE; if (!result) { return result; } // return result; } /** * Calculate Custom Buffers ... * * @param barIndex: Integer, Represent Current Bar ... * @param prevCalculated: Integer, Represent Previous Calculated Bars ... * @param ratesTotal: Integer, Represents All Available Bars ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param close: Double Array, History of Close Prices ... * @param low: Double Array, History of Low Prices ... * @param tickVolume: Long, History of Tick Volumes on Bar ... */ void CalculateBuffers( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // int barsLimit = startCalculationForLastBars > 0 ? startCalculationForLastBars : 0; if (barsLimit == 0) { // barsLimit = ratesTotal; firstBarIndex = barsLimit - 1; } else { firstBarIndex = startCalculationForLastBars; } // // bool canCalculate = true; bool canCalculate = barIndex <= barsLimit; if (canCalculate) { // // Calculate Values ... CalculateValues( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); } else { FillBuffersZero(barIndex); } } /** * Fill All Bufers to Zero Vlue for Specified Bar Index ... * * @param barIndex: Integer ... */ void FillBuffersZero(int barIndex) { // kiColorBuffer[barIndex] = hideColorIDX; sarColorBuffer[barIndex] = hideColorIDX; trendColorBuffer[barIndex] = hideColorIDX; // atrUpperRawBuffer[barIndex] = emptyValue; atrLowerRawBuffer[barIndex] = emptyValue; } // // Value Calculators ... /** * Calculate Values ... * * @param barIndex: int, Specified Bar Index ... * @param prevCalculated: int, Provides Previous Calculated Bars ... * @param ratesTotal: int, Provides All Availabled Bars ... * @param open: double Collection, Provides Open Prices Time Series ... * @param high: double Collection, Provides High Prices Time Series ... * @param close: double Collection, Provides Close Prices Time Series ... * @param low: double Collection, Provides Low Prices Time Series ... * @param tickVolume: long Collection, Provides Ticks Volume Prices Time Series ... */ void CalculateValues( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // int lastBarIndex = barIndex + 1; int maxBarIndex = startCalculationForLastBars > 0 ? startCalculationForLastBars : ratesTotal; bool isFirstBar = startCalculationForLastBars > 0 ? barIndex == startCalculationForLastBars : barIndex == firstBarIndex; // // Cycle Ranges ... CalculateCycleRanges( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // KI ... CalculateKI( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // PV ... CalculatePV( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // SAR ... CalculateSAR( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // SBAR ... CalculateSBar( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // HKBAR ... CalculateHKBar( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // DELTA ... CalculateDelta( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // TREND ... CalculateTrend( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // VOLUME ... CalculateVolume( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // ATR Band ... CalculateATRBand( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // Handling Process ... // // Prepare Market Conditions ... PrepareMarketConditions( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // Detecting POI(s) ... DetectPOIs( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // Validating ... ValidatePOIs( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // Drawing ... DrawPOIs( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // Do Process on Bars ... DoProcess( barIndex, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); } /** * Calculate Cycle Ranges 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 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 KI 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 CalculateKI( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // int lastBarIndex = barIndex + 1; bool isFirstBar = startCalculationForLastBars > 0 ? barIndex == startCalculationForLastBars : barIndex == firstBarIndex; // XOHCL iBar; bool isInited = iBar.Init( _Symbol, _Period, barIndex // ); // double iClose = close[barIndex]; // // Calculate KI / Color ... double lastKI = isFirstBar ? emptyValue : kiBuffer[lastBarIndex]; double iKI = lastKI; if (isInited) { // double iLLKI = iBar.FindLowest(kiLength, MODE_LOW); double iHHKI = iBar.FindHighest(kiLength, MODE_HIGH); // iKI = (iHHKI + iLLKI) / 2; if (iLLKI == 0 || iHHKI == 0) { iKI = lastKI; } } else { iKI = lastKI; } kiBuffer[barIndex] = iKI; // double iKIState = neuturalState; double iKIColor = neuturalColorIDX; if (iClose > iKI) { // iKIState = bullishState; iKIColor = !showKI ? hideColorIDX : bullishColorIDX; } else if (iClose < iKI) { // iKIState = bearishState; iKIColor = !showKI ? hideColorIDX : bearishColorIDX; } kiStateBuffer[barIndex] = iKIState; kiColorBuffer[barIndex] = iKIColor; // iBar.Clean(); } /** * Calculate Peaks and Vales 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 CalculatePV( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // int lastBarIndex = barIndex + 1; bool isFirstBar = startCalculationForLastBars > 0 ? barIndex == startCalculationForLastBars : barIndex == firstBarIndex; // double iSHH = sHHBuffer[barIndex]; double iSLL = sLLBuffer[barIndex]; // double iMHH = mHHBuffer[barIndex]; double iMLL = mLLBuffer[barIndex]; // double iLHH = lHHBuffer[barIndex]; double iLLL = lLLBuffer[barIndex]; // double iHHH = hHHBuffer[barIndex]; double iHLL = hLLBuffer[barIndex]; // // Calculate VALE ... bool isVale = iSLL == iMLL && iMLL == iLLL && iLLL == iHLL; double iPVale = isFirstBar ? emptyValue : valeBuffer[lastBarIndex]; double iVale = isVale ? iSLL : iPVale; valeBuffer[barIndex] = iVale; // // Calculate PEAK ... bool isPeak = iSHH == iMHH && iMHH == iLHH && iLHH == iHHH; double iPPeak = isFirstBar ? emptyValue : peakBuffer[lastBarIndex]; double iPeak = isPeak ? iSHH : iPPeak; peakBuffer[barIndex] = iPeak; // // GOLDEN ... XOHCL iBar; bool isInited = iBar.Init( _Symbol, _Period, barIndex // ); // // Calculate PV Gold ... double lastPeakGold = isFirstBar ? emptyValue : peakGoldenBuffer[lastBarIndex]; double lastValeGold = isFirstBar ? emptyValue : valeGoldenBuffer[lastBarIndex]; double iPeakGold = lastPeakGold; double iValeGold = lastValeGold; if (isInited) { // iPeakGold = iBar.FindHighest(mHCLength, MODE_CLOSE); if (iPeakGold == 0) { iPeakGold = lastPeakGold; } // iValeGold = iBar.FindLowest(mHCLength, MODE_CLOSE); if (iValeGold == 0) { iValeGold = lastValeGold; } } else { // iPeakGold = lastPeakGold; iValeGold = lastValeGold; } // peakGoldenBuffer[barIndex] = iPeakGold; valeGoldenBuffer[barIndex] = iValeGold; // iBar.Clean(); } /** * Calculate PSar 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 CalculateSAR( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // double iLow = low[barIndex]; double iHigh = low[barIndex]; double iSar = sarBuffer[barIndex]; // bool isBullish = iSar < iLow; bool isBearish = iSar > iHigh; // double iSarState = isBullish ? 1 : isBearish ? -1 : 0; double iSarColor = iSarState > 0 ? bullishColorIDX : iSarState < 0 ? bearishColorIDX : neuturalColorIDX; sarStateBuffer[barIndex] = iSarState; sarColorBuffer[barIndex] = showSar ? iSarColor : hideColorIDX; } /** * Calculate Signal Bar 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 CalculateSBar( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // // Open ... iMAOnBuffer( ratesTotal, prevCalculated, barIndex, mAppliedLength, open, sBarOpenBuffer, barsSignalMethod // ); // // Close ... iMAOnBuffer( ratesTotal, prevCalculated, barIndex, mAppliedLength, close, sBarCloseBuffer, barsSignalMethod // ); // double min = MathMin(sBarCloseBuffer[barIndex], sBarOpenBuffer[barIndex]); double max = MathMin(sBarCloseBuffer[barIndex], sBarOpenBuffer[barIndex]); // sBarLowBuffer[barIndex] = min; sBarHighBuffer[barIndex] = max; // // Calculate HK Signal Color ... double iSignalColorValue = sBarOpenBuffer[barIndex] < sBarCloseBuffer[barIndex] ? bullishColorIDX : bearishColorIDX; sBarColorBuffer[barIndex] = showSignalBars ? iSignalColorValue : hideColorIDX; } /** * Calculate HK and HK Signal Bars 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 CalculateHKBar( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // int lastBarIndex = barIndex + 1; bool isFirstBar = startCalculationForLastBars > 0 ? barIndex == startCalculationForLastBars : barIndex == firstBarIndex; // double lastHKOpen = isFirstBar ? emptyValue : openHKBuffer[lastBarIndex]; double lastHKClose = isFirstBar ? emptyValue : closeHKBuffer[lastBarIndex]; // double iHKOpenValue = (lastHKOpen + lastHKClose) / 2; double iHKCloseValue = (open[barIndex] + high[barIndex] + close[barIndex] + low[barIndex]) / 4; double iHKHighValue = MathMax(high[barIndex], MathMax(iHKOpenValue, iHKCloseValue)); double iHKLowValue = MathMin(low[barIndex], MathMin(iHKOpenValue, iHKCloseValue)); // // Raw HK Buffers ... openHKBuffer[barIndex] = iHKOpenValue; highHKBuffer[barIndex] = iHKHighValue; lowHKBuffer[barIndex] = iHKLowValue; closeHKBuffer[barIndex] = iHKCloseValue; // // XHK Signal ... // // Open ... iMAOnBuffer( ratesTotal, prevCalculated, barIndex, mAppliedLength, openHKBuffer, hkSBarOpenBuffer, hkSignalBarMethod // ); // // Close ... iMAOnBuffer( ratesTotal, prevCalculated, barIndex, mAppliedLength, closeHKBuffer, hkSBarCloseBuffer, hkSignalBarMethod // ); // double min = MathMin(hkSBarCloseBuffer[barIndex], hkSBarOpenBuffer[barIndex]); double max = MathMin(hkSBarCloseBuffer[barIndex], hkSBarOpenBuffer[barIndex]); // hkSBarLowBuffer[barIndex] = min; hkSBarHighBuffer[barIndex] = max; // // Calculate HK Signal Color ... double iHKSignalColorValue = hkSBarOpenBuffer[barIndex] < hkSBarCloseBuffer[barIndex] ? bullishColorIDX : bearishColorIDX; hkSBarColorBuffer[barIndex] = showHKSignalBars ? iHKSignalColorValue : hideColorIDX; } /** * Calculate Delta Oscillator 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 CalculateDelta( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // int lastBarIndex = barIndex + 1; bool isFirstBar = startCalculationForLastBars > 0 ? barIndex == startCalculationForLastBars : barIndex == firstBarIndex; // double iClose = close[barIndex]; double iOpen = open[barIndex]; double iVolume = (double)iVolume(_Symbol, _Period, barIndex); // bool isBullish = iClose > iOpen; bool isBearish = iClose < iOpen; // // DELTA ... double lastDelta = isFirstBar ? emptyValue : deltaBuffer[lastBarIndex]; double iAppliedVolume = isBullish ? iVolume : -1 * iVolume; double iDelta = lastDelta + iAppliedVolume; deltaBuffer[barIndex] = iDelta; // // Calculate Delta Signal ... int deltaSignalsCount = iMAOnBuffer( ratesTotal, prevCalculated, barIndex, mAppliedLength, deltaBuffer, deltaSignalBuffer, deltaSignalMethod // ); } /** * Calculate Trend 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 CalculateTrend( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // double iLow = low[barIndex]; double iHigh = high[barIndex]; double iClose = close[barIndex]; double iTrend = trendBuffer[barIndex]; // bool isBullish = iTrend < iLow; bool isBearish = iTrend > iHigh; // double iTrendState = isBullish ? 1 : isBearish ? -1 : 0; double iTrendColor = iTrendState > 0 ? bullishColorIDX : iTrendState < 0 ? bearishColorIDX : neuturalColorIDX; trendStateBuffer[barIndex] = iTrendState; trendColorBuffer[barIndex] = showTrend ? iTrendColor : hideColorIDX; } /** * Calculate Volume Oscillators 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 CalculateVolume( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // double iClose = close[barIndex]; double iOpen = open[barIndex]; double iVolume = (double)iVolume(_Symbol, _Period, barIndex); // bool isBullish = iClose > iOpen; bool isBearish = iClose < iOpen; // double iBullishVolume = emptyValue; double iBearishVolume = emptyValue; if (isBullish) { iBullishVolume = iVolume; } else if (isBearish) { iBearishVolume = iVolume; } else { // double iHalfVolume = iVolume / 2; // iBullishVolume = iHalfVolume; iBearishVolume = iHalfVolume; } bullishVolumeBuffer[barIndex] = iBullishVolume; bearishVolumeBuffer[barIndex] = iBearishVolume; // // Calculate Volume Signals ... // int bullishVolumeSignalsCount = iMAOnBuffer( ratesTotal, prevCalculated, barIndex, mAppliedLength, bullishVolumeBuffer, bullishVolumeSignalBuffer, volumeSignalMethod // ); // int bearishVolumeSignalsCount = iMAOnBuffer( ratesTotal, prevCalculated, barIndex, mAppliedLength, bearishVolumeBuffer, bearishVolumeSignalBuffer, volumeSignalMethod // ); } /** * Calculate ATR Band 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 CalculateATRBand( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // double iATR = atrBuffer[barIndex]; double iAppliedATR = atrMultiplier * iATR; double iATRUpperPrice = GetAppliedPrice( atrUpperPriceType, open, high, low, close, barIndex // ); double iATRLowerPrice = GetAppliedPrice( atrLowerPriceType, open, high, low, close, barIndex // ); double iATRUpper = iATRUpperPrice + iAppliedATR; double iATRLower = iATRLowerPrice - iAppliedATR; atrUpperRawBuffer[barIndex] = iATRUpper; atrLowerRawBuffer[barIndex] = iATRLower; // bool canSignalATR = IsValid(atrSignalMethod); if (canSignalATR) { // // Upper ... iMAOnBuffer( ratesTotal, prevCalculated, barIndex, mAppliedLength, atrUpperRawBuffer, atrUpperBuffer, atrSignalMethod // ); // // Lower ... iMAOnBuffer( ratesTotal, prevCalculated, barIndex, mAppliedLength, atrLowerRawBuffer, atrLowerBuffer, atrSignalMethod // ); } else { // atrUpperBuffer[barIndex] = iATRUpper; atrLowerBuffer[barIndex] = iATRLower; } } /** * Calculate Specified Market Cycle Info ... * * @param barIndex: Integer, Bar Index ... * @param cycle: ENUM_X_MARKET_CYCLES member, Specified Cycle ... * @param hhBuffer: Highest High Buffer Reference ... * @param llBuffer: Lowest Low Buffer Reference ... */ void CalculateCycle( int barIndex, ENUM_X_MARKET_CYCLES cycle, double &hhBuffer[], double &llBuffer[] // ) { // XOHCL bar; bool isBarInited = bar.Init( _Symbol, _Period, barIndex // ); if (!isBarInited) { return; } // int mLength = 0; switch (cycle) { // case X_MARKET_CYCLE_SHORT: mLength = mSCLength; break; // case X_MARKET_CYCLE_MEDIUM: mLength = mMCLength; break; // case X_MARKET_CYCLE_LONG: mLength = mLCLength; break; // case X_MARKET_CYCLE_HIND: mLength = mHCLength; break; } // if (mLength == 0) { return; } // // Find Highest High ... double hhValue = bar.FindHighest( mLength, upperMode // ); hhBuffer[barIndex] = hhValue; // // Find Lowest Low ... double llValue = bar.FindLowest( mLength, lowerMode // ); llBuffer[barIndex] = llValue; // bar.Clean(); } // // // /** * Reading Bar Style and Store it ... */ void ReadBarStyle() { // long chartId = ChartID(); // _upColor = GetChartUpColor(chartId); _downColor = GetChartDownColor(chartId); _lineColor = GetChartLineColor(chartId); _bullishColor = GetChartBullishColor(chartId); _bearishColor = GetChartBearishColor(chartId); } /** * Show Bars ... */ void ShowBars() { // long chartId = ChartID(); // SetChartUpColor(_upColor, chartId); SetChartDownColor(_downColor, chartId); SetChartLineColor(_lineColor, chartId); SetChartBullishColor(_bullishColor, chartId); SetChartBearishColor(_bearishColor, chartId); } /** * Hide Bars ... */ void HideBars() { // long chartId = ChartID(); // SetChartUpColor(CLR_NONE, chartId); SetChartDownColor(CLR_NONE, chartId); SetChartLineColor(CLR_NONE, chartId); SetChartBullishColor(CLR_NONE, chartId); SetChartBearishColor(CLR_NONE, chartId); } // // Process Handlers ... // /** * Prepare Market Conditions ... * * @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 PrepareMarketConditions( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // // Check Some Requirements ... int lastBarIndex = barIndex + 1; int maxBarIndex = startCalculationForLastBars > 0 ? startCalculationForLastBars : ratesTotal; bool isFirstBar = startCalculationForLastBars > 0 ? barIndex == startCalculationForLastBars : barIndex == firstBarIndex; // // Recieve Bar ... XOHCL iBar; XOHCL iPBar; mHas = iBar.Init( _Symbol, _Period, barIndex // ); mHas = mHas && iBar.GetPreviousBar(iPBar); if (!mHas) { return; } // int cIndex = barIndex; int pIndex = barIndex + 1; int p2Index = barIndex + 2; int p3Index = barIndex + 3; // // Check Required Bars Passed ... mHas = p3Index <= maxBarIndex; if (!mHas) { return; } // // Start Preparing Conditions ... // // Liquidities ... // isLiquidity = mBarAnalyser .IsRejected( iBar, mDir, true, true // ); isBullishLiquidity = isLiquidity && IsBullish(mDir); isBearishLiquidity = isLiquidity && IsBearish(mDir); // // Trigger Bars Conditions ... // // Cond 1 ... isTriggerBarCond1 = mBarAnalyser .IsValidForTrigger( iPBar, mDir, true, // Cond 1 ... false, // Cond 2 ... false, // Cond 3 ... false, // Cond 4 ... false, // Cond 5 ... false, // Cond 6 ... false // Cond 7 ... ); isTriggerBarCond1Bullish = isTriggerBarCond1 && IsBullish(mDir); isTriggerBarCond1Bearish = isTriggerBarCond1 && IsBearish(mDir); if (isTriggerBarCond1) { mArrowNamePrefix += "1"; } // // Cond 2 ... isTriggerBarCond2 = mBarAnalyser .IsValidForTrigger( iPBar, mDir, false, // Cond 1 ... true, // Cond 2 ... false, // Cond 3 ... false, // Cond 4 ... false, // Cond 5 ... false, // Cond 6 ... false // Cond 7 ... ); isTriggerBarCond2Bullish = isTriggerBarCond2 && IsBullish(mDir); isTriggerBarCond2Bearish = isTriggerBarCond2 && IsBearish(mDir); if (isTriggerBarCond2) { mArrowNamePrefix += ",2"; } // // Cond 3 ... isTriggerBarCond3 = mBarAnalyser .IsValidForTrigger( iPBar, mDir, false, // Cond 1 ... false, // Cond 2 ... true, // Cond 3 ... false, // Cond 4 ... false, // Cond 5 ... false, // Cond 6 ... false // Cond 7 ... ); isTriggerBarCond3Bullish = isTriggerBarCond3 && IsBullish(mDir); isTriggerBarCond3Bearish = isTriggerBarCond3 && IsBearish(mDir); if (isTriggerBarCond3) { mArrowNamePrefix += ",3"; } // // Cond 4 ... isTriggerBarCond4 = mBarAnalyser .IsValidForTrigger( iPBar, mDir, false, // Cond 1 ... false, // Cond 2 ... false, // Cond 3 ... true, // Cond 4 ... false, // Cond 5 ... false, // Cond 6 ... false // Cond 7 ... ); isTriggerBarCond4Bullish = isTriggerBarCond4 && IsBullish(mDir); isTriggerBarCond4Bearish = isTriggerBarCond4 && IsBearish(mDir); if (isTriggerBarCond4) { mArrowNamePrefix += ",4"; } // // Cond 5 ... isTriggerBarCond5 = mBarAnalyser .IsValidForTrigger( iPBar, mDir, false, // Cond 1 ... false, // Cond 2 ... false, // Cond 3 ... false, // Cond 4 ... true, // Cond 5 ... false, // Cond 6 ... false // Cond 7 ... ); isTriggerBarCond5Bullish = isTriggerBarCond5 && IsBullish(mDir); isTriggerBarCond5Bearish = isTriggerBarCond5 && IsBearish(mDir); if (isTriggerBarCond5) { mArrowNamePrefix += ",5"; } // // Cond 6 ... isTriggerBarCond6 = mBarAnalyser .IsValidForTrigger( iPBar, mDir, false, // Cond 1 ... false, // Cond 2 ... false, // Cond 3 ... false, // Cond 4 ... false, // Cond 5 ... true, // Cond 6 ... false // Cond 7 ... ); isTriggerBarCond6Bullish = isTriggerBarCond6 && IsBullish(mDir); isTriggerBarCond6Bearish = isTriggerBarCond6 && IsBearish(mDir); if (isTriggerBarCond6) { mArrowNamePrefix += ",6"; } // // Cond 7 ... isTriggerBarCond7 = mBarAnalyser .IsValidForTrigger( iPBar, mDir, false, // Cond 1 ... false, // Cond 2 ... false, // Cond 3 ... false, // Cond 4 ... false, // Cond 5 ... false, // Cond 6 ... true // Cond 7 ... ); isTriggerBarCond7Bullish = isTriggerBarCond7 && IsBullish(mDir); isTriggerBarCond7Bearish = isTriggerBarCond7 && IsBearish(mDir); if (isTriggerBarCond7) { mArrowNamePrefix += ",7"; } // // Summarizing Trigger Bar ... // isTriggerBar = isTriggerBarCond1 || isTriggerBarCond2 || isTriggerBarCond3 || isTriggerBarCond4 || isTriggerBarCond5 || isTriggerBarCond6 || isTriggerBarCond7; // isTriggerBarBullish = isTriggerBarCond1Bullish || isTriggerBarCond2Bullish || isTriggerBarCond3Bullish || isTriggerBarCond4Bullish || isTriggerBarCond5Bullish || isTriggerBarCond6Bullish || isTriggerBarCond7Bullish; // isTriggerBarBearish = isTriggerBarCond1Bearish || isTriggerBarCond2Bearish || isTriggerBarCond3Bearish || isTriggerBarCond4Bearish || isTriggerBarCond5Bearish || isTriggerBarCond6Bearish || isTriggerBarCond7Bearish; // // Resetting Counters Based on Conditions ... // // XPV ... // if (!isSamePeak) { // mSamePeakCount = 0; mSamePeakGoldenMin = 0; mSamePeakGoldenMax = 0; } // if (!isSameVale) { // mSameValeCount = 0; mSameValeGoldenMin = 0; mSameValeGoldenMax = 0; } // if (!isSamePeakGolden) { mSamePeakGoldenCount = 0; } // if (!isSameValeGolden) { mSameValeGoldenCount = 0; } // // XKI ... // if (!isSameKI) { mSameKICount = 0; } // if (!isSameBullishKI) { mSameBullishKICount = 0; } // if (!isSameBearishKI) { mSameBearishKICount = 0; } // // XSB ... // if (isSBSwitchedToBullish) { // mSameSBCount = 0; mSameBullishSBCount = 0; } // if (isSBSwitchedToBearish) { // mSameSBCount = 0; mSameBearishSBCount = 0; } // // XSAR ... // if (isSarSwitchedToBullish) { // mSameSarCount = 0; mSameBullishSarCount = 0; } // if (isSarSwitchedToBearish) { // mSameSarCount = 0; mSameBearishSarCount = 0; } // // XHKS ... // if (isHKSSwitchedToBullish) { // mSameHKSCount = 0; mSameBullishHKSCount = 0; } // if (isHKSSwitchedToBearish) { // mSameHKSCount = 0; mSameBearishHKSCount = 0; } // // XTREND ... // if (isTrendSwitchedToBullish) { // mSameTrendCount = 0; mSameBullishTrendCount = 0; } // if (isTrendSwitchedToBearish) { // mSameTrendCount = 0; mSameBearishTrendCount = 0; } // // Preparing Conditions ... // // XPV ... // isSamePeak = peakBuffer[pIndex] == peakBuffer[p2Index]; isSamePeakP = peakBuffer[p2Index] == peakBuffer[p3Index]; // isSameVale = valeBuffer[pIndex] == valeBuffer[p2Index]; isSameValeP = valeBuffer[p2Index] == valeBuffer[p3Index]; // isPeakOverLast = peakBuffer[pIndex] > peakBuffer[p2Index]; isPeakUnderLast = peakBuffer[pIndex] < peakBuffer[p2Index]; // isValeOverLast = valeBuffer[pIndex] > valeBuffer[p2Index]; isValeUnderLast = valeBuffer[pIndex] < valeBuffer[p2Index]; // isSamePeakOverLast = isSamePeakP && isPeakOverLast; isSamePeakUnderLast = isSamePeakP && isPeakUnderLast; // isSameValeOverLast = isSameValeP && isValeOverLast; isSameValeUnderLast = isSameValeP && isValeUnderLast; // isSamePeakGolden = peakGoldenBuffer[pIndex] == peakGoldenBuffer[p2Index]; isSamePeakGoldenP = peakGoldenBuffer[p2Index] == peakGoldenBuffer[p3Index]; // isSameValeGolden = valeGoldenBuffer[pIndex] == valeGoldenBuffer[p2Index]; isSameValeGoldenP = valeGoldenBuffer[p2Index] == valeGoldenBuffer[p3Index]; // isPeakGoldenOverLast = peakGoldenBuffer[pIndex] > peakGoldenBuffer[p2Index]; isPeakGoldenUnderLast = peakGoldenBuffer[pIndex] < peakGoldenBuffer[p2Index]; // isValeGoldenOverLast = valeGoldenBuffer[pIndex] > valeGoldenBuffer[p2Index]; isValeGoldenUnderLast = valeGoldenBuffer[pIndex] < valeGoldenBuffer[p2Index]; // isSamePeakGoldenOverLast = isSamePeakGoldenP && isPeakGoldenOverLast; isSamePeakGoldenUnderLast = isSamePeakGoldenP && isPeakGoldenUnderLast; // isSameValeGoldenOverLast = isSameValeGoldenP && isValeGoldenOverLast; isSameValeGoldenUnderLast = isSameValeGoldenP && isSameValeGoldenUnderLast; // // XSAR ... // isSarBullish = sarStateBuffer[pIndex] > 0; isSarBullishP = sarStateBuffer[p2Index] > 0; // isSarBearish = sarStateBuffer[pIndex] < 0; isSarBearishP = sarStateBuffer[p2Index] < 0; // isSarSwitchedToBullish = isSarBullish && !isSarBullishP; isSarSwitchedToBearish = isSarBearish && !isSarBearishP; // // XSB ... // isSBBullish = sBarCloseBuffer[pIndex] > sBarOpenBuffer[pIndex]; isSBBullishP = sBarCloseBuffer[p2Index] > sBarOpenBuffer[p2Index]; // isSBBearish = sBarCloseBuffer[pIndex] < sBarOpenBuffer[pIndex]; isSBBearishP = sBarCloseBuffer[p2Index] < sBarOpenBuffer[p2Index]; // isSBSwitchedToBullish = isSBBullish && !isSBBullishP; isSBSwitchedToBearish = isSBBearish && !isSBBearishP; // mSBMin = MathMin(sBarCloseBuffer[pIndex], sBarOpenBuffer[pIndex]); mSBMax = MathMax(sBarCloseBuffer[pIndex], sBarOpenBuffer[pIndex]); // mSBPMin = MathMin(sBarCloseBuffer[p2Index], sBarOpenBuffer[p2Index]); mSBPMax = MathMax(sBarCloseBuffer[p2Index], sBarOpenBuffer[p2Index]); // // XHKS ... // isHKSBullish = hkSBarCloseBuffer[pIndex] > hkSBarOpenBuffer[pIndex]; isHKSBullishP = hkSBarCloseBuffer[p2Index] > hkSBarOpenBuffer[p2Index]; // isHKSBearish = hkSBarCloseBuffer[pIndex] < hkSBarOpenBuffer[pIndex]; isHKSBearishP = hkSBarCloseBuffer[p2Index] < hkSBarOpenBuffer[p2Index]; // isHKSSwitchedToBullish = isHKSBullish && !isHKSBullishP; isHKSSwitchedToBearish = isHKSBearish && !isHKSBearishP; // mHKSMin = MathMin(hkSBarCloseBuffer[pIndex], hkSBarOpenBuffer[pIndex]); mHKSMax = MathMax(hkSBarCloseBuffer[pIndex], hkSBarOpenBuffer[pIndex]); // mHKSPMin = MathMin(hkSBarCloseBuffer[p2Index], hkSBarOpenBuffer[p2Index]); mHKSPMax = MathMax(hkSBarCloseBuffer[p2Index], hkSBarOpenBuffer[p2Index]); // // XKI ... // isKIBullish = kiStateBuffer[pIndex] > 0; isKIBullishP = kiStateBuffer[p2Index] > 0; // isKIBearish = kiStateBuffer[pIndex] < 0; isKIBearishP = kiStateBuffer[p2Index] < 0; // isSameKI = kiBuffer[pIndex] == kiBuffer[p2Index]; isSameBullishKI = isSameKI && isKIBullish; isSameBearishKI = isSameKI && isKIBearish; // isKISwitchedToBullish = isKIBullish && !isKIBullishP; isKISwitchedToBearish = isKIBearish && !isKIBearishP; // // XTREND ... // isTrendBullish = trendStateBuffer[pIndex] > 0; isTrendBullishP = trendStateBuffer[p2Index] > 0; // isTrendBearish = trendStateBuffer[pIndex] < 0; isTrendBearishP = trendStateBuffer[p2Index] < 0; // isTrendSwitchedToBullish = isTrendBullish && !isTrendBullishP; isTrendSwitchedToBearish = isTrendBearish && !isTrendBearishP; // // Detecting Counters and Direction Shifts and it's related Conditions ... // // XPV Counters ... // if (isSamePeak) { // mSamePeakCount++; mSamePeakGoldenMin = mSamePeakGoldenMin == 0 ? peakGoldenBuffer[pIndex] : MathMin(mSamePeakGoldenMin, peakGoldenBuffer[pIndex]); mSamePeakGoldenMax = mSamePeakGoldenMax == 0 ? peakGoldenBuffer[pIndex] : MathMax(mSamePeakGoldenMax, peakGoldenBuffer[pIndex]); } // if (isSameVale) { // mSameValeCount++; mSameValeGoldenMin = mSameValeGoldenMin == 0 ? valeGoldenBuffer[pIndex] : MathMin(mSameValeGoldenMin, valeGoldenBuffer[pIndex]); mSameValeGoldenMax = mSameValeGoldenMax == 0 ? valeGoldenBuffer[pIndex] : MathMax(mSameValeGoldenMax, valeGoldenBuffer[pIndex]); } // if (isSamePeakGolden) { mSamePeakGoldenCount++; } // if (isSameValeGolden) { mSameValeGoldenCount++; } // // XSB Shifts ... // // Detection ... if (isSBSwitchedToBullish || isSBSwitchedToBearish) { // mDirShift.at = iPBar.time; mDirShift.symbol = _Symbol; mDirShift.period = _Period; // mDirShift.type = "XSBSHFT"; // mDirShift.after = 0; mDirShift.before = 0; // if (isSBSwitchedToBullish) { // mDirShift.after = mSBMax; mDirShift.before = mSBPMax; mDirShift.shiftTo = X_DIRECTION_BULLISH; // if (mDirShift.IsValid()) { // AddIfNotExists( mDirShift, mBullishSBChanges // ); } } // if (isSBSwitchedToBearish) { // mDirShift.after = mSBMin; mDirShift.before = mSBPMin; mDirShift.shiftTo = X_DIRECTION_BEARISH; // if (mDirShift.IsValid()) { // AddIfNotExists( mDirShift, mBearishSBChanges // ); } } // mDirShift.Clean(); } // // Parsers ... // mHas = isSBBullish && HasChild(mBearishSBChanges); if (mHas) { isBullishSBBreakedLast = mSBMin > mBearishSBChanges[ArraySize(mBearishSBChanges) - 1].after; } // mHas = isSBBearish && HasChild(mBullishSBChanges); if (mHas) { isBearishSBBreakedLast = mSBMax < mBullishSBChanges[ArraySize(mBullishSBChanges) - 1].after; } // // Counters ... // if (!isSBSwitchedToBullish && !isSBSwitchedToBearish) { // bool isDBullish = isSBBullish && isSBBullishP; if (isDBullish) { mSameBullishSBCount++; } // bool isDBearish = isSBBearish && isSBBearishP; if (isDBearish) { mSameBearishSBCount++; } // if (isDBullish || isDBearish) { mSameSBCount++; } } // // XSAR Shifts ... // // Detection ... if (isSarSwitchedToBullish || isSarSwitchedToBearish) { // mDirShift.at = iPBar.time; mDirShift.symbol = _Symbol; mDirShift.period = _Period; // mDirShift.type = "XSARSHFT"; // mDirShift.after = sarBuffer[pIndex]; mDirShift.before = sarBuffer[p2Index]; // if (isSarSwitchedToBullish) { // mDirShift.shiftTo = X_DIRECTION_BULLISH; // if (mDirShift.IsValid()) { // AddIfNotExists( mDirShift, mBullishSarChanges // ); } } // if (isSarSwitchedToBearish) { // mDirShift.shiftTo = X_DIRECTION_BEARISH; // if (mDirShift.IsValid()) { // AddIfNotExists( mDirShift, mBearishSarChanges // ); } } // mDirShift.Clean(); } // // Parsers ... // mHas = isSarBullish && HasChild(mBearishSarChanges); if (mHas) { isBullishSarBreakedLast = sarBuffer[pIndex] > mBearishSarChanges[ArraySize(mBearishSarChanges) - 1].after; } // mHas = isSarBearish && HasChild(mBullishSarChanges); if (mHas) { isBearishSarBreakedLast = sarBuffer[pIndex] < mBullishSarChanges[ArraySize(mBullishSarChanges) - 1].after; } // // Counters ... // if (!isSarSwitchedToBullish && !isSarSwitchedToBearish) { // bool isDBullish = isSarBullish && isSarBullishP; if (isDBullish) { mSameBullishSarCount++; } // bool isDBearish = isSarBearish && isSarBearishP; if (isDBearish) { mSameBearishSarCount++; } // if (isDBullish || isDBearish) { mSameSarCount++; } } // // XHKS Shifts ... // // Detection ... if (isHKSSwitchedToBullish || isHKSSwitchedToBearish) { // mDirShift.at = iPBar.time; mDirShift.symbol = _Symbol; mDirShift.period = _Period; // mDirShift.type = "XHKSSHFT"; // mDirShift.after = 0; mDirShift.before = 0; // if (isHKSSwitchedToBullish) { // mDirShift.after = mHKSMax; mDirShift.before = mHKSPMax; mDirShift.shiftTo = X_DIRECTION_BULLISH; // if (mDirShift.IsValid()) { // AddIfNotExists( mDirShift, mBullishHKSChanges // ); } } // if (isHKSSwitchedToBearish) { // mDirShift.after = mHKSMin; mDirShift.before = mHKSPMin; mDirShift.shiftTo = X_DIRECTION_BEARISH; // if (mDirShift.IsValid()) { // AddIfNotExists( mDirShift, mBearishHKSChanges // ); } } // mDirShift.Clean(); } // // Parsers ... // mHas = isHKSBullish && HasChild(mBearishHKSChanges); if (mHas) { isBullishHKSBreakedLast = mHKSMin > mBearishHKSChanges[ArraySize(mBearishHKSChanges) - 1].after; } // mHas = isHKSBearish && HasChild(mBullishHKSChanges); if (mHas) { isBearishHKSBreakedLast = mHKSMax < mBullishHKSChanges[ArraySize(mBullishHKSChanges) - 1].after; } // // Counters ... // if (!isHKSSwitchedToBullish && !isHKSSwitchedToBearish) { // bool isDBullish = isHKSBullish && isHKSBullishP; if (isDBullish) { mSameBullishHKSCount++; } // bool isDBearish = isHKSBearish && isHKSBearishP; if (isDBearish) { mSameBearishHKSCount++; } // if (isDBullish || isDBearish) { mSameHKSCount++; } } // // XKI Shifts ... // // Detection ... if (isKISwitchedToBullish || isKISwitchedToBearish) { // mDirShift.at = iPBar.time; mDirShift.symbol = _Symbol; mDirShift.period = _Period; // mDirShift.type = "XKISHFT"; // mDirShift.after = kiBuffer[pIndex]; mDirShift.before = kiBuffer[p2Index]; // if (isKISwitchedToBullish) { // mDirShift.shiftTo = X_DIRECTION_BULLISH; // if (mDirShift.IsValid()) { // AddIfNotExists( mDirShift, mBullishKIChanges // ); } } // if (isKISwitchedToBearish) { // mDirShift.shiftTo = X_DIRECTION_BEARISH; // if (mDirShift.IsValid()) { // AddIfNotExists( mDirShift, mBearishKIChanges // ); } } // mDirShift.Clean(); } // // Parsers ... // mHas = isKIBullish && HasChild(mBearishKIChanges); if (mHas) { isBullishKIBreakedLast = kiBuffer[pIndex] > mBearishKIChanges[ArraySize(mBearishKIChanges) - 1].after; } // mHas = isKIBearish && HasChild(mBullishKIChanges); if (mHas) { isBearishKIBreakedLast = kiBuffer[pIndex] < mBullishKIChanges[ArraySize(mBullishKIChanges) - 1].after; } // // Counters ... // if (isSameKI) { mSameKICount++; } // if (isSameBullishKI) { mSameBullishKICount++; } // if (isSameBearishKI) { mSameBearishKICount++; } // // XTREND Shifts ... // // Detection ... if (isTrendSwitchedToBullish || isTrendSwitchedToBearish) { // mDirShift.at = iPBar.time; mDirShift.symbol = _Symbol; mDirShift.period = _Period; // mDirShift.type = "XTRENDSHFT"; // mDirShift.after = trendBuffer[pIndex]; mDirShift.before = trendBuffer[p2Index]; // if (isTrendSwitchedToBullish) { // mDirShift.shiftTo = X_DIRECTION_BULLISH; // if (mDirShift.IsValid()) { // AddIfNotExists( mDirShift, mBullishTrendChanges // ); } } // if (isTrendSwitchedToBearish) { // mDirShift.shiftTo = X_DIRECTION_BEARISH; // if (mDirShift.IsValid()) { // AddIfNotExists( mDirShift, mBearishTrendChanges // ); } } // mDirShift.Clean(); } // // Parsers ... // mHas = isTrendBullish && HasChild(mBearishTrendChanges); if (mHas) { isBullishTrendBreakedLast = trendBuffer[pIndex] > mBearishTrendChanges[ArraySize(mBearishTrendChanges) - 1].after; } // mHas = isTrendBearish && HasChild(mBullishTrendChanges); if (mHas) { isBearishTrendBreakedLast = trendBuffer[pIndex] < mBullishTrendChanges[ArraySize(mBullishTrendChanges) - 1].after; } // // Counters ... // if (!isTrendSwitchedToBullish && !isTrendSwitchedToBearish) { // bool isDBullish = isTrendBullish && isTrendBullishP; if (isDBullish) { mSameBullishTrendCount++; } // bool isDBearish = isTrendBearish && isTrendBearishP; if (isDBearish) { mSameBearishTrendCount++; } // if (isDBullish || isDBearish) { mSameTrendCount++; } } // // // // // Cleanup Resources ... // iBar.Clean(); iPBar.Clean(); mDirShift.Clean(); } /** * Detect POI(s) ... * * @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 DetectPOIs( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // // Check Some Requirements ... int lastBarIndex = barIndex + 1; int maxBarIndex = startCalculationForLastBars > 0 ? startCalculationForLastBars : ratesTotal; bool isFirstBar = startCalculationForLastBars > 0 ? barIndex == startCalculationForLastBars : barIndex == firstBarIndex; // // Recieve Bar ... XOHCL iBar; XOHCL iPBar; mHas = iBar.Init( _Symbol, _Period, barIndex // ); mHas = mHas && iBar.GetPreviousBar(iPBar); if (!mHas) { return; } // // Liquidities ... if (mDetectLiquidities) { // if (isLiquidity) { // XBoxZone iLiq; // iLiq.type = "XLIQ"; iLiq.symbol = _Symbol; iLiq.period = _Period; // if (isBullishLiquidity) { // iLiq.at = iBar.time; iLiq.lower = iBar.low; iLiq.to = iBar.NextAt(); iLiq.from = iBar.BeforeOn(); iLiq.upper = iBar.GetDown(); iLiq.dir = X_DIRECTION_BULLISH; // if (iLiq.IsValid()) { // AddIfNotExists( iLiq, mBullishLiquidities // ); } } // if (isBearishLiquidity) { // iLiq.at = iBar.time; iLiq.upper = iBar.high; iLiq.to = iBar.NextAt(); iLiq.lower = iBar.GetUp(); iLiq.from = iBar.BeforeOn(); iLiq.dir = X_DIRECTION_BEARISH; // if (iLiq.IsValid()) { // AddIfNotExists( iLiq, mBearishLiquidities // ); } } // iLiq.Clean(); } } // // Range Breakes ... int mRangeBreakesMinLength = 5; if (mDetectRangeBreakes) { // XBoxZone iRB; // iRB.type = "XRNGB"; iRB.at = iPBar.time; iRB.to = iPBar.time; iRB.symbol = _Symbol; iRB.period = _Period; // // Bullish ... bool isBullishPeakPOI = (isSamePeakOverLast && mSamePeakCount >= mRangeBreakesMinLength); bool isBullishValePOI = (isSameValeOverLast && mSameValeCount >= mRangeBreakesMinLength); mHas = isBullishPeakPOI || isBullishValePOI; if (mHas) { // if (isBullishPeakPOI) { // iRB.lower = mSamePeakGoldenMax; iRB.upper = peakBuffer[barIndex + 1]; // iRB.from = iPBar.time - (mSamePeakCount * PeriodSeconds(_Period)); } // if (isBullishValePOI) { // iRB.upper = mSameValeGoldenMin; iRB.lower = valeBuffer[barIndex + 1]; // iRB.from = iPBar.time - (mSameValeCount * PeriodSeconds(_Period)); } // iRB.dir = X_DIRECTION_BULLISH; // if (iRB.IsValid()) { // AddIfNotExists( iRB, mBullishRangeBreakes // ); } } // // Bearish ... bool isBearishPeakPOI = (isSamePeakUnderLast && mSamePeakCount >= mRangeBreakesMinLength); bool isBearishValePOI = (isSameValeUnderLast && mSameValeCount >= mRangeBreakesMinLength); mHas = isBearishPeakPOI || isBearishValePOI; if (mHas) { // if (isBearishPeakPOI) { // iRB.lower = mSamePeakGoldenMax; iRB.upper = peakBuffer[barIndex + 1]; // iRB.from = iPBar.time - (mSamePeakCount * PeriodSeconds(_Period)); } // if (isBearishValePOI) { // iRB.upper = mSameValeGoldenMin; iRB.lower = valeBuffer[barIndex + 1]; // iRB.from = iPBar.time - (mSameValeCount * PeriodSeconds(_Period)); } // iRB.dir = X_DIRECTION_BEARISH; // if (iRB.IsValid()) { // AddIfNotExists( iRB, mBearishRangeBreakes // ); } } // iRB.Clean(); } // // Cleanup Resources ... // iBar.Clean(); iPBar.Clean(); } /** * Validate Detected POI(s) ... * * @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 ValidatePOIs( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // int barsLength = 3; // // Liquidities ... // // Bullish ... mHas = HasChild(mBullishLiquidities); if (mHas) { // ValidateBoxes( mBullishLiquidities, barIndex, barsLength // ); } // // Bearish ... mHas = HasChild(mBearishLiquidities); if (mHas) { // ValidateBoxes( mBearishLiquidities, barIndex, barsLength // ); } // // Range Breakes ... // // Bullish ... mHas = HasChild(mBullishRangeBreakes); if (mHas) { // ValidateBoxes( mBullishRangeBreakes, barIndex, barsLength // ); } // // Bearish ... mHas = HasChild(mBearishRangeBreakes); if (mHas) { // ValidateBoxes( mBearishRangeBreakes, barIndex, barsLength // ); } // } /** * Draw Detected POI(s) ... * * @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 DrawPOIs( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // datetime to = GetBarTime( _Symbol, _Period, barIndex // ); // // Liquidities ... if (mDrawLiquidities) { // // Bullish ... mCount = ArraySize(mBullishLiquidities); mHas = IsValidSize(mCount); if (mHas) { // for (int i = 0; i < mCount; i++) { // XBoxZone iBox = mBullishLiquidities[i]; iBox.to = to; // XCBoxObject *iBObj; mHas = mDrawer.DrawBox( iBox, iBObj // ); if (mHas) { // if (iBox.IsBullish()) { // mDrawer.ApplyStyle( iBObj, mBullishLiquidityStyle // ); } else { // mDrawer.ApplyStyle( iBObj, mBearishLiquidityStyle // ); } // mObjects.Add(iBObj); } // iBox.Clean(); } } // // Bearish ... mCount = ArraySize(mBearishLiquidities); mHas = IsValidSize(mCount); if (mHas) { // for (int i = 0; i < mCount; i++) { // XBoxZone iBox = mBearishLiquidities[i]; iBox.to = to; // XCBoxObject *iBObj; mHas = mDrawer.DrawBox( iBox, iBObj // ); if (mHas) { // if (iBox.IsBullish()) { // mDrawer.ApplyStyle( iBObj, mBullishLiquidityStyle // ); } else { // mDrawer.ApplyStyle( iBObj, mBearishLiquidityStyle // ); } // mObjects.Add(iBObj); } // iBox.Clean(); } } } // // Range Breakes ... if (mDrawRangeBreakes) { // // Bullish ... mCount = ArraySize(mBullishRangeBreakes); mHas = IsValidSize(mCount); if (mHas) { // for (int i = 0; i < mCount; i++) { // XBoxZone iBox = mBullishRangeBreakes[i]; iBox.to = to; // XCBoxObject *iBObj; mHas = mDrawer.DrawBox( iBox, iBObj // ); if (mHas) { // if (iBox.IsBullish()) { // mDrawer.ApplyStyle( iBObj, mBullishRangeBreakStyle // ); } else { // mDrawer.ApplyStyle( iBObj, mBearishRangeBreakStyle // ); } // mObjects.Add(iBObj); } // iBox.Clean(); } } // // Bearish ... mCount = ArraySize(mBearishRangeBreakes); mHas = IsValidSize(mCount); if (mHas) { // for (int i = 0; i < mCount; i++) { // XBoxZone iBox = mBearishRangeBreakes[i]; iBox.to = to; // XCBoxObject *iBObj; mHas = mDrawer.DrawBox( iBox, iBObj // ); if (mHas) { // if (iBox.IsBullish()) { // mDrawer.ApplyStyle( iBObj, mBullishRangeBreakStyle // ); } else { // mDrawer.ApplyStyle( iBObj, mBearishRangeBreakStyle // ); } // mObjects.Add(iBObj); } // iBox.Clean(); } } } } /** * Process Custom Analysing Senarios ... * * @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 DoProcess( int barIndex, const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // // Here we Can Detect Conditions ... // // Check Some Requirements ... int lastBarIndex = barIndex + 1; int maxBarIndex = startCalculationForLastBars > 0 ? startCalculationForLastBars : ratesTotal; bool isFirstBar = startCalculationForLastBars > 0 ? barIndex == startCalculationForLastBars : barIndex == firstBarIndex; // // Recieve Bar ... XOHCL iBar; XOHCL iPBar; mHas = iBar.Init( _Symbol, _Period, barIndex // ); mHas = mHas && iBar.GetPreviousBar(iPBar); if (!mHas) { return; } // // Trigger Bar's Conditions ... // // Bullish ... bool isTBBullish = // iBar.IsBullish() && isTriggerBarBullish && iBar.low > iPBar.low // ; // // Bearish ... bool isTBBearish = // iBar.IsBearish() && isTriggerBarBearish && iBar.high < iPBar.high // ; // // KI Breakes Validation Conditions ... // // Bullish ... bool isKIBullishBreakes = // isKIBullish && iBar.IsBullish() && iPBar.IsBreaked( kiBuffer[barIndex + 1], X_DIRECTION_BULLISH, X_FIBO_LEVEL_500, // Fibo Level ... X_BOUNDARY_PRICE_HIGH_LOW // Boundary Type ... ) // ; // // Bearish ... bool isKIBearishBreakes = // isKIBearish && iBar.IsBearish() && iPBar.IsBreaked( kiBuffer[barIndex + 1], X_DIRECTION_BEARISH, X_FIBO_LEVEL_500, // Fibo Level ... X_BOUNDARY_PRICE_HIGH_LOW // Boundary Type ... ) // ; // // Conditions By ... // - Rejecting Trend Line; // - Trend Line is Over HK; // - SAR Directional; // - KI Directional; // - HKS Directional; // bool isTrendsBasedBullish = // isKIBullish && isSarBullish && isHKSBullish && // // TODO: Implement Trend Line is Over HKS MAX ... // // Rejectiong Trend Line ... iPBar.IsBullish() && iPBar.low < trendBuffer[barIndex + 1] && iPBar.GetDown() > trendBuffer[barIndex + 1] // ; // bool isTrendBasedBearish = // isKIBearish && isSarBearish && isHKSBearish && // // TODO: Implement Trend Line is Under HKS MIN ... // // Rejecting Trend Line ... iPBar.IsBearish() && iPBar.high > trendBuffer[barIndex + 1] && iPBar.GetUp() < trendBuffer[barIndex + 1] // ; // // Summarization Conditions ... // // Bullish ... mIsBullish = // // false // isTBBullish && // isKIBullishBreakes isTrendsBasedBullish // ; // // Bearish ... mIsBearish = // // false // isTBBearish && // isKIBearishBreakes isTrendBasedBearish // ; // // Signal Summarize ... mHasSignal = mIsBullish || mIsBearish; // // Handling Signal ... if (mHasSignal) { // // Creating Signal Box ... mSignalBox.type = "XSGB"; mSignalBox.at = iBar.time; mSignalBox.to = iBar.time; mSignalBox.symbol = _Symbol; mSignalBox.period = _Period; mSignalBox.lower = iPBar.low; mSignalBox.from = iPBar.time; mSignalBox.upper = iPBar.high; mSignalBox.dir = mIsBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // // Converting Box to Signal ... double rrs[] = { 1, 1.5, 2, 3 // }; mHas = ToSignal( mSignalBox, mSignal, rrs, // Risk To Reward Ratios ... 0 // Additional SL ... ); // // Draw Signal Box ... if (mDrawSignalBoxes) { // mHas = mSignalBox.IsValid(); if (mHas) { // XCBoxObject *iSignalBoxObj; mHas = mDrawer.DrawBox( mSignalBox, iSignalBoxObj, !mDrawSignalBoxAtLines // ); // if (mHas) { // // Styling Object ... if (mSignalBox.IsBullish()) { // mDrawer.ApplyStyle( iSignalBoxObj, mBullishSignalBoxStyle // ); } else { // mDrawer.ApplyStyle( iSignalBoxObj, mBearishSignalBoxStyle // ); } // // Storing Object ... mObjects.Add(iSignalBoxObj); } // ZeroMemory(iSignalBoxObj); } } // // Draw Signal ... if (mDrawSignals) { // mHas = mSignal.IsValid(); if (mHas) { // XCSignalObject *iSignalObj; mHas = mDrawer.DrawSignal( mSignal, iSignalObj, 3 // ); // if (mHas) { mObjects.Add(iSignalObj); } // ZeroMemory(iSignalObj); } } // // Draw Arrows ... if (mDrawSignalArrows) { // int arrowWidth = 3; int arrowCode = mIsBullish ? _bullishArrowCode : _bearishArrowCode; ENUM_X_PRICE arrowPriceType = mIsBullish ? X_PRICE_LOW : X_PRICE_HIGH; color arrowColor = mIsBullish ? _bullishArrowColor : _bearishArrowColor; ENUM_ARROW_ANCHOR arrowAnchor = mIsBullish ? mBullishAnchor : mBearishAnchor; // XCBarArrowObject *iSignalArrowObj; mHas = mDrawer.CreateBarArrow( iBar, iSignalArrowObj, arrowPriceType, arrowCode, arrowColor, arrowWidth, arrowAnchor, mArrowNamePrefix // ); if (mHas) { mObjects.Add(iSignalArrowObj); } // ZeroMemory(iSignalArrowObj); } } // // Cleanup Resources ... // iBar.Clean(); iPBar.Clean(); mSignal.Clean(); mSignalBox.Clean(); // mArrowNamePrefix = NULL; } //