/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Helper Class Library // ---------------------------------------------- // Name: XSCXMANHelper // Description: provides all Indicator // Helper requirements ... // // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... #property library #property copyright "Copyright 2023, SaherElm IT Center" #property link "https://www.saherelm.ir" #property version "1.00" #property strict // // START Definitions ... // // // All Extractable Buffers ... enum ENUM_XMAN_BUFFERS { // // Peaks and Vales ... XMAN_PEAKS_LINE = 0, // Peaks XMAN_VALES_LINE = 1, // Vales XMAN_PEAKS_STATE_LINE = 69, // New Peak XMAN_VALES_STATE_LINE = 70, // New Vales // // Fibonacci Retracement ... XMAN_FIB_L1_LINE = 6, // Fibo Level 1 XMAN_FIB_L2_LINE = 8, // Fibo Level 2 XMAN_FIB_L3_LINE = 10, // Fibo Level 3 XMAN_FIB_L4_LINE = 12, // Fibo Level 3 XMAN_FIB_L5_LINE = 14, // Fibo Level 3 // // Period Cycles ... // // Short Cycle ... XMAN_SC_HH_LINE = 16, // High XMAN_SC_LL_LINE = 18, // Low XMAN_SC_HH_STATE_LINE = 71, // High State XMAN_SC_LL_STATE_LINE = 72, // Low State // // Medium ... XMAN_MC_HH_LINE = 20, // High XMAN_MC_LL_LINE = 22, // Low XMAN_MC_HH_STATE_LINE = 73, // High State XMAN_MC_LL_STATE_LINE = 74, // Low State // // Long ... XMAN_LC_HH_LINE = 24, // High XMAN_LC_LL_LINE = 26, // Low XMAN_LC_HH_STATE_LINE = 75, // High State XMAN_LC_LL_STATE_LINE = 76, // Low State // // Hind ... XMAN_HC_HH_LINE = 28, // High XMAN_HC_LL_LINE = 30, // Low XMAN_HC_HH_STATE_LINE = 77, // High State XMAN_HC_LL_STATE_LINE = 78, // Low State // // XSTR ... XMAN_TREND_LINE = 34, // Trend Value XMAN_TREND_STATE_LINE = 79, // Trend Direction // // XMRB ... // // RIBBON 1 _ HIGH ... XMAN_RB1_LINE = 36, // Value XMAN_RB1_STATE_LINE = 80, // State // // RIBBON 2 _ OPEN ... XMAN_RB2_LINE = 38, // Value XMAN_RB2_STATE_LINE = 81, // State // // RIBBON 3 _ CLOSE ... XMAN_RB3_LINE = 40, // Value XMAN_RB3_STATE_LINE = 82, // State // // RIBBON 4 _ MEDIAN ... XMAN_RB4_LINE = 42, // Value XMAN_RB4_STATE_LINE = 83, // State // // RIBBON 5 _ TYPICAL ... XMAN_RB5_LINE = 44, // Value XMAN_RB5_STATE_LINE = 84, // State // // RIBBON 6 _ LOW ... XMAN_RB6_LINE = 46, // Value XMAN_RB6_STATE_LINE = 85, // State // // XSSLC ... XMAN_SSLC_UP_LINE = 48, // Up XMAN_SSLC_DOWN_LINE = 50, // Down // // XHULL ... XMAN_HULL_UP_LINE = 52, // Up XMAN_HULL_DOWN_LINE = 54, // Down XMAN_HULL_UP_STATE_LINE = 86, // Up State XMAN_HULL_DOWN_STATE_LINE = 87, // Down State // // XHK ... XMAN_HK_OPEN_LINE = 56, // Open XMAN_HK_HIGH_LINE = 57, // High XMAN_HK_LOW_LINE = 58, // Low XMAN_HK_CLOSE_LINE = 59, // Close XMAN_HK_STATE_LINE = 88, // State }; // // Define States On XMAN ... enum ENUM_XMAN_STATES { XMAN_STATE_BULLISH = 2, XMAN_STATE_STRONG_BULLISH = 8, XMAN_STATE_BEARISH = 3, XMAN_STATE_STRONG_BEARISH = 9, XMAN_STATE_NEUTURAL = 1, XMAN_STATE_STRONG_NEUTURAL = 7, }; // // XPERIOD Calculation Method ... // USED For Multiple Time Frames ... enum ENUM_X_PERIOD_METHOD { // X_PERIOD_NOTHING, // Nothing X_PERIOD_AUTO, // Auto Select X_PERIOD_MANUALLY // Manually }; // enum ENUM_X_MA_METHOD { X_MA_NOTHING, // Nothing X_MA_SMA, // Simple X_MA_EMA, // Expotential X_MA_SMMA, // Smoothed Simple X_MA_LWMA, // Linear Weighted X_MA_AMA // Adaptive }; // // Model all required info as a Model for Instancing Helper Class ... struct XMANInputs { // // Candle Timer ... color candleTimerColor; // Text Color ENUM_BASE_CORNER candleTimerCorner; // Text Position // // Chart Style ... color upColor; // Up Color color downColor; // Down Color color lineColor; // Line mode and Doji candlestick Color color bearishColor; // Bullish Color color bullishColor; // Bearish Color color volumesColor; // Volumes Color ENUM_CHART_MODE chartMode; // Chart Mode // // Market Cycles ... // // Level 1 ... ENUM_X_PERIOD_METHOD l1Method; // How to Find Period ENUM_TIMEFRAMES l1Period; // Time Period // // Level 2 ... ENUM_X_PERIOD_METHOD l2Method; // How to Find Period ENUM_TIMEFRAMES l2Period; // Time Period // // Level 3 ... ENUM_X_PERIOD_METHOD l3Method; // How to Find Period ENUM_TIMEFRAMES l3Period; // Time Period // // Level 4 ... ENUM_X_PERIOD_METHOD l4Method; // How to Find Period ENUM_TIMEFRAMES l4Period; // Time Period // // Fibonacci ... double fiboLevel1; // Fibio 1st Level double fiboLevel2; // Fibio 2st Level double fiboLevel3; // Fibio 3rd Level double fiboLevel4; // Fibio 4th Level double fiboLevel5; // Fibio 5th Level // // Boundary Detection Modes ... ENUM_SERIESMODE hhMode; // Highest High Calculation Method ENUM_SERIESMODE llMode; // Lowest Low Calculation Method // // Trend Detection double trendMultiplier; // Multiplier ENUM_APPLIED_PRICE trendPriceAppliedTo; // Applied To // // Ribbon Detection ... ENUM_X_MA_METHOD ribbonMode; // How to Calculate // // Hull Trend Detection ... double hullDivisor; // Divisor (Speed) ENUM_APPLIED_PRICE hullUpAppliedTo; // Up Zone Applied to ENUM_APPLIED_PRICE hullDownAppliedTo; // Down Zone Applied to // // SSL Channel Detection ... ENUM_X_MA_METHOD sslcMode; // How to Calculate ENUM_APPLIED_PRICE sslcUpAppliedTo; // Up Applied To ENUM_APPLIED_PRICE sslcDownAppliedTo; // Down Applied To // // Presentation ... bool showCandleTimer; // Show Candle Time bool showCandles; // Show Candles bool showHKCandles; // Draw Hiken Ashi Candle bool showPeaksAndVales; // Show Peaks and Vales bool showTrends; // Show Trends bool fillTrends; // Fill Trends bool showLevels; // Show Levels bool showConsolidations; // Show Consolidations bool showRibbons; // Show Ribbons bool showHull; // Show Hull bool showSSLChannel; // Show SSL Channel bool showFibo1Levels; // Show Fibo 1st Level bool showFibo2Levels; // Show Fibo 2nd Level bool showFibo3Levels; // Show Fibo 3rd Level bool showFibo4Levels; // Show Fibo 4th Level bool showFibo5Levels; // Show Fibo 5th Level }; // // Model all Extractable Info as a Model for Market Analyzing ... struct XMANInfo { // // COMMONS ... // // Symbol ... string symbol; // // Period ... ENUM_TIMEFRAMES period; // // Bar Time ... datetime barTime; // // Bar Index ... int barIndex; // // SPECIALS ... // // Buffers ... // // Peaks and Vales ... double peaks[]; double peaksStates[]; double vales[]; double valesStates[]; // // Fibonacci ... double fibLevel1s[]; double fibLevel2s[]; double fibLevel3s[]; double fibLevel4s[]; double fibLevel5s[]; // // Cycles ... // // Short ... double sHHs[]; double sHHStates[]; double sLLs[]; double sLLStates[]; // // Medium ... double mHHs[]; double mHHStates[]; double mLLs[]; double mLLStates[]; // // Long ... double lHHs[]; double lHHStates[]; double lLLs[]; double lLLStates[]; // // Hind ... double hHHs[]; double hHHStates[]; double hLLs[]; double hLLStates[]; // // Trends ... double trends[]; double trendStates[]; // // Ribbons ... // // 1 _ High ... double ribbon1s[]; double ribbon1States[]; // // 2 _ Open ... double ribbon2s[]; double ribbon2States[]; // // 3 _ Close ... double ribbon3s[]; double ribbon3States[]; // // 4 _ Median ... double ribbon4s[]; double ribbon4States[]; // // 5 _ Typical ... double ribbon5s[]; double ribbon5States[]; // // 6 _ Low ... double ribbon6s[]; double ribbon6States[]; // // SSL Channel ... double sslcUps[]; double sslcDowns[]; // // Hull Trend ... double hullUps[]; double hullUpStates[]; double hullDowns[]; double hullDownStates[]; // // Hiken Ashi ... double hkOpens[]; double hkHighs[]; double hkLows[]; double hkCloses[]; double hkStates[]; // // Conditions ... // // Peaks and Vales ... bool isNewPeak; bool isNewVale; // // Trend ... bool isTrendBullish; bool isTrendSwitchedToBullish; bool isTrendBearish; bool isTrendSwitchedToBearish; bool isTrendNeutural; bool isTrendSwitchedToNeutural; // // SSL Channel ... bool isSSLCBullish; bool isSSLCSwitchedToBullish; bool isSSLCBearish; bool isSSLCSwitchedToBearish; bool isSSLCNeutural; bool isSSLCSwitchedToNeutural; // // Hull Trend ... // bool isHullBullish; bool isHullUpBullish; bool isHullDownBullish; bool isHullSwitchedToBullish; // bool isHullBearish; bool isHullUpBearish; bool isHullDownBearish; bool isHullSwitchedToBearish; // bool isHullNeutural; bool isHullUpNeutural; bool isHullDownNeutural; bool isHullSwitchedToNeutural; // // HK ... bool isHKBullish; bool isHKBearish; // // Market Cycles ... // // Short ... // bool isSCBullish; bool isSCHBullish; bool isSCLBullish; bool isSCSwitchedToBullish; bool isSCHSwitchedToBullish; bool isSCLSwitchedToBullish; // bool isSCBearish; bool isSCHBearish; bool isSCLBearish; bool isSCSwitchedToBearish; bool isSCHSwitchedToBearish; bool isSCLSwitchedToBearish; // bool isSCNeutural; bool isSCHNeutural; bool isSCLNeutural; bool isSCSwitchedToNeutural; bool isSCHSwitchedToNeutural; bool isSCLSwitchedToNeutural; // // Medium ... // bool isMCBullish; bool isMCHBullish; bool isMCLBullish; bool isMCSwitchedToBullish; bool isMCHSwitchedToBullish; bool isMCLSwitchedToBullish; // bool isMCBearish; bool isMCHBearish; bool isMCLBearish; bool isMCSwitchedToBearish; bool isMCHSwitchedToBearish; bool isMCLSwitchedToBearish; // bool isMCNeutural; bool isMCHNeutural; bool isMCLNeutural; bool isMCSwitchedToNeutural; bool isMCHSwitchedToNeutural; bool isMCLSwitchedToNeutural; // // Long ... // bool isLCBullish; bool isLCHBullish; bool isLCLBullish; bool isLCSwitchedToBullish; bool isLCHSwitchedToBullish; bool isLCLSwitchedToBullish; // bool isLCBearish; bool isLCHBearish; bool isLCLBearish; bool isLCSwitchedToBearish; bool isLCHSwitchedToBearish; bool isLCLSwitchedToBearish; // bool isLCNeutural; bool isLCHNeutural; bool isLCLNeutural; bool isLCSwitchedToNeutural; bool isLCHSwitchedToNeutural; bool isLCLSwitchedToNeutural; // // Hind ... // bool isHCBullish; bool isHCHBullish; bool isHCLBullish; bool isHCSwitchedToBullish; bool isHCHSwitchedToBullish; bool isHCLSwitchedToBullish; // bool isHCBearish; bool isHCHBearish; bool isHCLBearish; bool isHCSwitchedToBearish; bool isHCHSwitchedToBearish; bool isHCLSwitchedToBearish; // bool isHCNeutural; bool isHCHNeutural; bool isHCLNeutural; bool isHCSwitchedToNeutural; bool isHCHSwitchedToNeutural; bool isHCLSwitchedToNeutural; // // Ribbons ... // // R1 ... // bool isRibbon1Bullish; bool isRibbon2Bullish; bool isRibbon3Bullish; bool isRibbon4Bullish; bool isRibbon5Bullish; bool isRibbon6Bullish; // bool isRibbon1Bearish; bool isRibbon2Bearish; bool isRibbon3Bearish; bool isRibbon4Bearish; bool isRibbon5Bearish; bool isRibbon6Bearish; // bool isRibbon1Neutural; bool isRibbon2Neutural; bool isRibbon3Neutural; bool isRibbon4Neutural; bool isRibbon5Neutural; bool isRibbon6Neutural; // bool isRibbonBullish; bool isRibbonSwitchedToBullish; // bool isRibbonBearish; bool isRibbonSwitchedToBearish; // bool isRibbonNeutural; bool isRibbonSwitchedToNeutural; }; // // END Definitions ... // // // START Import and Inclused requirements ... // // // Includes ... #include "../Libraries/x-saherelm.common.lib.mq5" #include "../Classes/x-saherelm.xhelper.class.mq5" // // END Import and Inclused requirements ... // // // START Overrides ... // // // END Overrides ... // // class XSCXMANHelper : public XSCBaseHelper { // // Public ... public: // // Props ... // // Peaks and Vales ... double peaksBuffer[]; double peaksStateBuffer[]; double valesBuffer[]; double valesStateBuffer[]; // // Fibonacci ... double fibLevel1Buffer[]; double fibLevel2Buffer[]; double fibLevel3Buffer[]; double fibLevel4Buffer[]; double fibLevel5Buffer[]; // // Cycles ... // // Short ... double sHHBuffer[]; double sHHStateBuffer[]; double sLLBuffer[]; double sLLStateBuffer[]; // // Medium ... double mHHBuffer[]; double mHHStateBuffer[]; double mLLBuffer[]; double mLLStateBuffer[]; // // Long ... double lHHBuffer[]; double lHHStateBuffer[]; double lLLBuffer[]; double lLLStateBuffer[]; // // Hind ... double hHHBuffer[]; double hHHStateBuffer[]; double hLLBuffer[]; double hLLStateBuffer[]; // // Trends ... double trendBuffer[]; double trendStateBuffer[]; // // Ribbons ... // // 1 _ High ... double ribbon1Buffer[]; double ribbon1StateBuffer[]; // // 2 _ Open ... double ribbon2Buffer[]; double ribbon2StateBuffer[]; // // 3 _ Close ... double ribbon3Buffer[]; double ribbon3StateBuffer[]; // // 4 _ Median ... double ribbon4Buffer[]; double ribbon4StateBuffer[]; // // 5 _ Typical ... double ribbon5Buffer[]; double ribbon5StateBuffer[]; // // 6 _ Low ... double ribbon6Buffer[]; double ribbon6StateBuffer[]; // // SSL Channel ... double sslUpBuffer[]; double sslDownBuffer[]; // // Hull Trend ... double hullUpBuffer[]; double hullUpStateBuffer[]; double hullDownBuffer[]; double hullDownStateBuffer[]; // // Hiken Ashi ... double hkOpenBuffer[]; double hkHighBuffer[]; double hkLowBuffer[]; double hkCloseBuffer[]; double hkStateBuffer[]; // // Constructor ... void XSCXMANHelper( string symbol, // Trading Symbol ENUM_TIMEFRAMES period // Trading Time Frame ) : XSCBaseHelper(symbol, period) { PrepareTag(); } // // Deconstructor ... void ~XSCXMANHelper() { } // // START Properties ... // // // END Properties ... // // // START Provided Functions ... // // // Prepare Tag ... virtual void PrepareTag() { mTag = "XMAN" + GetTagPrefix(); } // virtual int GetMaxLength() { // int result = 1; // result = 1; // return result; } // // Initial Indicator Handler ... bool Init() { // bool result = false; // // Validate Args ... result = // // L1 ... // Short Cycle ... ( // mL1Method == X_PERIOD_AUTO ? mL1Period == NULL : mL1Period != NULL && mL1Method != X_PERIOD_NOTHING // ) // && // // L2 ... // Medium Cycle ... ( // mL2Method == X_PERIOD_AUTO ? mL2Period == NULL : mL2Period != NULL && mL2Method != X_PERIOD_NOTHING // ) // && // // L3 ... // Long Cycle ... ( // mL3Method == X_PERIOD_AUTO ? mL3Period == NULL : mL3Period != NULL && mL3Method != X_PERIOD_NOTHING // ) // && // // L4 ... // Hind Cycle ... ( // mL4Method == X_PERIOD_AUTO ? mL4Period == NULL : mL4Period != NULL && mL4Method != X_PERIOD_NOTHING // ) // && // // Validate Ribbon ... ( // mRibbonMode != X_MA_NOTHING // ) // ; if (!result) { return false; } // // Initialize Handler ... mHandler = iCustom( // mSymbol, mPeriod, "x-saherelm.x121.xman", // // Inputs ... // // Candle Timer ... "", // mCandleTimerColor, // Text Color mCandleTimerCorner, // Text Position // // Chart Style ... // "", // mUpColor, // Up Color mDownColor, // Down Color mLineColor, // Line mode and Doji candlestick Color mBearishColor, // Bullish Color mBullishColor, // Bearish Color mVolumesColor, // Volumes Color mChartMode, // Chart Mode // // Market Cycles ... // "", // // Level 1 ... "", // mL1Method, // How to Find Period mL1Period, // Time Period // // Level 2 ... "", // mL2Method, // How to Find Period mL2Period, // Time Period // // Level 3 ... "", // mL3Method, // How to Find Period mL3Period, // Time Period // // Level 4 ... "", // mL4Method, // How to Find Period mL4Period, // Time Period // // Fibonacci ... "", // mFiboLevel1, // Fibio 1st Level mFiboLevel2, // Fibio 2st Level mFiboLevel3, // Fibio 3rd Level mFiboLevel4, // Fibio 4th Level mFiboLevel5, // Fibio 5th Level // // Boundary Detection Modes ... "", // mHHMode, // Highest High Calculation Method mLLMode, // Lowest Low Calculation Method // // Trend Detection "", // mTrendMultiplier, // Multiplier mTrendPriceAppliedTo, // Applied To // // Ribbon Detection ... "", // mRibbonMode, // How to Calculate // // Hull Trend Detection ... "", // mHullDivisor, // Divisor (Speed) mHullUpAppliedTo, // Up Zone Applied to mHullDownAppliedTo, // Down Zone Applied to // // SSL Channel Detection ... "", // mSslcMode, // How to Calculate mSslcUpAppliedTo, // Up Applied To mSslcDownAppliedTo, // Down Applied To // // Presentation ... "", // mShowCandleTimer, // Show Candle Timer mShowCandles, // Show Candles mShowHKCandles, // Draw Hiken Ashi Candle mShowPeaksAndVales, // Show Peaks and Vales mShowTrends, // Show Trends mSillTrends, // Fill Trends mShowLevels, // Show Levels mShowConsolidations, // Show Consolidations mShowRibbons, // Show Ribbons mShowHull, // Show Hull mShowSSLChannel, // Show SSL Channel mShowFibo1Levels, // Show Fibo 1st Level mShowFibo2Levels, // Show Fibo 2nd Level mShowFibo3Levels, // Show Fibo 3rd Level mShowFibo4Levels, // Show Fibo 4th Level mShowFibo5Levels // Show Fibo 5th Level // ); result = mHandler != INVALID_HANDLE; // return result; } // // Retrieve Current Config ... XMANInputs GetConfig() { // XMANInputs result; // result.candleTimerColor = mCandleTimerColor; result.candleTimerCorner = mCandleTimerCorner; result.upColor = mUpColor; result.downColor = mDownColor; result.lineColor = mLineColor; result.bearishColor = mBearishColor; result.bullishColor = mBullishColor; result.volumesColor = mVolumesColor; result.chartMode = mChartMode; result.l1Method = mL1Method; result.l1Period = mL1Period; result.l2Method = mL2Method; result.l2Period = mL2Period; result.l3Method = mL3Method; result.l3Period = mL3Period; result.l4Method = mL4Method; result.l4Period = mL4Period; result.fiboLevel1 = mFiboLevel1; result.fiboLevel2 = mFiboLevel2; result.fiboLevel3 = mFiboLevel3; result.fiboLevel4 = mFiboLevel4; result.fiboLevel5 = mFiboLevel5; result.hhMode = mHHMode; result.llMode = mLLMode; result.trendMultiplier = mTrendMultiplier; result.trendPriceAppliedTo = mTrendPriceAppliedTo; result.ribbonMode = mRibbonMode; result.hullDivisor = mHullDivisor; result.hullUpAppliedTo = mHullUpAppliedTo; result.hullDownAppliedTo = mHullDownAppliedTo; result.sslcMode = mSslcMode; result.sslcUpAppliedTo = mSslcUpAppliedTo; result.sslcDownAppliedTo = mSslcDownAppliedTo; result.showCandleTimer = mShowCandleTimer; result.showCandles = mShowCandles; result.showHKCandles = mShowHKCandles; result.showPeaksAndVales = mShowPeaksAndVales; result.showTrends = mShowTrends; result.fillTrends = mSillTrends; result.showLevels = mShowLevels; result.showConsolidations = mShowConsolidations; result.showRibbons = mShowRibbons; result.showHull = mShowHull; result.showSSLChannel = mShowSSLChannel; result.showFibo1Levels = mShowFibo1Levels; result.showFibo2Levels = mShowFibo2Levels; result.showFibo3Levels = mShowFibo3Levels; result.showFibo4Levels = mShowFibo4Levels; result.showFibo5Levels = mShowFibo5Levels; // return result; } // // Set Config ... bool SetConfig(XMANInputs &config) { // bool result = false; // mCandleTimerColor = config.candleTimerColor; mCandleTimerCorner = config.candleTimerCorner; mUpColor = config.upColor; mDownColor = config.downColor; mLineColor = config.lineColor; mBearishColor = config.bearishColor; mBullishColor = config.bullishColor; mVolumesColor = config.volumesColor; mChartMode = config.chartMode; mL1Method = config.l1Method; mL1Period = config.l1Period; mL2Method = config.l2Method; mL2Period = config.l2Period; mL3Method = config.l3Method; mL3Period = config.l3Period; mL4Method = config.l4Method; mL4Period = config.l4Period; mFiboLevel1 = config.fiboLevel1; mFiboLevel2 = config.fiboLevel2; mFiboLevel3 = config.fiboLevel3; mFiboLevel4 = config.fiboLevel4; mFiboLevel5 = config.fiboLevel5; mHHMode = config.hhMode; mLLMode = config.llMode; mTrendMultiplier = config.trendMultiplier; mTrendPriceAppliedTo = config.trendPriceAppliedTo; mRibbonMode = config.ribbonMode; mHullDivisor = config.hullDivisor; mHullUpAppliedTo = config.hullUpAppliedTo; mHullDownAppliedTo = config.hullDownAppliedTo; mSslcMode = config.sslcMode; mSslcUpAppliedTo = config.sslcUpAppliedTo; mSslcDownAppliedTo = config.sslcDownAppliedTo; mShowCandleTimer = config.showCandleTimer; mShowCandles = config.showCandles; mShowHKCandles = config.showHKCandles; mShowPeaksAndVales = config.showPeaksAndVales; mShowTrends = config.showTrends; mSillTrends = config.fillTrends; mShowLevels = config.showLevels; mShowConsolidations = config.showConsolidations; mShowRibbons = config.showRibbons; mShowHull = config.showHull; mShowSSLChannel = config.showSSLChannel; mShowFibo1Levels = config.showFibo1Levels; mShowFibo2Levels = config.showFibo2Levels; mShowFibo3Levels = config.showFibo3Levels; mShowFibo4Levels = config.showFibo4Levels; mShowFibo5Levels = config.showFibo5Levels; // result = Init(); // return result; } // // Reading Buffers based on Given Bar Index ... virtual void Calculate( int barIndex // Given Bar Index ) { // // Peaks ... ArraySetAsSeries(peaksBuffer, true); CopyBuffer( mHandler, XMAN_PEAKS_LINE, barIndex, mLoopbackBars, peaksBuffer); // // Peaks State ... ArraySetAsSeries(peaksStateBuffer, true); CopyBuffer( mHandler, XMAN_PEAKS_STATE_LINE, barIndex, mLoopbackBars, peaksStateBuffer); // // Vales ... ArraySetAsSeries(valesBuffer, true); CopyBuffer( mHandler, XMAN_VALES_LINE, barIndex, mLoopbackBars, valesBuffer); // // Vales State ... ArraySetAsSeries(valesStateBuffer, true); CopyBuffer( mHandler, XMAN_VALES_STATE_LINE, barIndex, mLoopbackBars, valesStateBuffer); // // Fibo 1 ... ArraySetAsSeries(fibLevel1Buffer, true); CopyBuffer( mHandler, XMAN_FIB_L1_LINE, barIndex, mLoopbackBars, fibLevel1Buffer); // // Fibo 2 ... ArraySetAsSeries(fibLevel2Buffer, true); CopyBuffer( mHandler, XMAN_FIB_L2_LINE, barIndex, mLoopbackBars, fibLevel2Buffer); // // Fibo 3 ... ArraySetAsSeries(fibLevel3Buffer, true); CopyBuffer( mHandler, XMAN_FIB_L3_LINE, barIndex, mLoopbackBars, fibLevel3Buffer); // // Fibo 4 ... ArraySetAsSeries(fibLevel4Buffer, true); CopyBuffer( mHandler, XMAN_FIB_L4_LINE, barIndex, mLoopbackBars, fibLevel4Buffer); // // Fibo 5 ... ArraySetAsSeries(fibLevel5Buffer, true); CopyBuffer( mHandler, XMAN_FIB_L5_LINE, barIndex, mLoopbackBars, fibLevel5Buffer); // // Cycles ... // // Short ... // // High ... ArraySetAsSeries(sHHBuffer, true); CopyBuffer( mHandler, XMAN_SC_HH_LINE, barIndex, mLoopbackBars, sHHBuffer); // // High State ... ArraySetAsSeries(sHHStateBuffer, true); CopyBuffer( mHandler, XMAN_SC_HH_STATE_LINE, barIndex, mLoopbackBars, sHHStateBuffer); // // High ... ArraySetAsSeries(sLLBuffer, true); CopyBuffer( mHandler, XMAN_SC_LL_LINE, barIndex, mLoopbackBars, sLLBuffer); // // High State ... ArraySetAsSeries(sLLStateBuffer, true); CopyBuffer( mHandler, XMAN_SC_LL_STATE_LINE, barIndex, mLoopbackBars, sLLStateBuffer); // // Medium ... // // High ... ArraySetAsSeries(mHHBuffer, true); CopyBuffer( mHandler, XMAN_MC_HH_LINE, barIndex, mLoopbackBars, mHHBuffer); // // High State ... ArraySetAsSeries(mHHStateBuffer, true); CopyBuffer( mHandler, XMAN_MC_HH_STATE_LINE, barIndex, mLoopbackBars, mHHStateBuffer); // // High ... ArraySetAsSeries(mLLBuffer, true); CopyBuffer( mHandler, XMAN_MC_LL_LINE, barIndex, mLoopbackBars, mLLBuffer); // // High State ... ArraySetAsSeries(mLLStateBuffer, true); CopyBuffer( mHandler, XMAN_MC_LL_STATE_LINE, barIndex, mLoopbackBars, mLLStateBuffer); // // Long ... // // High ... ArraySetAsSeries(lHHBuffer, true); CopyBuffer( mHandler, XMAN_LC_HH_LINE, barIndex, mLoopbackBars, lHHBuffer); // // High State ... ArraySetAsSeries(lHHStateBuffer, true); CopyBuffer( mHandler, XMAN_LC_HH_STATE_LINE, barIndex, mLoopbackBars, lHHStateBuffer); // // High ... ArraySetAsSeries(lLLBuffer, true); CopyBuffer( mHandler, XMAN_LC_LL_LINE, barIndex, mLoopbackBars, lLLBuffer); // // High State ... ArraySetAsSeries(lLLStateBuffer, true); CopyBuffer( mHandler, XMAN_LC_LL_STATE_LINE, barIndex, mLoopbackBars, lLLStateBuffer); // // Hind ... // // High ... ArraySetAsSeries(hHHBuffer, true); CopyBuffer( mHandler, XMAN_HC_HH_LINE, barIndex, mLoopbackBars, hHHBuffer); // // High State ... ArraySetAsSeries(hHHStateBuffer, true); CopyBuffer( mHandler, XMAN_HC_HH_STATE_LINE, barIndex, mLoopbackBars, hHHStateBuffer); // // High ... ArraySetAsSeries(hLLBuffer, true); CopyBuffer( mHandler, XMAN_HC_LL_LINE, barIndex, mLoopbackBars, hLLBuffer); // // High State ... ArraySetAsSeries(hLLStateBuffer, true); CopyBuffer( mHandler, XMAN_HC_LL_STATE_LINE, barIndex, mLoopbackBars, hLLStateBuffer); // // Trend ... // // Trend ... ArraySetAsSeries(trendBuffer, true); CopyBuffer( mHandler, XMAN_TREND_LINE, barIndex, mLoopbackBars, trendBuffer); // // Trend State ... ArraySetAsSeries(trendStateBuffer, true); CopyBuffer( mHandler, XMAN_TREND_STATE_LINE, barIndex, mLoopbackBars, trendStateBuffer); // // Ribbons ... // // 1 ... // // R1 ... ArraySetAsSeries(ribbon1Buffer, true); CopyBuffer( mHandler, XMAN_RB1_LINE, barIndex, mLoopbackBars, ribbon1Buffer); // // R1 State ... ArraySetAsSeries(ribbon1StateBuffer, true); CopyBuffer( mHandler, XMAN_RB1_STATE_LINE, barIndex, mLoopbackBars, ribbon1StateBuffer); // // 2 ... // // R2 ... ArraySetAsSeries(ribbon2Buffer, true); CopyBuffer( mHandler, XMAN_RB2_LINE, barIndex, mLoopbackBars, ribbon2Buffer); // // R2 State ... ArraySetAsSeries(ribbon2StateBuffer, true); CopyBuffer( mHandler, XMAN_RB2_STATE_LINE, barIndex, mLoopbackBars, ribbon2StateBuffer); // // 3 ... // // R3 ... ArraySetAsSeries(ribbon3Buffer, true); CopyBuffer( mHandler, XMAN_RB3_LINE, barIndex, mLoopbackBars, ribbon3Buffer); // // R3 State ... ArraySetAsSeries(ribbon3StateBuffer, true); CopyBuffer( mHandler, XMAN_RB3_STATE_LINE, barIndex, mLoopbackBars, ribbon3StateBuffer); // // 4 ... // // R4 ... ArraySetAsSeries(ribbon4Buffer, true); CopyBuffer( mHandler, XMAN_RB4_LINE, barIndex, mLoopbackBars, ribbon4Buffer); // // R4 State ... ArraySetAsSeries(ribbon4StateBuffer, true); CopyBuffer( mHandler, XMAN_RB4_STATE_LINE, barIndex, mLoopbackBars, ribbon4StateBuffer); // // 5 ... // // R5 ... ArraySetAsSeries(ribbon5Buffer, true); CopyBuffer( mHandler, XMAN_RB5_LINE, barIndex, mLoopbackBars, ribbon5Buffer); // // R5 State ... ArraySetAsSeries(ribbon5StateBuffer, true); CopyBuffer( mHandler, XMAN_RB5_STATE_LINE, barIndex, mLoopbackBars, ribbon5StateBuffer); // // 6 ... // // R6 ... ArraySetAsSeries(ribbon6Buffer, true); CopyBuffer( mHandler, XMAN_RB6_LINE, barIndex, mLoopbackBars, ribbon6Buffer); // // R6 State ... ArraySetAsSeries(ribbon6StateBuffer, true); CopyBuffer( mHandler, XMAN_RB6_STATE_LINE, barIndex, mLoopbackBars, ribbon6StateBuffer); // // SSL Channel ... // // UP ... ArraySetAsSeries(sslUpBuffer, true); CopyBuffer( mHandler, XMAN_SSLC_UP_LINE, barIndex, mLoopbackBars, sslUpBuffer); // // DOWN ... ArraySetAsSeries(sslDownBuffer, true); CopyBuffer( mHandler, XMAN_SSLC_DOWN_LINE, barIndex, mLoopbackBars, sslDownBuffer); // // HULL Trend ... // // UP ... ArraySetAsSeries(hullUpBuffer, true); CopyBuffer( mHandler, XMAN_HULL_UP_LINE, barIndex, mLoopbackBars, hullUpBuffer); // // UP State ... ArraySetAsSeries(hullUpStateBuffer, true); CopyBuffer( mHandler, XMAN_HULL_UP_STATE_LINE, barIndex, mLoopbackBars, hullUpStateBuffer); // // DOWN ... ArraySetAsSeries(hullDownBuffer, true); CopyBuffer( mHandler, XMAN_HULL_DOWN_LINE, barIndex, mLoopbackBars, hullDownBuffer); // // DOWN State ... ArraySetAsSeries(hullDownStateBuffer, true); CopyBuffer( mHandler, XMAN_HULL_DOWN_STATE_LINE, barIndex, mLoopbackBars, hullDownStateBuffer); // // Hiken Ashi ... // // Open ... ArraySetAsSeries(hkOpenBuffer, true); CopyBuffer( mHandler, XMAN_HK_OPEN_LINE, barIndex, mLoopbackBars, hkOpenBuffer); // // High ... ArraySetAsSeries(hkHighBuffer, true); CopyBuffer( mHandler, XMAN_HK_HIGH_LINE, barIndex, mLoopbackBars, hkHighBuffer); // // Low ... ArraySetAsSeries(hkLowBuffer, true); CopyBuffer( mHandler, XMAN_HK_LOW_LINE, barIndex, mLoopbackBars, hkLowBuffer); // // Close ... ArraySetAsSeries(hkCloseBuffer, true); CopyBuffer( mHandler, XMAN_HK_CLOSE_LINE, barIndex, mLoopbackBars, hkCloseBuffer); // // Close ... ArraySetAsSeries(hkStateBuffer, true); CopyBuffer( mHandler, XMAN_HK_STATE_LINE, barIndex, mLoopbackBars, hkStateBuffer); } // // Retrieve Info at Specific Bar Index ... XMANInfo GetInfo( int barIndex // Given Bar Index ) { // XMANInfo result; // if (barIndex < 0) { barIndex = 0; } // // Do Calculations ... Calculate(barIndex); // // Generate Candle Time ... datetime barTime = GetCandleTime( mSymbol, mPeriod, barIndex); // // Fill Result ... result.symbol = mSymbol; result.period = mPeriod; result.barTime = barTime; result.barIndex = barIndex; // // Buffers ... // Copy(peaksBuffer, result.peaks); Copy(peaksStateBuffer, result.peaksStates); Copy(valesBuffer, result.vales); Copy(valesStateBuffer, result.valesStates); // Copy(fibLevel1Buffer, result.fibLevel1s); Copy(fibLevel2Buffer, result.fibLevel2s); Copy(fibLevel3Buffer, result.fibLevel3s); Copy(fibLevel4Buffer, result.fibLevel4s); Copy(fibLevel5Buffer, result.fibLevel5s); // Copy(sHHBuffer, result.sHHs); Copy(sHHStateBuffer, result.sHHStates); Copy(sLLBuffer, result.sLLs); Copy(sLLStateBuffer, result.sLLStates); // Copy(mHHBuffer, result.mHHs); Copy(mHHStateBuffer, result.mHHStates); Copy(mLLBuffer, result.mLLs); Copy(mLLStateBuffer, result.mLLStates); // Copy(lHHBuffer, result.lHHs); Copy(lHHStateBuffer, result.lHHStates); Copy(lLLBuffer, result.lLLs); Copy(lLLStateBuffer, result.lLLStates); // Copy(hHHBuffer, result.hHHs); Copy(hHHStateBuffer, result.hHHStates); Copy(hLLBuffer, result.hLLs); Copy(hLLStateBuffer, result.hLLStates); // Copy(trendBuffer, result.trends); Copy(trendStateBuffer, result.trendStates); // Copy(ribbon1Buffer, result.ribbon1s); Copy(ribbon1StateBuffer, result.ribbon1States); // Copy(ribbon2Buffer, result.ribbon2s); Copy(ribbon2StateBuffer, result.ribbon2States); // Copy(ribbon3Buffer, result.ribbon3s); Copy(ribbon3StateBuffer, result.ribbon3States); // Copy(ribbon4Buffer, result.ribbon4s); Copy(ribbon4StateBuffer, result.ribbon4States); // Copy(ribbon5Buffer, result.ribbon5s); Copy(ribbon5StateBuffer, result.ribbon5States); // Copy(ribbon6Buffer, result.ribbon6s); Copy(ribbon6StateBuffer, result.ribbon6States); // Copy(sslUpBuffer, result.sslcUps); Copy(sslDownBuffer, result.sslcDowns); // Copy(hullUpBuffer, result.hullUps); Copy(hullUpStateBuffer, result.hullUpStates); Copy(hullDownBuffer, result.hullDowns); Copy(hullDownStateBuffer, result.hullDownStates); // Copy(hkOpenBuffer, result.hkOpens); Copy(hkHighBuffer, result.hkHighs); Copy(hkLowBuffer, result.hkLows); Copy(hkCloseBuffer, result.hkCloses); Copy(hkStateBuffer, result.hkStates); // int idx = 0; // // Conditions ... bool isNewPeak = // peaksStateBuffer[idx] != EMPTY_VALUE // ; bool isNewVale = // valesStateBuffer[idx] != EMPTY_VALUE // ; // // XSTR ... // // Reading Temp ... ENUM_XMAN_STATES trendState = (ENUM_XMAN_STATES)trendStateBuffer[idx]; ENUM_XMAN_STATES trendStatePrev = (ENUM_XMAN_STATES)trendStateBuffer[idx + 1]; // bool isTrendBullish = // trendState == XMAN_STATE_BULLISH // ; // bool isTrendPrevBullish = // trendStatePrev == XMAN_STATE_BULLISH // ; // bool isTrendSwitchedToBullish = // isTrendBullish && !isTrendPrevBullish // ; // bool isTrendBearish = // trendState == XMAN_STATE_BEARISH // ; // bool isTrendPrevBearish = // trendStatePrev == XMAN_STATE_BEARISH // ; // bool isTrendSwitchedToBearish = // isTrendBearish && !isTrendPrevBearish // ; // bool isTrendNeutural = // !isTrendBullish && !isTrendBearish // ; // bool isTrendPrevNeutural = // !isTrendPrevBullish && !isTrendPrevBearish // ; // bool isTrendSwitchedToNeutural = // isTrendNeutural && !isTrendPrevNeutural // ; // // XSSLC ... // bool isSSLCBullish = // sslUpBuffer[idx] > sslDownBuffer[idx] // ; // bool isSSLPrevBullish = // sslUpBuffer[idx + 1] > sslDownBuffer[idx + 1] // ; // bool isSSLCSwitchedToBullish = // isSSLCBullish && !isSSLPrevBullish // ; // bool isSSLCBearish = // sslUpBuffer[idx] < sslDownBuffer[idx] // ; // bool isSSLPrevBearish = // sslUpBuffer[idx + 1] < sslDownBuffer[idx + 1] // ; // bool isSSLCSwitchedToBearish = // isSSLCBearish && !isSSLPrevBearish // ; // bool isSSLCNeutural = // !isSSLCBullish && !isSSLCBearish // ; // bool isSSLPrevNeutural = // !isSSLPrevBullish && !isSSLPrevBearish // ; // bool isSSLCSwitchedToNeutural = // isSSLCNeutural && !isSSLPrevNeutural // ; // // XHULL ... // bool isHullUpBullish = // hullUpStateBuffer[idx] == XMAN_STATE_BULLISH // ; // bool isHullUpPrevBullish = // hullUpStateBuffer[idx + 1] == XMAN_STATE_BULLISH // ; // bool isHullDownBullish = // hullDownStateBuffer[idx] == XMAN_STATE_BULLISH // ; // bool isHullDownPrevBullish = // hullDownStateBuffer[idx + 1] == XMAN_STATE_BULLISH // ; // bool isHullBullish = // isHullUpBullish && isHullDownBullish // ; // bool isHullPrevBullish = // isHullUpPrevBullish && isHullDownPrevBullish // ; // bool isHullSwitchedToBullish = // isHullBullish && !isHullPrevBullish // ; // bool isHullUpBearish = // hullUpStateBuffer[idx] == XMAN_STATE_BEARISH // ; // bool isHullUpPrevBearish = // hullUpStateBuffer[idx + 1] == XMAN_STATE_BEARISH // ; // bool isHullDownBearish = // hullDownStateBuffer[idx] == XMAN_STATE_BEARISH // ; // bool isHullDownPrevBearish = // hullDownStateBuffer[idx + 1] == XMAN_STATE_BEARISH // ; // bool isHullBearish = // isHullUpBearish && isHullDownBearish // ; // bool isHullPrevBearish = // isHullUpPrevBearish && isHullDownPrevBearish // ; // bool isHullSwitchedToBearish = // isHullBearish && !isHullPrevBearish // ; // bool isHullUpNeutural = // !isHullUpBullish && !isHullUpBearish // ; // bool isHullUpPrevNeutural = // !isHullUpPrevBullish && !isHullUpPrevBearish // ; // bool isHullDownNeutural = // !isHullDownBullish && !isHullDownBearish // ; // bool isHullDownPrevNeutural = // !isHullDownPrevBullish && !isHullDownPrevBearish // ; // bool isHullNeutural = // isHullUpNeutural && isHullDownNeutural // ; // bool isHullPrevNeutural = // isHullUpPrevNeutural && isHullDownPrevNeutural // ; // bool isHullSwitchedToNeutural = // isHullNeutural && !isHullPrevNeutural // ; // // XHK ... // // Hiken Ashi ... bool isHKBullish = // hkStateBuffer[idx] == XMAN_STATE_BULLISH // ; bool isHKBearish = // hkStateBuffer[idx] == XMAN_STATE_BEARISH // ; // // Cycles ... // // Level 1 ... // ENUM_XMAN_STATES scHState = (ENUM_XMAN_STATES)sHHStateBuffer[idx]; ENUM_XMAN_STATES scHStatePrev = (ENUM_XMAN_STATES)sHHStateBuffer[idx + 1]; ENUM_XMAN_STATES scLState = (ENUM_XMAN_STATES)sLLStateBuffer[idx]; ENUM_XMAN_STATES scLStatePrev = (ENUM_XMAN_STATES)sLLStateBuffer[idx + 1]; // // Bullish ... // bool isSCHBullish = scHState == XMAN_STATE_BULLISH; bool isSCHPrevBullish = scHStatePrev == XMAN_STATE_BULLISH; // bool isSCLBullish = scLState == XMAN_STATE_BULLISH; bool isSCLPrevBullish = scLStatePrev == XMAN_STATE_BULLISH; // bool isSCBullish = isSCHBullish && isSCLBullish; // bool isSCPrevBullish = isSCHPrevBullish && isSCLPrevBullish; // bool isSCHSwitchedToBullish = isSCHBullish && !isSCHPrevBullish; // bool isSCLSwitchedToBullish = isSCLBullish && !isSCLPrevBullish; // bool isSCSwitchedToBullish = isSCBullish && !isSCPrevBullish; // // Bearish ... // bool isSCHBearish = scHState == XMAN_STATE_BEARISH; bool isSCHPrevBearish = scHStatePrev == XMAN_STATE_BEARISH; // bool isSCLBearish = scLState == XMAN_STATE_BEARISH; bool isSCLPrevBearish = scLStatePrev == XMAN_STATE_BEARISH; // bool isSCBearish = isSCHBearish && isSCLBearish; // bool isSCPrevBearish = isSCHPrevBearish && isSCLPrevBearish; // bool isSCHSwitchedToBearish = isSCHBearish && !isSCHPrevBearish; // bool isSCLSwitchedToBearish = isSCLBearish && !isSCLPrevBearish; // bool isSCSwitchedToBearish = isSCBearish && !isSCPrevBearish; // // Neutural ... // bool isSCHNeutural = !isSCHBullish && !isSCHBearish; // bool isSCHPrevNeutural = !isSCHPrevBullish && !isSCHPrevBearish; // bool isSCLNeutural = !isSCLBullish && !isSCLBearish; // bool isSCLPrevNeutural = !isSCLPrevBullish && !isSCLPrevBearish; // bool isSCNeutural = isSCHNeutural && isSCLNeutural; // bool isSCPrevNeutural = isSCHPrevNeutural && isSCLPrevNeutural; // bool isSCHSwitchedToNeutural = isSCHNeutural && !isSCHPrevNeutural; // bool isSCLSwitchedToNeutural = isSCLNeutural && !isSCLPrevNeutural; // bool isSCSwitchedToNeutural = isSCNeutural && !isSCPrevNeutural; // // Level 2 ... // ENUM_XMAN_STATES mcHState = (ENUM_XMAN_STATES)mHHStateBuffer[idx]; ENUM_XMAN_STATES mcHStatePrev = (ENUM_XMAN_STATES)mHHStateBuffer[idx + 1]; ENUM_XMAN_STATES mcLState = (ENUM_XMAN_STATES)mLLStateBuffer[idx]; ENUM_XMAN_STATES mcLStatePrev = (ENUM_XMAN_STATES)mLLStateBuffer[idx + 1]; // // Bullish ... // bool isMCHBullish = mcHState == XMAN_STATE_BULLISH; bool isMCHPrevBullish = mcHStatePrev == XMAN_STATE_BULLISH; // bool isMCLBullish = mcLState == XMAN_STATE_BULLISH; bool isMCLPrevBullish = mcLStatePrev == XMAN_STATE_BULLISH; // bool isMCBullish = isMCHBullish && isMCLBullish; // bool isMCPrevBullish = isMCHPrevBullish && isMCLPrevBullish; // bool isMCHSwitchedToBullish = isMCHBullish && !isMCHPrevBullish; // bool isMCLSwitchedToBullish = isMCLBullish && !isMCLPrevBullish; // bool isMCSwitchedToBullish = isMCBullish && !isMCPrevBullish; // // Bearish ... // bool isMCHBearish = mcHState == XMAN_STATE_BEARISH; bool isMCHPrevBearish = mcHStatePrev == XMAN_STATE_BEARISH; // bool isMCLBearish = mcLState == XMAN_STATE_BEARISH; bool isMCLPrevBearish = mcLStatePrev == XMAN_STATE_BEARISH; // bool isMCBearish = isMCHBearish && isMCLBearish; // bool isMCPrevBearish = isMCHPrevBearish && isMCLPrevBearish; // bool isMCHSwitchedToBearish = isMCHBearish && !isMCHPrevBearish; // bool isMCLSwitchedToBearish = isMCLBearish && !isMCLPrevBearish; // bool isMCSwitchedToBearish = isMCBearish && !isMCPrevBearish; // // Neutural ... // bool isMCHNeutural = !isMCHBullish && !isMCHBearish; // bool isMCHPrevNeutural = !isMCHPrevBullish && !isMCHPrevBearish; // bool isMCLNeutural = !isMCLBullish && !isMCLBearish; // bool isMCLPrevNeutural = !isMCLPrevBullish && !isMCLPrevBearish; // bool isMCNeutural = isMCHNeutural && isMCLNeutural; // bool isMCPrevNeutural = isMCHPrevNeutural && isMCLPrevNeutural; // bool isMCHSwitchedToNeutural = isMCHNeutural && !isMCHPrevNeutural; // bool isMCLSwitchedToNeutural = isMCLNeutural && !isMCLPrevNeutural; // bool isMCSwitchedToNeutural = isMCNeutural && !isMCPrevNeutural; // // Level 3 ... // ENUM_XMAN_STATES lcHState = (ENUM_XMAN_STATES)lHHStateBuffer[idx]; ENUM_XMAN_STATES lcHStatePrev = (ENUM_XMAN_STATES)lHHStateBuffer[idx + 1]; ENUM_XMAN_STATES lcLState = (ENUM_XMAN_STATES)lLLStateBuffer[idx]; ENUM_XMAN_STATES lcLStatePrev = (ENUM_XMAN_STATES)lLLStateBuffer[idx + 1]; // // Bullish ... // bool isLCHBullish = lcHState == XMAN_STATE_BULLISH; bool isLCHPrevBullish = lcHStatePrev == XMAN_STATE_BULLISH; // bool isLCLBullish = lcLState == XMAN_STATE_BULLISH; bool isLCLPrevBullish = lcLStatePrev == XMAN_STATE_BULLISH; // bool isLCBullish = isLCHBullish && isLCLBullish; // bool isLCPrevBullish = isLCHPrevBullish && isLCLPrevBullish; // bool isLCHSwitchedToBullish = isLCHBullish && !isLCHPrevBullish; // bool isLCLSwitchedToBullish = isLCLBullish && !isLCLPrevBullish; // bool isLCSwitchedToBullish = isLCBullish && !isLCPrevBullish; // // Bearish ... // bool isLCHBearish = lcHState == XMAN_STATE_BEARISH; bool isLCHPrevBearish = lcHStatePrev == XMAN_STATE_BEARISH; // bool isLCLBearish = lcLState == XMAN_STATE_BEARISH; bool isLCLPrevBearish = lcLStatePrev == XMAN_STATE_BEARISH; // bool isLCBearish = isLCHBearish && isLCLBearish; // bool isLCPrevBearish = isLCHPrevBearish && isLCLPrevBearish; // bool isLCHSwitchedToBearish = isLCHBearish && !isLCHPrevBearish; // bool isLCLSwitchedToBearish = isLCLBearish && !isLCLPrevBearish; // bool isLCSwitchedToBearish = isLCBearish && !isLCPrevBearish; // // Neutural ... // bool isLCHNeutural = !isLCHBullish && !isLCHBearish; // bool isLCHPrevNeutural = !isLCHPrevBullish && !isLCHPrevBearish; // bool isLCLNeutural = !isLCLBullish && !isLCLBearish; // bool isLCLPrevNeutural = !isLCLPrevBullish && !isLCLPrevBearish; // bool isLCNeutural = isLCHNeutural && isLCLNeutural; // bool isLCPrevNeutural = isLCHPrevNeutural && isLCLPrevNeutural; // bool isLCHSwitchedToNeutural = isLCHNeutural && !isLCHPrevNeutural; // bool isLCLSwitchedToNeutural = isLCLNeutural && !isLCLPrevNeutural; // bool isLCSwitchedToNeutural = isLCNeutural && !isLCPrevNeutural; // // Level 4 ... // ENUM_XMAN_STATES hcHState = (ENUM_XMAN_STATES)hHHStateBuffer[idx]; ENUM_XMAN_STATES hcHStatePrev = (ENUM_XMAN_STATES)hHHStateBuffer[idx + 1]; ENUM_XMAN_STATES hcLState = (ENUM_XMAN_STATES)hLLStateBuffer[idx]; ENUM_XMAN_STATES hcLStatePrev = (ENUM_XMAN_STATES)hLLStateBuffer[idx + 1]; // // Bullish ... // bool isHCHBullish = hcHState == XMAN_STATE_BULLISH; bool isHCHPrevBullish = hcHStatePrev == XMAN_STATE_BULLISH; // bool isHCLBullish = hcLState == XMAN_STATE_BULLISH; bool isHCLPrevBullish = hcLStatePrev == XMAN_STATE_BULLISH; // bool isHCBullish = isHCHBullish && isHCLBullish; // bool isHCPrevBullish = isHCHPrevBullish && isHCLPrevBullish; // bool isHCHSwitchedToBullish = isHCHBullish && !isHCHPrevBullish; // bool isHCLSwitchedToBullish = isHCLBullish && !isHCLPrevBullish; // bool isHCSwitchedToBullish = isHCBullish && !isHCPrevBullish; // // Bearish ... // bool isHCHBearish = hcHState == XMAN_STATE_BEARISH; bool isHCHPrevBearish = hcHStatePrev == XMAN_STATE_BEARISH; // bool isHCLBearish = hcLState == XMAN_STATE_BEARISH; bool isHCLPrevBearish = hcLStatePrev == XMAN_STATE_BEARISH; // bool isHCBearish = isHCHBearish && isHCLBearish; // bool isHCPrevBearish = isHCHPrevBearish && isHCLPrevBearish; // bool isHCHSwitchedToBearish = isHCHBearish && !isHCHPrevBearish; // bool isHCLSwitchedToBearish = isHCLBearish && !isHCLPrevBearish; // bool isHCSwitchedToBearish = isHCBearish && !isHCPrevBearish; // // Neutural ... // bool isHCHNeutural = !isHCHBullish && !isHCHBearish; // bool isHCHPrevNeutural = !isHCHPrevBullish && !isHCHPrevBearish; // bool isHCLNeutural = !isHCLBullish && !isHCLBearish; // bool isHCLPrevNeutural = !isHCLPrevBullish && !isHCLPrevBearish; // bool isHCNeutural = isHCHNeutural && isHCLNeutural; // bool isHCPrevNeutural = isHCHPrevNeutural && isHCLPrevNeutural; // bool isHCHSwitchedToNeutural = isHCHNeutural && !isHCHPrevNeutural; // bool isHCLSwitchedToNeutural = isHCLNeutural && !isHCLPrevNeutural; // bool isHCSwitchedToNeutural = isHCNeutural && !isHCPrevNeutural; // // Ribbons ... // // R1 ... ENUM_XMAN_STATES r1State = (ENUM_XMAN_STATES)ribbon1StateBuffer[idx]; ENUM_XMAN_STATES r1StatePrev = (ENUM_XMAN_STATES)ribbon1StateBuffer[idx + 1]; // // R2 ... ENUM_XMAN_STATES r2State = (ENUM_XMAN_STATES)ribbon2StateBuffer[idx]; ENUM_XMAN_STATES r2StatePrev = (ENUM_XMAN_STATES)ribbon2StateBuffer[idx + 1]; // // R3 ... ENUM_XMAN_STATES r3State = (ENUM_XMAN_STATES)ribbon3StateBuffer[idx]; ENUM_XMAN_STATES r3StatePrev = (ENUM_XMAN_STATES)ribbon3StateBuffer[idx + 1]; // // R4 ... ENUM_XMAN_STATES r4State = (ENUM_XMAN_STATES)ribbon4StateBuffer[idx]; ENUM_XMAN_STATES r4StatePrev = (ENUM_XMAN_STATES)ribbon4StateBuffer[idx + 1]; // // R5 ... ENUM_XMAN_STATES r5State = (ENUM_XMAN_STATES)ribbon5StateBuffer[idx]; ENUM_XMAN_STATES r5StatePrev = (ENUM_XMAN_STATES)ribbon5StateBuffer[idx + 1]; // // R6 ... ENUM_XMAN_STATES r6State = (ENUM_XMAN_STATES)ribbon6StateBuffer[idx]; ENUM_XMAN_STATES r6StatePrev = (ENUM_XMAN_STATES)ribbon6StateBuffer[idx + 1]; // // Bullish ... // bool isRibbon1Bullish = r1State == XMAN_STATE_BULLISH; bool isRibbon2Bullish = r2State == XMAN_STATE_BULLISH; bool isRibbon3Bullish = r3State == XMAN_STATE_BULLISH; bool isRibbon4Bullish = r4State == XMAN_STATE_BULLISH; bool isRibbon5Bullish = r5State == XMAN_STATE_BULLISH; bool isRibbon6Bullish = r6State == XMAN_STATE_BULLISH; // bool isRibbon1PrevBullish = r1StatePrev == XMAN_STATE_BULLISH; bool isRibbon2PrevBullish = r2StatePrev == XMAN_STATE_BULLISH; bool isRibbon3PrevBullish = r3StatePrev == XMAN_STATE_BULLISH; bool isRibbon4PrevBullish = r4StatePrev == XMAN_STATE_BULLISH; bool isRibbon5PrevBullish = r5StatePrev == XMAN_STATE_BULLISH; bool isRibbon6PrevBullish = r6StatePrev == XMAN_STATE_BULLISH; // // Bearish ... // bool isRibbon1Bearish = r1State == XMAN_STATE_BEARISH; bool isRibbon2Bearish = r2State == XMAN_STATE_BEARISH; bool isRibbon3Bearish = r3State == XMAN_STATE_BEARISH; bool isRibbon4Bearish = r4State == XMAN_STATE_BEARISH; bool isRibbon5Bearish = r5State == XMAN_STATE_BEARISH; bool isRibbon6Bearish = r6State == XMAN_STATE_BEARISH; // bool isRibbon1PrevBearish = r1StatePrev == XMAN_STATE_BEARISH; bool isRibbon2PrevBearish = r2StatePrev == XMAN_STATE_BEARISH; bool isRibbon3PrevBearish = r3StatePrev == XMAN_STATE_BEARISH; bool isRibbon4PrevBearish = r4StatePrev == XMAN_STATE_BEARISH; bool isRibbon5PrevBearish = r5StatePrev == XMAN_STATE_BEARISH; bool isRibbon6PrevBearish = r6StatePrev == XMAN_STATE_BEARISH; // // Neutural ... // bool isRibbon1Neutural = !isRibbon1Bullish && !isRibbon1Bearish; // bool isRibbon2Neutural = !isRibbon2Bullish && !isRibbon2Bearish; // bool isRibbon3Neutural = !isRibbon3Bullish && !isRibbon3Bearish; // bool isRibbon4Neutural = !isRibbon4Bullish && !isRibbon4Bearish; // bool isRibbon5Neutural = !isRibbon5Bullish && !isRibbon5Bearish; // bool isRibbon6Neutural = !isRibbon6Bullish && !isRibbon6Bearish; // bool isRibbon1PrevNeutural = !isRibbon1PrevBullish && !isRibbon1PrevBearish; // bool isRibbon2PrevNeutural = !isRibbon2PrevBullish && !isRibbon2PrevBearish; // bool isRibbon3PrevNeutural = !isRibbon3PrevBullish && !isRibbon3PrevBearish; // bool isRibbon4PrevNeutural = !isRibbon4PrevBullish && !isRibbon4PrevBearish; // bool isRibbon5PrevNeutural = !isRibbon5PrevBullish && !isRibbon5PrevBearish; // bool isRibbon6PrevNeutural = !isRibbon6PrevBullish && !isRibbon6PrevBearish; // // All Ribbons ... // bool isRibbonBullish = isRibbon1Bullish && isRibbon2Bullish && isRibbon3Bullish && isRibbon4Bullish && isRibbon5Bullish && isRibbon6Bullish; // bool isRibbonPrevBullish = isRibbon1PrevBullish && isRibbon2PrevBullish && isRibbon3PrevBullish && isRibbon4PrevBullish && isRibbon5PrevBullish && isRibbon6PrevBullish; // bool isRibbonSwitchedToBullish = isRibbonBullish && !isRibbonPrevBullish; // bool isRibbonBearish = isRibbon1Bearish && isRibbon2Bearish && isRibbon3Bearish && isRibbon4Bearish && isRibbon5Bearish && isRibbon6Bearish; // bool isRibbonPrevBearish = isRibbon1PrevBearish && isRibbon2PrevBearish && isRibbon3PrevBearish && isRibbon4PrevBearish && isRibbon5PrevBearish && isRibbon6PrevBearish; // bool isRibbonSwitchedToBearish = isRibbonBearish && !isRibbonPrevBearish; // bool isRibbonNeutural = isRibbon1Neutural && isRibbon2Neutural && isRibbon3Neutural && isRibbon4Neutural && isRibbon5Neutural && isRibbon6Neutural; // bool isRibbonPrevNeutural = isRibbon1PrevNeutural && isRibbon2PrevNeutural && isRibbon3PrevNeutural && isRibbon4PrevNeutural && isRibbon5PrevNeutural && isRibbon6PrevNeutural; // bool isRibbonSwitchedToNeutural = isRibbonNeutural && !isRibbonPrevNeutural; // result.isNewPeak = isNewPeak; result.isNewVale = isNewVale; result.isTrendBullish = isTrendBullish; result.isTrendSwitchedToBullish = isTrendSwitchedToBullish; result.isTrendBearish = isTrendBearish; result.isTrendSwitchedToBearish = isTrendSwitchedToBearish; result.isTrendNeutural = isTrendNeutural; result.isTrendSwitchedToNeutural = isTrendSwitchedToNeutural; result.isSSLCBullish = isSSLCBullish; result.isSSLCSwitchedToBullish = isSSLCSwitchedToBullish; result.isSSLCBearish = isSSLCBearish; result.isSSLCSwitchedToBearish = isSSLCSwitchedToBearish; result.isSSLCNeutural = isSSLCNeutural; result.isSSLCSwitchedToNeutural = isSSLCSwitchedToNeutural; result.isHullBullish = isHullBullish; result.isHullUpBullish = isHullUpBullish; result.isHullDownBullish = isHullDownBullish; result.isHullSwitchedToBullish = isHullSwitchedToBullish; result.isHullBearish = isHullBearish; result.isHullUpBearish = isHullUpBearish; result.isHullDownBearish = isHullDownBearish; result.isHullSwitchedToBearish = isHullSwitchedToBearish; result.isHullNeutural = isHullNeutural; result.isHullUpNeutural = isHullUpNeutural; result.isHullDownNeutural = isHullDownNeutural; result.isHullSwitchedToNeutural = isHullSwitchedToNeutural; result.isHKBullish = isHKBullish; result.isHKBearish = isHKBearish; result.isSCBullish = isSCBullish; result.isSCHBullish = isSCHBullish; result.isSCLBullish = isSCLBullish; result.isSCSwitchedToBullish = isSCSwitchedToBullish; result.isSCHSwitchedToBullish = isSCHSwitchedToBullish; result.isSCLSwitchedToBullish = isSCLSwitchedToBullish; result.isSCBearish = isSCBearish; result.isSCHBearish = isSCHBearish; result.isSCLBearish = isSCLBearish; result.isSCSwitchedToBearish = isSCSwitchedToBearish; result.isSCHSwitchedToBearish = isSCHSwitchedToBearish; result.isSCLSwitchedToBearish = isSCLSwitchedToBearish; result.isSCNeutural = isSCNeutural; result.isSCHNeutural = isSCHNeutural; result.isSCLNeutural = isSCLNeutural; result.isSCSwitchedToNeutural = isSCSwitchedToNeutural; result.isSCHSwitchedToNeutural = isSCHSwitchedToNeutural; result.isSCLSwitchedToNeutural = isSCLSwitchedToNeutural; result.isMCBullish = isMCBullish; result.isMCHBullish = isMCHBullish; result.isMCLBullish = isMCLBullish; result.isMCSwitchedToBullish = isMCSwitchedToBullish; result.isMCHSwitchedToBullish = isMCHSwitchedToBullish; result.isMCLSwitchedToBullish = isMCLSwitchedToBullish; result.isMCBearish = isMCBearish; result.isMCHBearish = isMCHBearish; result.isMCLBearish = isMCLBearish; result.isMCSwitchedToBearish = isMCSwitchedToBearish; result.isMCHSwitchedToBearish = isMCHSwitchedToBearish; result.isMCLSwitchedToBearish = isMCLSwitchedToBearish; result.isMCNeutural = isMCNeutural; result.isMCHNeutural = isMCHNeutural; result.isMCLNeutural = isMCLNeutural; result.isMCSwitchedToNeutural = isMCSwitchedToNeutural; result.isMCHSwitchedToNeutural = isMCHSwitchedToNeutural; result.isMCLSwitchedToNeutural = isMCLSwitchedToNeutural; result.isLCBullish = isLCBullish; result.isLCHBullish = isLCHBullish; result.isLCLBullish = isLCLBullish; result.isLCSwitchedToBullish = isLCSwitchedToBullish; result.isLCHSwitchedToBullish = isLCHSwitchedToBullish; result.isLCLSwitchedToBullish = isLCLSwitchedToBullish; result.isLCBearish = isLCBearish; result.isLCHBearish = isLCHBearish; result.isLCLBearish = isLCLBearish; result.isLCSwitchedToBearish = isLCSwitchedToBearish; result.isLCHSwitchedToBearish = isLCHSwitchedToBearish; result.isLCLSwitchedToBearish = isLCLSwitchedToBearish; result.isLCNeutural = isLCNeutural; result.isLCHNeutural = isLCHNeutural; result.isLCLNeutural = isLCLNeutural; result.isLCSwitchedToNeutural = isLCSwitchedToNeutural; result.isLCHSwitchedToNeutural = isLCHSwitchedToNeutural; result.isLCLSwitchedToNeutural = isLCLSwitchedToNeutural; result.isHCBullish = isHCBullish; result.isHCHBullish = isHCHBullish; result.isHCLBullish = isHCLBullish; result.isHCSwitchedToBullish = isHCSwitchedToBullish; result.isHCHSwitchedToBullish = isHCHSwitchedToBullish; result.isHCLSwitchedToBullish = isHCLSwitchedToBullish; result.isHCBearish = isHCBearish; result.isHCHBearish = isHCHBearish; result.isHCLBearish = isHCLBearish; result.isHCSwitchedToBearish = isHCSwitchedToBearish; result.isHCHSwitchedToBearish = isHCHSwitchedToBearish; result.isHCLSwitchedToBearish = isHCLSwitchedToBearish; result.isHCNeutural = isHCNeutural; result.isHCHNeutural = isHCHNeutural; result.isHCLNeutural = isHCLNeutural; result.isHCSwitchedToNeutural = isHCSwitchedToNeutural; result.isHCHSwitchedToNeutural = isHCHSwitchedToNeutural; result.isHCLSwitchedToNeutural = isHCLSwitchedToNeutural; result.isRibbon1Bullish = isRibbon1Bullish; result.isRibbon2Bullish = isRibbon2Bullish; result.isRibbon3Bullish = isRibbon3Bullish; result.isRibbon4Bullish = isRibbon4Bullish; result.isRibbon5Bullish = isRibbon5Bullish; result.isRibbon6Bullish = isRibbon6Bullish; result.isRibbon1Bearish = isRibbon1Bearish; result.isRibbon2Bearish = isRibbon2Bearish; result.isRibbon3Bearish = isRibbon3Bearish; result.isRibbon4Bearish = isRibbon4Bearish; result.isRibbon5Bearish = isRibbon5Bearish; result.isRibbon6Bearish = isRibbon6Bearish; result.isRibbon1Neutural = isRibbon1Neutural; result.isRibbon2Neutural = isRibbon2Neutural; result.isRibbon3Neutural = isRibbon3Neutural; result.isRibbon4Neutural = isRibbon4Neutural; result.isRibbon5Neutural = isRibbon5Neutural; result.isRibbon6Neutural = isRibbon6Neutural; result.isRibbonBullish = isRibbonBullish; result.isRibbonSwitchedToBullish = isRibbonSwitchedToBullish; result.isRibbonBearish = isRibbonBearish; result.isRibbonSwitchedToBearish = isRibbonSwitchedToBearish; result.isRibbonNeutural = isRibbonNeutural; result.isRibbonSwitchedToNeutural = isRibbonSwitchedToNeutural; // return result; } // // TOOLS ... // bool IsValesTrendBearish( int count = 10 // Number of Values Processed ) { // bool result = false; // int calculatedVales = 0; int verifier = 0; // int availableBars = Bars( mSymbol, mPeriod); // for (int i = 1; i < availableBars - 2; i++) { // // Update Buffers ... Calculate(i); // // Check New Vale Happens ... bool isNewVale = // valesBuffer[0] != valesBuffer[1] // ; if (!isNewVale) { continue; } // // Check New Vale is Over last or Under Last ... bool isOverLastVale = // valesBuffer[0] > valesBuffer[1] // ; // // Set Verifier Value based On New Vale State ... if (isOverLastVale) { verifier++; } else { verifier--; } // // Increase Number of Calculated Vales ... calculatedVales++; // // Break when Calculating required Vales ... if (calculatedVales >= count) { break; } } // result = verifier < 0; // return result; } // bool IsValesTrendBullish( int count = 10 // Number of Values Processed ) { // bool result = false; // int calculatedVales = 0; int verifier = 0; // int availableBars = Bars( mSymbol, mPeriod); // for (int i = 1; i < availableBars - 2; i++) { // // Update Buffers ... Calculate(i); // // Check New Vale Happens ... bool isNewVale = // valesBuffer[0] != valesBuffer[1] // ; if (!isNewVale) { continue; } // // Check New Vale is Over last or Under Last ... bool isOverLastVale = // valesBuffer[0] > valesBuffer[1] // ; // // Set Verifier Value based On New Vale State ... if (isOverLastVale) { verifier++; } else { verifier--; } // // Increase Number of Calculated Vales ... calculatedVales++; // // Break when Calculating required Vales ... if (calculatedVales >= count) { break; } } // result = verifier > 0; // return result; } // bool IsPeaksTrendBearish( int count = 10 // Number of Peaks Processed ) { // bool result = false; // int calculatedPeaks = 0; int verifier = 0; // int availableBars = Bars( mSymbol, mPeriod); // for (int i = 1; i < availableBars - 2; i++) { // // Update Buffers ... Calculate(i); // // Check New Peak Happens ... bool isNewPeak = // peaksBuffer[0] != peaksBuffer[1] // ; if (!isNewPeak) { continue; } // // Check New Peak is Over last or Under Last ... bool isOverLastPeak = // peaksBuffer[0] > peaksBuffer[1] // ; // // Set Verifier Value based On New Peak State ... if (isOverLastPeak) { verifier++; } else { verifier--; } // // Increase Number of Calculated Peaks ... calculatedPeaks++; // // Break when Calculating required Peaks ... if (calculatedPeaks >= count) { break; } } // result = verifier < 0; // return result; } // bool IsPeaksTrendBullish( int count = 10 // Number of Peaks Processed ) { // bool result = false; // int calculatedPeaks = 0; int verifier = 0; // int availableBars = Bars( mSymbol, mPeriod); // for (int i = 1; i < availableBars - 2; i++) { // // Update Buffers ... Calculate(i); // // Check New Peak Happens ... bool isNewPeak = // peaksBuffer[0] != peaksBuffer[1] // ; if (!isNewPeak) { continue; } // // Check New Peak is Over last or Under Last ... bool isOverLastPeak = // peaksBuffer[0] > peaksBuffer[1] // ; // // Set Verifier Value based On New Peak State ... if (isOverLastPeak) { verifier++; } else { verifier--; } // // Increase Number of Calculated Peaks ... calculatedPeaks++; // // Break when Calculating required Peaks ... if (calculatedPeaks >= count) { break; } } // result = verifier > 0; // return result; } // // Protcted ... protected: // // Private ... private: // // Inputs ... // // Candle Timer ... color mCandleTimerColor; // Text Color ENUM_BASE_CORNER mCandleTimerCorner; // Text Position // // Chart Style ... color mUpColor; // Up Color color mDownColor; // Down Color color mLineColor; // Line mode and Doji candlestick Color color mBearishColor; // Bullish Color color mBullishColor; // Bearish Color color mVolumesColor; // Volumes Color ENUM_CHART_MODE mChartMode; // Chart Mode // // Market Cycles ... // // Level 1 ... ENUM_X_PERIOD_METHOD mL1Method; // How to Find Period ENUM_TIMEFRAMES mL1Period; // Time Period // // Level 2 ... ENUM_X_PERIOD_METHOD mL2Method; // How to Find Period ENUM_TIMEFRAMES mL2Period; // Time Period // // Level 3 ... ENUM_X_PERIOD_METHOD mL3Method; // How to Find Period ENUM_TIMEFRAMES mL3Period; // Time Period // // Level 4 ... ENUM_X_PERIOD_METHOD mL4Method; // How to Find Period ENUM_TIMEFRAMES mL4Period; // Time Period // // Fibonacci ... double mFiboLevel1; // Fibio 1st Level double mFiboLevel2; // Fibio 2st Level double mFiboLevel3; // Fibio 3rd Level double mFiboLevel4; // Fibio 4th Level double mFiboLevel5; // Fibio 5th Level // // Boundary Detection Modes ... ENUM_SERIESMODE mHHMode; // Highest High Calculation Method ENUM_SERIESMODE mLLMode; // Lowest Low Calculation Method // // Trend Detection double mTrendMultiplier; // Multiplier ENUM_APPLIED_PRICE mTrendPriceAppliedTo; // Applied To // // Ribbon Detection ... ENUM_X_MA_METHOD mRibbonMode; // How to Calculate // // Hull Trend Detection ... double mHullDivisor; // Divisor (Speed) ENUM_APPLIED_PRICE mHullUpAppliedTo; // Up Zone Applied to ENUM_APPLIED_PRICE mHullDownAppliedTo; // Down Zone Applied to // // SSL Channel Detection ... ENUM_X_MA_METHOD mSslcMode; // How to Calculate ENUM_APPLIED_PRICE mSslcUpAppliedTo; // Up Applied To ENUM_APPLIED_PRICE mSslcDownAppliedTo; // Down Applied To // // Presentation ... bool mShowCandleTimer; // Show Candle Time bool mShowCandles; // Show Candles bool mShowHKCandles; // Draw Hiken Ashi Candle bool mShowPeaksAndVales; // Show Peaks and Vales bool mShowTrends; // Show Trends bool mSillTrends; // Fill Trends bool mShowLevels; // Show Levels bool mShowConsolidations; // Show Consolidations bool mShowRibbons; // Show Ribbons bool mShowHull; // Show Hull bool mShowSSLChannel; // Show SSL Channel bool mShowFibo1Levels; // Show Fibo 1st Level bool mShowFibo2Levels; // Show Fibo 2nd Level bool mShowFibo3Levels; // Show Fibo 3rd Level bool mShowFibo4Levels; // Show Fibo 4th Level bool mShowFibo5Levels; // Show Fibo 5th Level }; // // START Usefull Functions ... // // // END Usefull Functions ... //