/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Helper Class Library // ---------------------------------------------- // Name: XSCXICHHelper // Description: provides all Indicator // Helper requirements ... // // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... // // 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 ... // // // Ichimoku Lines Calculator Mode ... enum ENUM_X_ICHIMOKU_CALCULATION_MODE { // X_XICH_HH_LL_MODE = 1, // Highest High and Lowest Low X_XICH_HO_LC_MODE = 2, // Highest Open and Lowest Close }; // // Inputs ... struct XICHInputs { // // TENKANSEN ... // Tenkan Sen ... int tenkanSenLength; // Length ENUM_X_ICHIMOKU_CALCULATION_MODE tenkanSenMode; // Calculation Mode // // KIJUNSEN ... // Kijun Sen ... int kijunSenLength; // Length ENUM_X_ICHIMOKU_CALCULATION_MODE kijunSenMode; // Calculation Mode // // SENKOUSPANB ... // Senkou Span B ... int senkouSpanBLength; // Length ENUM_X_ICHIMOKU_CALCULATION_MODE senkouSpanBMode; // Calculation Mode // // CHIKOUSPAN ... // Chikou Span ... ENUM_APPLIED_PRICE chikuoSpanAppliedTo; // Price Type // // Presentation ... bool showTenkanSen; // Show Tenkan Sen bool showKijunSen; // Show Kijun Sen bool showKijunSenPlus; // Show Kijun Sen + bool showKijunSenNegative; // Show Kijun Sen - bool showChikouSpan; // Show Chikou Span bool showSenkouSpanA; // Show Senkou Span A bool showSenkouSpanB; // Show Senkou Span B bool showKumo; // Show Kumo bool shiftKumo; // Shift Kumo to Future }; // // Index of Lines ... enum ENUM_XICH_BUFFERS { // // Main Requirements ... XICH_TEANKANSEN_LINE = 0, XICH_KIJUNSEN_LINE = 1, XICH_CHIKOUSPAN_LINE = 4, XICH_SENKOUSPANA_LINE = 5, XICH_SENKOUSPANB_LINE = 6, }; // // Retrieve Info Model ... struct XICHInfo { // // Symbol ... string symbol; // // Period ... ENUM_TIMEFRAMES period; // // Bar Time ... datetime barTime; // // Bar Index ... int barIndex; // // Values ... double tenkanSen; double kijunSen; double chikouSpan; double senkouSpanA; double senkouSpanB; double senkouSpanAFuture; double senkouSpanBFuture; // // Conditions ... // bool isTenkanSenOverKijunSen; bool isTenkanSenUnderKijunSen; bool isTenkanSenCrossedOverKijunSen; bool isTenkanSenCrossedUnderKijunSen; // bool isKumoBullish; bool isKumoBearish; bool isFutureKumoBullish; bool isFutureKumoBearish; bool isKumoSwitchedToBullish; bool isKumoSwitchedToBearish; bool isFutureKumoSwitchedToBullish; bool isFutureKumoSwitchedToBearish; // bool isTenkanSenOverSenkouSpanA; bool isTenkanSenUnderSenkouSpanA; bool isTenkanSenOverFutureSenkouSpanA; bool isTenkanSenUnderFutureSenkouSpanA; bool isTenkanSenCrossedOverSenkouSpanA; bool isTenkanSenCrossedUnderSenkouSpanA; bool isTenkanSenCrossedOverFutureSenkouSpanA; bool isTenkanSenCrossedUnderFutureSenkouSpanA; // bool isTenkanSenOverSenkouSpanB; bool isTenkanSenUnderSenkouSpanB; bool isTenkanSenOverFutureSenkouSpanB; bool isTenkanSenUnderFutureSenkouSpanB; bool isTenkanSenCrossedOverSenkouSpanB; bool isTenkanSenCrossedUnderSenkouSpanB; bool isTenkanSenCrossedOverFutureSenkouSpanB; bool isTenkanSenCrossedUnderFutureSenkouSpanB; // bool isKijunSenOverSenkouSpanA; bool isKijunSenUnderSenkouSpanA; bool isKijunSenOverFutureSenkouSpanA; bool isKijunSenUnderFutureSenkouSpanA; bool isKijunSenCrossedOverSenkouSpanA; bool isKijunSenCrossedUnderSenkouSpanA; bool isKijunSenCrossedOverFutureSenkouSpanA; bool isKijunSenCrossedUnderFutureSenkouSpanA; // bool isKijunSenOverSenkouSpanB; bool isKijunSenUnderSenkouSpanB; bool isKijunSenOverFutureSenkouSpanB; bool isKijunSenUnderFutureSenkouSpanB; bool isKijunSenCrossedOverSenkouSpanB; bool isKijunSenCrossedUnderSenkouSpanB; bool isKijunSenCrossedOverFutureSenkouSpanB; bool isKijunSenCrossedUnderFutureSenkouSpanB; }; // // 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 ... // // // a Class for Helping Indicators Requirements ... class XSCXICHHelper : public XSCBaseHelper { // // Public ... public: // // Buffers ... double tenkanSenBuffer[]; double kijunSenBuffer[]; double chikouSpanBuffer[]; double senkouSpanABuffer[]; double senkouSpanBBuffer[]; // // Constructor ... void XSCXICHHelper( string symbol, // Trading Symbol ENUM_TIMEFRAMES period // Trading Time Frame ) : XSCBaseHelper(symbol, period) { PrepareTag(); } // // Deconstructor ... void ~XSCXICHHelper() { } // // START Properties ... // // // Show Tenkan Sen ... bool ShowTenkanSen( bool show // Show or Hide ) { // bool result = false; // if (mShowTenkanSen == show) { return true; } // mShowTenkanSen = show; result = Init(); // return result; } // // Show Kijun Sen ... bool ShowKijunSen( bool show // Show or Hide ) { // bool result = false; // if (mShowKijunSen == show) { return true; } // mShowKijunSen = show; result = Init(); // return result; } // // Show Chikou Span ... bool ShowChikouSpan( bool show // Show or Hide ) { // bool result = false; // if (mShowChikouSpan == show) { return true; } // mShowChikouSpan = show; result = Init(); // return result; } // // Show Senkou Span A ... bool ShowSenkouSpanA( bool show // Show or Hide ) { // bool result = false; // if (mShowSenkouSpanA == show) { return true; } // mShowSenkouSpanA = show; result = Init(); // return result; } // // Show Senkou Span B ... bool ShowSenkouSpanB( bool show // Show or Hide ) { // bool result = false; // if (mShowSenkouSpanB == show) { return true; } // mShowSenkouSpanB = show; result = Init(); // return result; } // // Show Kumo ... bool ShowKumo( bool show // Show or Hide ) { // bool result = false; // if (mShowKumo == show) { return true; } // mShowKumo = show; result = Init(); // return result; } // // END Properties ... // // // START Provided Functions ... // // // Prepare Tag ... virtual void PrepareTag() { mTag = "XICH" + GetTagPrefix(); } // virtual int GetMaxLength() { // int result = -1; // result = MathMax(result, mTenkanSenLength); result = MathMax(result, mKijunSenLength); result = MathMax(result, mSenkouSpanBLength); // return result; } // // Initial Indicator Handler ... bool Init() { // bool result = false; // // Validate Inputs ... // result = (mTenkanSenLength > 2 && mKijunSenLength > mTenkanSenLength && mSenkouSpanBLength > mKijunSenLength); if (!result) { return result; } // // Initialize Handler ... mHandler = iCustom( // mSymbol, mPeriod, "x-saherelm.x121.xich", // // Inputs ... // // TENKANSEN ... "", // // Length ... mTenkanSenLength, // // Calculation Mode ... mTenkanSenMode, // // KIJUNSEN ... "", // // Length ... mKijunSenLength, // // Calculation Mode ... mKijunSenMode, // // SENKOUSPANA ... "", // // Length ... mSenkouSpanBLength, // // Calculation Mode ... mSenkouSpanBMode, // // CHIKOUSPAN ... "", // // Price Type ... mChikuoSpanAppliedTo, // // PRESENTATION ... "", // // Show Tenkan Sen ... mShowTenkanSen, // // Show Kijun Sen ... mShowKijunSen, // // Show Kijun Sen + ... mShowKijunSenPlus, // // Show Kijun Sen - ... mShowKijunSenNegative, // // Show Chikou Span ... mShowChikouSpan, // // Show Senkou Span A ... mShowSenkouSpanA, // // Show Senkou Span B ... mShowSenkouSpanB, // // Show Kumo ... mShowKumo, // // Shift Kumo to Future ... mShiftKumo // ); result = mHandler != INVALID_HANDLE; // return result; } // // Retrieve Current Config ... XICHInputs GetConfig() { // XICHInputs result; // result.tenkanSenLength = mTenkanSenLength; result.tenkanSenMode = mTenkanSenMode; result.kijunSenLength = mKijunSenLength; result.kijunSenMode = mKijunSenMode; result.senkouSpanBLength = mSenkouSpanBLength; result.senkouSpanBMode = mSenkouSpanBMode; result.chikuoSpanAppliedTo = mChikuoSpanAppliedTo; result.showTenkanSen = mShowTenkanSen; result.showKijunSen = mShowKijunSen; result.showKijunSenPlus = mShowKijunSenPlus; result.showKijunSenNegative = mShowKijunSenNegative; result.showChikouSpan = mShowChikouSpan; result.showSenkouSpanA = mShowSenkouSpanA; result.showSenkouSpanB = mShowSenkouSpanB; result.showKumo = mShowKumo; result.shiftKumo = mShiftKumo; // return result; } // // Set Config ... bool SetConfig(XICHInputs &config) { // bool result = false; // mTenkanSenLength = config.tenkanSenLength; mTenkanSenMode = config.tenkanSenMode; mKijunSenLength = config.kijunSenLength; mKijunSenMode = config.kijunSenMode; mSenkouSpanBLength = config.senkouSpanBLength; mSenkouSpanBMode = config.senkouSpanBMode; mChikuoSpanAppliedTo = config.chikuoSpanAppliedTo; mShowTenkanSen = config.showTenkanSen; mShowKijunSen = config.showKijunSen; mShowKijunSenPlus = config.showKijunSenPlus; mShowKijunSenNegative = config.showKijunSenNegative; mShowChikouSpan = config.showChikouSpan; mShowSenkouSpanA = config.showSenkouSpanA; mShowSenkouSpanB = config.showSenkouSpanB; mShowKumo = config.showKumo; mShiftKumo = config.shiftKumo; // result = Init(); // return result; } // // Reading Buffers based on Given Bar Index ... virtual void Calculate( int barIndex // Given Bar Index ) { // // Since Ichimoku Has Some Issues ... mLoopbackBars = 52; // // TENKANSEN ... ArraySetAsSeries(tenkanSenBuffer, true); CopyBuffer( mHandler, XICH_TEANKANSEN_LINE, barIndex, mLoopbackBars, tenkanSenBuffer); // // KIJUNSEN ... ArraySetAsSeries(kijunSenBuffer, true); CopyBuffer( mHandler, XICH_KIJUNSEN_LINE, barIndex, mLoopbackBars, kijunSenBuffer); // // CHIKOUSPAN ... ArraySetAsSeries(chikouSpanBuffer, true); CopyBuffer( mHandler, XICH_CHIKOUSPAN_LINE, barIndex + mKijunSenLength + 1, mLoopbackBars, chikouSpanBuffer); // // SENKOUSPANA ... ArraySetAsSeries(senkouSpanABuffer, true); CopyBuffer( mHandler, XICH_SENKOUSPANA_LINE, -1 * (barIndex + mKijunSenLength), mLoopbackBars, senkouSpanABuffer); // // SENKOUSPANB ... ArraySetAsSeries(senkouSpanBBuffer, true); CopyBuffer( mHandler, XICH_SENKOUSPANB_LINE, -1 * (barIndex + mKijunSenLength), mLoopbackBars, senkouSpanBBuffer); } // // Retrieve Info at Specific Bar Index ... XICHInfo GetInfo( int barIndex // Given Bar Index ) { // XICHInfo result; // if (barIndex < 0) { return result; } // barIndex--; 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; // double tenkanSen = tenkanSenBuffer[barIndex]; double tenkanSenPrev = tenkanSenBuffer[barIndex + 1]; // double kijunSen = kijunSenBuffer[barIndex]; double kijunSenPrev = kijunSenBuffer[barIndex + 1]; // double chikouSpan = chikouSpanBuffer[barIndex + mKijunSenLength]; double chikouSpanPrev = chikouSpanBuffer[barIndex + mKijunSenLength + 1]; // double senkouSpanA = senkouSpanABuffer[barIndex + mKijunSenLength]; double senkouSpanAPrev = senkouSpanABuffer[barIndex + mKijunSenLength + 1]; // double senkouSpanB = senkouSpanBBuffer[barIndex + mKijunSenLength]; double senkouSpanBPrev = senkouSpanBBuffer[barIndex + mKijunSenLength + 1]; // double senkouSpanAFuture = senkouSpanABuffer[barIndex]; double senkouSpanAFuturePrev = senkouSpanABuffer[barIndex + 1]; // double senkouSpanBFuture = senkouSpanBBuffer[barIndex]; double senkouSpanBFuturePrev = senkouSpanBBuffer[barIndex + 1]; // bool isTenkanSenOverKijunSen = tenkanSen > kijunSen; bool isTenkanSenUnderKijunSen = tenkanSen < kijunSen; bool isTenkanSenCrossedOverKijunSen = tenkanSen > kijunSen && tenkanSenPrev <= kijunSenPrev; bool isTenkanSenCrossedUnderKijunSen = tenkanSen < kijunSen && tenkanSenPrev >= kijunSenPrev; // bool isKumoBullish = senkouSpanA > senkouSpanB; bool isKumoBearish = senkouSpanA < senkouSpanB; bool isFutureKumoBullish = senkouSpanAFuture > senkouSpanBFuture; bool isFutureKumoBearish = senkouSpanAFuture < senkouSpanBFuture; bool isKumoSwitchedToBullish = senkouSpanA > senkouSpanB && senkouSpanAPrev <= senkouSpanBPrev; bool isKumoSwitchedToBearish = senkouSpanA < senkouSpanB && senkouSpanAPrev >= senkouSpanBPrev; bool isFutureKumoSwitchedToBullish = senkouSpanAFuture > senkouSpanBFuture && senkouSpanAFuturePrev <= senkouSpanBFuturePrev; bool isFutureKumoSwitchedToBearish = senkouSpanAFuture < senkouSpanBFuture && senkouSpanAFuturePrev >= senkouSpanBFuturePrev; // bool isTenkanSenOverSenkouSpanA = tenkanSen > senkouSpanA; bool isTenkanSenUnderSenkouSpanA = tenkanSen < senkouSpanA; bool isTenkanSenOverFutureSenkouSpanA = tenkanSen > senkouSpanAFuture; bool isTenkanSenUnderFutureSenkouSpanA = tenkanSen < senkouSpanAFuture; bool isTenkanSenCrossedOverSenkouSpanA = tenkanSen > senkouSpanA && tenkanSenPrev <= senkouSpanAPrev; bool isTenkanSenCrossedUnderSenkouSpanA = tenkanSen < senkouSpanA && tenkanSenPrev >= senkouSpanAPrev; bool isTenkanSenCrossedOverFutureSenkouSpanA = tenkanSen > senkouSpanAFuture && tenkanSenPrev <= senkouSpanAFuturePrev; bool isTenkanSenCrossedUnderFutureSenkouSpanA = tenkanSen < senkouSpanAFuture && tenkanSenPrev >= senkouSpanAFuturePrev; // bool isTenkanSenOverSenkouSpanB = tenkanSen > senkouSpanB; bool isTenkanSenUnderSenkouSpanB = tenkanSen < senkouSpanB; bool isTenkanSenOverFutureSenkouSpanB = tenkanSen > senkouSpanBFuture; bool isTenkanSenUnderFutureSenkouSpanB = tenkanSen < senkouSpanBFuture; bool isTenkanSenCrossedOverSenkouSpanB = tenkanSen > senkouSpanB && tenkanSenPrev <= senkouSpanBPrev; bool isTenkanSenCrossedUnderSenkouSpanB = tenkanSen < senkouSpanB && tenkanSenPrev >= senkouSpanBPrev; bool isTenkanSenCrossedOverFutureSenkouSpanB = tenkanSen > senkouSpanBFuture && tenkanSenPrev <= senkouSpanBFuturePrev; bool isTenkanSenCrossedUnderFutureSenkouSpanB = tenkanSen < senkouSpanBFuture && tenkanSenPrev >= senkouSpanBFuturePrev; // bool isKijunSenOverSenkouSpanA = kijunSen > senkouSpanA; bool isKijunSenUnderSenkouSpanA = kijunSen < senkouSpanA; bool isKijunSenOverFutureSenkouSpanA = kijunSen > senkouSpanAFuture; bool isKijunSenUnderFutureSenkouSpanA = kijunSen < senkouSpanAFuture; bool isKijunSenCrossedOverSenkouSpanA = kijunSen > senkouSpanA && kijunSenPrev <= senkouSpanAPrev; bool isKijunSenCrossedUnderSenkouSpanA = kijunSen < senkouSpanA && kijunSenPrev >= senkouSpanAPrev; bool isKijunSenCrossedOverFutureSenkouSpanA = kijunSen > senkouSpanAFuture && kijunSenPrev <= senkouSpanAFuturePrev; bool isKijunSenCrossedUnderFutureSenkouSpanA = kijunSen < senkouSpanAFuture && kijunSenPrev >= senkouSpanAFuturePrev; // bool isKijunSenOverSenkouSpanB = kijunSen > senkouSpanB; bool isKijunSenUnderSenkouSpanB = kijunSen < senkouSpanB; bool isKijunSenOverFutureSenkouSpanB = kijunSen > senkouSpanBFuture; bool isKijunSenUnderFutureSenkouSpanB = kijunSen < senkouSpanBFuture; bool isKijunSenCrossedOverSenkouSpanB = kijunSen > senkouSpanB && kijunSenPrev <= senkouSpanB; bool isKijunSenCrossedUnderSenkouSpanB = kijunSen < senkouSpanB && kijunSenPrev >= senkouSpanB; bool isKijunSenCrossedOverFutureSenkouSpanB = kijunSen > senkouSpanBFuture && kijunSenPrev <= senkouSpanBFuturePrev; bool isKijunSenCrossedUnderFutureSenkouSpanB = kijunSen < senkouSpanBFuture && kijunSenPrev >= senkouSpanBFuturePrev; // result.tenkanSen = tenkanSen; result.kijunSen = kijunSen; result.chikouSpan = chikouSpan; result.senkouSpanA = senkouSpanA; result.senkouSpanB = senkouSpanB; result.senkouSpanAFuture = senkouSpanAFuture; result.senkouSpanBFuture = senkouSpanBFuture; // result.isTenkanSenOverKijunSen = isTenkanSenOverKijunSen; result.isTenkanSenUnderKijunSen = isTenkanSenUnderKijunSen; result.isTenkanSenCrossedOverKijunSen = isTenkanSenCrossedOverKijunSen; result.isTenkanSenCrossedUnderKijunSen = isTenkanSenCrossedUnderKijunSen; // result.isKumoBullish = isKumoBullish; result.isKumoBearish = isKumoBearish; result.isFutureKumoBullish = isFutureKumoBullish; result.isFutureKumoBearish = isFutureKumoBearish; result.isKumoSwitchedToBullish = isKumoSwitchedToBullish; result.isKumoSwitchedToBearish = isKumoSwitchedToBearish; result.isFutureKumoSwitchedToBullish = isFutureKumoSwitchedToBullish; result.isFutureKumoSwitchedToBearish = isFutureKumoSwitchedToBearish; // result.isTenkanSenOverSenkouSpanA = isTenkanSenOverSenkouSpanA; result.isTenkanSenUnderSenkouSpanA = isTenkanSenUnderSenkouSpanA; result.isTenkanSenOverFutureSenkouSpanA = isTenkanSenOverFutureSenkouSpanA; result.isTenkanSenUnderFutureSenkouSpanA = isTenkanSenUnderFutureSenkouSpanA; result.isTenkanSenCrossedOverSenkouSpanA = isTenkanSenCrossedOverSenkouSpanA; result.isTenkanSenCrossedUnderSenkouSpanA = isTenkanSenCrossedUnderSenkouSpanA; result.isTenkanSenCrossedOverFutureSenkouSpanA = isTenkanSenCrossedOverFutureSenkouSpanA; result.isTenkanSenCrossedUnderFutureSenkouSpanA = isTenkanSenCrossedUnderFutureSenkouSpanA; // result.isTenkanSenOverSenkouSpanB = isTenkanSenOverSenkouSpanB; result.isTenkanSenUnderSenkouSpanB = isTenkanSenUnderSenkouSpanB; result.isTenkanSenOverFutureSenkouSpanB = isTenkanSenOverFutureSenkouSpanB; result.isTenkanSenUnderFutureSenkouSpanB = isTenkanSenUnderFutureSenkouSpanB; result.isTenkanSenCrossedOverSenkouSpanB = isTenkanSenCrossedOverSenkouSpanB; result.isTenkanSenCrossedUnderSenkouSpanB = isTenkanSenCrossedUnderSenkouSpanB; result.isTenkanSenCrossedOverFutureSenkouSpanB = isTenkanSenCrossedOverFutureSenkouSpanB; result.isTenkanSenCrossedUnderFutureSenkouSpanB = isTenkanSenCrossedUnderFutureSenkouSpanB; // result.isKijunSenOverSenkouSpanA = isKijunSenOverSenkouSpanA; result.isKijunSenUnderSenkouSpanA = isKijunSenUnderSenkouSpanA; result.isKijunSenOverFutureSenkouSpanA = isKijunSenOverFutureSenkouSpanA; result.isKijunSenUnderFutureSenkouSpanA = isKijunSenUnderFutureSenkouSpanA; result.isKijunSenCrossedOverSenkouSpanA = isKijunSenCrossedOverSenkouSpanA; result.isKijunSenCrossedUnderSenkouSpanA = isKijunSenCrossedUnderSenkouSpanA; result.isKijunSenCrossedOverFutureSenkouSpanA = isKijunSenCrossedOverFutureSenkouSpanA; result.isKijunSenCrossedUnderFutureSenkouSpanA = isKijunSenCrossedUnderFutureSenkouSpanA; // result.isKijunSenOverSenkouSpanB = isKijunSenOverSenkouSpanB; result.isKijunSenUnderSenkouSpanB = isKijunSenUnderSenkouSpanB; result.isKijunSenOverFutureSenkouSpanB = isKijunSenOverFutureSenkouSpanB; result.isKijunSenUnderFutureSenkouSpanB = isKijunSenUnderFutureSenkouSpanB; result.isKijunSenCrossedOverSenkouSpanB = isKijunSenCrossedOverSenkouSpanB; result.isKijunSenCrossedUnderSenkouSpanB = isKijunSenCrossedUnderSenkouSpanB; result.isKijunSenCrossedOverFutureSenkouSpanB = isKijunSenCrossedOverFutureSenkouSpanB; result.isKijunSenCrossedUnderFutureSenkouSpanB = isKijunSenCrossedUnderFutureSenkouSpanB; // return result; } // // END Provided Functions ... // // // Protected ... protected: // // Private ... private: // // Indicator Properties ... // // TENKANSEN ... // // Length ... int mTenkanSenLength; // // Calculation Mode ... ENUM_X_ICHIMOKU_CALCULATION_MODE mTenkanSenMode; // // KIJUNSEN ... // // Length ... int mKijunSenLength; // // Calculation Mode ... ENUM_X_ICHIMOKU_CALCULATION_MODE mKijunSenMode; // // SENKOUSPANB ... // // Length ... int mSenkouSpanBLength; // // Calculation Mode ... ENUM_X_ICHIMOKU_CALCULATION_MODE mSenkouSpanBMode; // // CHIKOUSPAN ... // // Price Type ... ENUM_APPLIED_PRICE mChikuoSpanAppliedTo; // // Presentation ... // // Show Tenkan Sen ... bool mShowTenkanSen; // // Show Kijun Sen ... bool mShowKijunSen; // // Show Kijun Sen + ... bool mShowKijunSenPlus; // // Show Kijun Sen - ... bool mShowKijunSenNegative; // // Show Chikou Span ... bool mShowChikouSpan; // // Show Senkou Span A ... bool mShowSenkouSpanA; // // Show Senkou Span B ... bool mShowSenkouSpanB; // // Show Kumo ... bool mShowKumo; // // Shift Kumo to Future ... bool mShiftKumo; }; // // START Usefull Functions ... // // // END Usefull Functions ... //