/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Library // --------------------------------------- // Name: XCATBLib // Description: required Parsers for XCATB ... // // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... #property library #property copyright "Copyright `023, SaherElm IT Center" #property link "https://www.saherelm.ir" #property version "1.00" #property strict // // Imports ... #include "../Classes/x-saherelm.x-bar.analyser.class.mq5" #include "../Classes/x-saherelm.x-poi.drawer.class.mq5" #include "../Helpers/x-saherelm.x121.xcatb.helper.mq5" #include "../Libraries/x-saherelm.common.lib.mq5"; #include "../Libraries/x-saherelm.x-poi.lib.mq5" // // Definiions ... // struct XTriggerBlock { // // Props ... XBoxZone ob; // Order Block XBoxZone fvg; // Fair Value Gap XOHCL swingBar; // Swing of Trigger XBoxZone trigger; // Trigger Block XBoxZone rLiquidity; // Reversal Liquidity XBoxZone fLiquidity; // Following Liquidity // XSignal signal; // Pepared Signal // // Constructor ... XTriggerBlock() { Clean(); } // // Tools ... // // Cleanup ... void Clean() { // ob.Clean(); fvg.Clean(); signal.Clean(); trigger.Clean(); swingBar.Clean(); rLiquidity.Clean(); fLiquidity.Clean(); // ZeroMemory(this); } // // Validate ... bool IsValid() { // bool result = false; // result = ob.IsValid() && fvg.IsValid() && trigger.IsValid(); // return result; } // bool IsBullish() { return IsValid() && ob.IsBullish(); } // bool IsBearish() { return IsValid() && ob.IsBearish(); } // int ToIndex() { return trigger.ToIndex(); } // int FromIndex() { return trigger.FromIndex(); } // ENUM_X_DIRECTION GetDirection() { // ENUM_X_DIRECTION result = X_DIRECTION_NONE; // if (IsValid()) { result = ob.dir; } // return result; } // }; // // Extensions ... // bool DetectSignalZone1( XCPOIDrawer *&drawer, XCX121XCatbHelper *helper, XCBarAnalyser *barAnalyser, XBoxZone &signalZone, X121XCatbConditions &conditions, int barIndex = 0, int loopback = 10 // ) { // bool result = false; // // Checking Conditions ... // // Normalize Args ... signalZone.Clean(); conditions.Clean(); barIndex = NormalizeInt(barIndex, 0); loopback = NormalizeInt(loopback, 0); // // Validate Args ... result = helper != NULL && barAnalyser != NULL; if (!result) { return result; } // // Reading Market Conditions ... result = helper.GetConditions( conditions, barIndex, loopback // ); if (!result) { // signalZone.Clean(); conditions.Clean(); } // int zIDX = 0; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int p2IDX = pIDX + 1; int p3IDX = p2IDX + 1; int p4IDX = p3IDX + 1; // // Checking Conditions ... // // Detect Bar Verifications ... // ENUM_X_DIRECTION iDir; // // Rejected ... bool isRejected = barAnalyser .IsRejected( conditions.bars[cIDX], iDir // ); bool isBullishRejected = isRejected && IsBullish(iDir); bool isBearishRejected = isRejected && IsBearish(iDir); // // Engulfed ... bool isEngulfed = barAnalyser .IsEngulfed( conditions.bars[cIDX], iDir // ); bool isBullishEngulfed = isEngulfed && IsBullish(iDir); bool isBearishEngulfed = isEngulfed && IsBearish(iDir); // // Momentum ... bool isMomentum = barAnalyser .IsMomentum( conditions.bars[cIDX], iDir // ); bool isBullishMomentum = isMomentum && IsBullish(iDir); bool isBearishMomentum = isMomentum && IsBearish(iDir); // bool isBarBullishPressured = isBullishRejected || isBullishEngulfed || isBullishMomentum; // bool isBarBearishPressured = isBearishRejected || isBearishEngulfed || isBearishMomentum; // // Detect Indicator Base Start Directional Movement ... // // SAR ... // bool isSarBullishStart = // ( // // Current SAR is Directional ... conditions.isSarBullish && // // Previous InDirectional Sar Exists ... helper.lastSarBearish.IsValid() && // // Current Close is Over previous Sar ... conditions.bars[cIDX].close > helper.lastSarBearish.after && // // Before Close is not Over previous Sar ... conditions.bars[pIDX].close <= helper.lastSarBearish.after // ) // ; // bool isSarBearishStart = // ( // // Current SAR is Directional ... conditions.isSarBearish && // // Previous InDirectional Sar Exists ... helper.lastSarBullish.IsValid() && // // Current Close is Under previous ... conditions.bars[cIDX].close < helper.lastSarBullish.after && // // Before Close is not Under previous ... conditions.bars[pIDX].close >= helper.lastSarBullish.after // ) // ; // // TREND ... // bool isTrendBullishStart = // ( // // Current Trend is Directional ... conditions.isTrendBullish && // // Previous InDirectiona; Trend Exists ... helper.lastTrendBearish.IsValid() && // // Current Close is Over previous ... conditions.bars[cIDX].close > helper.lastTrendBearish.after && // // Before close is not Over previous ... conditions.bars[pIDX].close <= helper.lastTrendBearish.after // ) // ; // bool isTrendBearishStart = // ( // // Current Trend is Directional ... conditions.isTrendBearish && // // Previous InDirectiona; Trend Exists ... helper.lastTrendBullish.IsValid() && // // Current Close is Under previous ... conditions.bars[cIDX].close < helper.lastTrendBullish.after && // // Before close is not Under previous ... conditions.bars[pIDX].close >= helper.lastTrendBullish.after // ) // ; // // ADX ... // bool isADXBullishStart = // ( // // ADX Value is Switched to Strong ... conditions.adxBuffer[cIDX] > conditions.adxThreshold && conditions.adxBuffer[pIDX] <= conditions.adxThreshold && // // ADX must Up ... conditions.adxBuffer[cIDX] > conditions.adxBuffer[pIDX] && // // ADX +DI is Bigger than -DI ... conditions.adxpBuffer[cIDX] > conditions.adxnBuffer[cIDX] && // // ADX +DI is Up ... conditions.adxpBuffer[cIDX] > conditions.adxpBuffer[pIDX] // ) // ; // bool isADXBearishStart = // ( // // ADX Value is Switched to Strong ... conditions.adxBuffer[cIDX] > conditions.adxThreshold && conditions.adxBuffer[pIDX] <= conditions.adxThreshold && // // ADX must Up ... conditions.adxBuffer[cIDX] > conditions.adxBuffer[pIDX] && // // ADX -DI is Bigger than +DI ... conditions.adxnBuffer[cIDX] > conditions.adxpBuffer[cIDX] && // // ADX -DI is Up ... conditions.adxnBuffer[cIDX] > conditions.adxnBuffer[pIDX] // ) // ; // // DELTA ... // bool isDeltaBullishStart = // // Check State ... ( // // Delta is Up ... conditions.deltaBuffer[cIDX] > conditions.deltaBuffer[pIDX] && // // Delta Signal is Up ... conditions.deltaSignalBuffer[cIDX] > conditions.deltaSignalBuffer[pIDX] && // // Delta Crossed Over Delta Signal ... conditions.deltaBuffer[cIDX] > conditions.deltaSignalBuffer[cIDX] // ) // && // // Check Last InDirectional Exists ... helper.lastDeltaBearish.IsValid() && // // Current Close is Over last ... conditions.bars[cIDX].close > helper.lastDeltaBearish.after && // // Before Close is not Over last ... conditions.bars[pIDX].close <= helper.lastDeltaBearish.after // ; // bool isDeltaBearishStart = // // Check State ... ( // // Delta is Down ... conditions.deltaBuffer[cIDX] < conditions.deltaBuffer[pIDX] && // // Delta Signal is Down ... conditions.deltaSignalBuffer[cIDX] < conditions.deltaSignalBuffer[pIDX] && // // Delta Crossed Under Delta Signal ... conditions.deltaBuffer[cIDX] < conditions.deltaSignalBuffer[cIDX] // ) // && // // Check Last InDirectional Exists ... helper.lastDeltaBullish.IsValid() && // // Current Close is Under last ... conditions.bars[cIDX].close < helper.lastDeltaBullish.after && // // Before Close is not Under last ... conditions.bars[pIDX].close >= helper.lastDeltaBullish.after // ; // // VOLUME ... // bool isVolumeBullishStart = // ( // // // Volume is Up ... conditions.bullishVolumeBuffer[1] > conditions.bullishVolumeBuffer[2] && // // Volume Signal is Up ... conditions.bullishVolumeSignalBuffer[1] > conditions.bullishVolumeSignalBuffer[2] && // // Volume Signals Crossed Over ... conditions.bullishVolumeSignalBuffer[1] > conditions.bearishVolumeSignalBuffer[1] // ) // && // // Check Last InDirectional Exists ... helper.lastVolumeBearish.IsValid() && // // Current Close is Over last ... conditions.bars[cIDX].close > helper.lastVolumeBearish.after && // // Before Close is not Over last ... conditions.bars[pIDX].close <= helper.lastVolumeBearish.after // ; // bool isVolumeBearishStart = // ( // // // Volume is Up ... conditions.bearishVolumeBuffer[1] > conditions.bearishVolumeBuffer[2] && // // Volume Signal is Up ... conditions.bearishVolumeSignalBuffer[1] > conditions.bearishVolumeSignalBuffer[2] && // // Volume Signals Crossed Over ... conditions.bearishVolumeSignalBuffer[1] > conditions.bullishVolumeSignalBuffer[1] // ) // && // // Check Last InDirectional Exists ... helper.lastVolumeBullish.IsValid() && // // Current Close is Over last ... conditions.bars[cIDX].close < helper.lastVolumeBullish.after && // // Before Close is not Over last ... conditions.bars[pIDX].close >= helper.lastVolumeBullish.after // ; // // SIGNAL Bar ... // bool isSBarBullishStart = // ( // // Check Direction ... conditions.isSBarBullish && // // Previous InDirectional Exists ... helper.lastSignalBarBearish.IsValid() && // // Current Signal Bar close over prev ... conditions.sBarCloseBuffer[cIDX] > helper.lastSignalBarBearish.after && // // Prev Signal Bar not close over prev ... conditions.sBarCloseBuffer[pIDX] <= helper.lastSignalBarBearish.after // ) // ; // bool isSBarBearishStart = // ( // // Check Direction ... conditions.isSBarBearish && // // Previous InDirectional Exists ... helper.lastSignalBarBullish.IsValid() && // // Current Signal Bar close over prev ... conditions.sBarCloseBuffer[cIDX] < helper.lastSignalBarBullish.after && // // Prev Signal Bar not close over prev ... conditions.sBarCloseBuffer[pIDX] >= helper.lastSignalBarBullish.after // ) // ; // // HKSIGNAL Bar ... // bool isHKSBarBullishStart = // ( // // Check Direction ... conditions.isHKSBarBullish && // // Previous InDirectional Exists ... helper.lastHKSignalBarBearish.IsValid() && // // Current Signal Bar close over prev ... conditions.hkSBarCloseBuffer[cIDX] > helper.lastHKSignalBarBearish.after && // // Prev Signal Bar not close over prev ... conditions.hkSBarCloseBuffer[pIDX] <= helper.lastHKSignalBarBearish.after // ) // ; // bool isHKSBarBearishStart = // ( // // Check Direction ... conditions.isHKSBarBearish && // // Previous InDirectional Exists ... helper.lastHKSignalBarBullish.IsValid() && // // Current Signal Bar close over prev ... conditions.hkSBarCloseBuffer[cIDX] < helper.lastHKSignalBarBullish.after && // // Prev Signal Bar not close over prev ... conditions.hkSBarCloseBuffer[pIDX] >= helper.lastHKSignalBarBullish.after // ) // ; // // Check for Vale and Peak ... // bool isPeakOverLast = // (conditions.peakBuffer[cIDX] > conditions.peakBuffer[pIDX] && conditions.peakBuffer[pIDX] <= conditions.peakBuffer[p2IDX] && conditions.bars[cIDX].close > conditions.peakBuffer[pIDX]) // ; // bool isValeUnderLast = // (conditions.valeBuffer[cIDX] < conditions.valeBuffer[pIDX] && conditions.valeBuffer[pIDX] >= conditions.valeBuffer[p2IDX] && conditions.bars[cIDX].close < conditions.valeBuffer[pIDX]) // ; // // Start Different Conditions Implemntation ... // // Condition 1: // --------------------------- // Descriptions: // // // --------------------------- // // Bullish ... bool isCond1Bullish = false; // // Bearish ... bool isCond1Bearish = false; // // Try to Summarize Conditions ... // bool isBullishPassed = // isCond1Bullish // ; // bool isBearishPassed = // isCond1Bearish // ; // // Summarize Result ... result = isBullishPassed || isBearishPassed; // return result; } bool DetectTriggerBlock( XCPOIDrawer *drawer, XCX121XCatbHelper *helper, XCBarAnalyser *barAnalyser, X121XCatbConditions &conditions, XTriggerBlock &tb, int barIndex = 0, int loopback = 10 // ) { // bool result = false; // // Normalize Args ... tb.Clean(); conditions.Clean(); barIndex = NormalizeInt(barIndex, 0); loopback = NormalizeInt(loopback, 0); // // Validate Args ... result = helper != NULL; if (!result) { return result; } // // Reading Market Conditions ... result = helper.GetConditions( conditions, barIndex, loopback // ); if (!result) { // tb.Clean(); conditions.Clean(); } // int zIDX = 0; int cIDX = zIDX + 1; int pIDX = cIDX + 1; int p2IDX = pIDX + 1; int p3IDX = p2IDX + 1; int p4IDX = p3IDX + 1; // // Checking Conditions ... // // Detect Bar Verifications ... // ENUM_X_DIRECTION iDir; // // Rejected ... bool isRejected = barAnalyser .IsRejected( conditions.bars[cIDX], iDir // ); bool isBullishRejected = isRejected && IsBullish(iDir); bool isBearishRejected = isRejected && IsBearish(iDir); // // Engulfed ... bool isEngulfed = barAnalyser .IsEngulfed( conditions.bars[cIDX], iDir // ); bool isBullishEngulfed = isEngulfed && IsBullish(iDir); bool isBearishEngulfed = isEngulfed && IsBearish(iDir); // // Momentum ... bool isMomentum = barAnalyser .IsMomentum( conditions.bars[cIDX], iDir // ); bool isBullishMomentum = isMomentum && IsBullish(iDir); bool isBearishMomentum = isMomentum && IsBearish(iDir); // bool isBarBullishPressured = isBullishRejected || isBullishEngulfed || isBullishMomentum; // bool isBarBearishPressured = isBearishRejected || isBearishEngulfed || isBearishMomentum; // // Detect Indicator Base Start Directional Movement ... // // SAR ... // bool isSarBullishStart = // ( // // Current SAR is Directional ... conditions.isSarBullish && // // Previous InDirectional Sar Exists ... helper.lastSarBearish.IsValid() && // // Current Close is Over previous Sar ... conditions.bars[cIDX].close > helper.lastSarBearish.after && // // Before Close is not Over previous Sar ... conditions.bars[pIDX].close <= helper.lastSarBearish.after // ) // ; // bool isSarBearishStart = // ( // // Current SAR is Directional ... conditions.isSarBearish && // // Previous InDirectional Sar Exists ... helper.lastSarBullish.IsValid() && // // Current Close is Under previous ... conditions.bars[cIDX].close < helper.lastSarBullish.after && // // Before Close is not Under previous ... conditions.bars[pIDX].close >= helper.lastSarBullish.after // ) // ; // // TREND ... // bool isTrendBullishStart = // ( // // Current Trend is Directional ... conditions.isTrendBullish && // // Previous InDirectiona; Trend Exists ... helper.lastTrendBearish.IsValid() && // // Current Close is Over previous ... conditions.bars[cIDX].close > helper.lastTrendBearish.after && // // Before close is not Over previous ... conditions.bars[pIDX].close <= helper.lastTrendBearish.after // ) // ; // bool isTrendBearishStart = // ( // // Current Trend is Directional ... conditions.isTrendBearish && // // Previous InDirectiona; Trend Exists ... helper.lastTrendBullish.IsValid() && // // Current Close is Under previous ... conditions.bars[cIDX].close < helper.lastTrendBullish.after && // // Before close is not Under previous ... conditions.bars[pIDX].close >= helper.lastTrendBullish.after // ) // ; // // ADX ... // bool isADXBullishStart = // ( // // ADX Value is Switched to Strong ... conditions.adxBuffer[cIDX] > conditions.adxThreshold && conditions.adxBuffer[pIDX] <= conditions.adxThreshold && // // ADX must Up ... conditions.adxBuffer[cIDX] > conditions.adxBuffer[pIDX] && // // ADX +DI is Bigger than -DI ... conditions.adxpBuffer[cIDX] > conditions.adxnBuffer[cIDX] && // // ADX +DI is Up ... conditions.adxpBuffer[cIDX] > conditions.adxpBuffer[pIDX] // ) // ; // bool isADXBearishStart = // ( // // ADX Value is Switched to Strong ... conditions.adxBuffer[cIDX] > conditions.adxThreshold && conditions.adxBuffer[pIDX] <= conditions.adxThreshold && // // ADX must Up ... conditions.adxBuffer[cIDX] > conditions.adxBuffer[pIDX] && // // ADX -DI is Bigger than +DI ... conditions.adxnBuffer[cIDX] > conditions.adxpBuffer[cIDX] && // // ADX -DI is Up ... conditions.adxnBuffer[cIDX] > conditions.adxnBuffer[pIDX] // ) // ; // // DELTA ... // bool isDeltaBullishStart = // // Check State ... ( // // Delta is Up ... conditions.deltaBuffer[cIDX] > conditions.deltaBuffer[pIDX] && // // Delta Signal is Up ... conditions.deltaSignalBuffer[cIDX] > conditions.deltaSignalBuffer[pIDX] && // // Delta Crossed Over Delta Signal ... conditions.deltaBuffer[cIDX] > conditions.deltaSignalBuffer[cIDX] // ) // && // // Check Last InDirectional Exists ... helper.lastDeltaBearish.IsValid() && // // Current Close is Over last ... conditions.bars[cIDX].close > helper.lastDeltaBearish.after && // // Before Close is not Over last ... conditions.bars[pIDX].close <= helper.lastDeltaBearish.after // ; // bool isDeltaBearishStart = // // Check State ... ( // // Delta is Down ... conditions.deltaBuffer[cIDX] < conditions.deltaBuffer[pIDX] && // // Delta Signal is Down ... conditions.deltaSignalBuffer[cIDX] < conditions.deltaSignalBuffer[pIDX] && // // Delta Crossed Under Delta Signal ... conditions.deltaBuffer[cIDX] < conditions.deltaSignalBuffer[cIDX] // ) // && // // Check Last InDirectional Exists ... helper.lastDeltaBullish.IsValid() && // // Current Close is Under last ... conditions.bars[cIDX].close < helper.lastDeltaBullish.after && // // Before Close is not Under last ... conditions.bars[pIDX].close >= helper.lastDeltaBullish.after // ; // // VOLUME ... // bool isVolumeBullishStart = // ( // // // Volume is Up ... conditions.bullishVolumeBuffer[1] > conditions.bullishVolumeBuffer[2] && // // Volume Signal is Up ... conditions.bullishVolumeSignalBuffer[1] > conditions.bullishVolumeSignalBuffer[2] && // // Volume Signals Crossed Over ... conditions.bullishVolumeSignalBuffer[1] > conditions.bearishVolumeSignalBuffer[1] // ) // && // // Check Last InDirectional Exists ... helper.lastVolumeBearish.IsValid() && // // Current Close is Over last ... conditions.bars[cIDX].close > helper.lastVolumeBearish.after && // // Before Close is not Over last ... conditions.bars[pIDX].close <= helper.lastVolumeBearish.after // ; // bool isVolumeBearishStart = // ( // // // Volume is Up ... conditions.bearishVolumeBuffer[1] > conditions.bearishVolumeBuffer[2] && // // Volume Signal is Up ... conditions.bearishVolumeSignalBuffer[1] > conditions.bearishVolumeSignalBuffer[2] && // // Volume Signals Crossed Over ... conditions.bearishVolumeSignalBuffer[1] > conditions.bullishVolumeSignalBuffer[1] // ) // && // // Check Last InDirectional Exists ... helper.lastVolumeBullish.IsValid() && // // Current Close is Over last ... conditions.bars[cIDX].close < helper.lastVolumeBullish.after && // // Before Close is not Over last ... conditions.bars[pIDX].close >= helper.lastVolumeBullish.after // ; // // SIGNAL Bar ... // bool isSBarBullishStart = // ( // // Check Direction ... conditions.isSBarBullish && // // Previous InDirectional Exists ... helper.lastSignalBarBearish.IsValid() && // // Current Signal Bar close over prev ... conditions.sBarCloseBuffer[cIDX] > helper.lastSignalBarBearish.after && // // Prev Signal Bar not close over prev ... conditions.sBarCloseBuffer[pIDX] <= helper.lastSignalBarBearish.after // ) // ; // bool isSBarBearishStart = // ( // // Check Direction ... conditions.isSBarBearish && // // Previous InDirectional Exists ... helper.lastSignalBarBullish.IsValid() && // // Current Signal Bar close over prev ... conditions.sBarCloseBuffer[cIDX] < helper.lastSignalBarBullish.after && // // Prev Signal Bar not close over prev ... conditions.sBarCloseBuffer[pIDX] >= helper.lastSignalBarBullish.after // ) // ; // // HKSIGNAL Bar ... // bool isHKSBarBullishStart = // ( // // Check Direction ... conditions.isHKSBarBullish && // // Previous InDirectional Exists ... helper.lastHKSignalBarBearish.IsValid() && // // Current Signal Bar close over prev ... conditions.hkSBarCloseBuffer[cIDX] > helper.lastHKSignalBarBearish.after && // // Prev Signal Bar not close over prev ... conditions.hkSBarCloseBuffer[pIDX] <= helper.lastHKSignalBarBearish.after // ) // ; // bool isHKSBarBearishStart = // ( // // Check Direction ... conditions.isHKSBarBearish && // // Previous InDirectional Exists ... helper.lastHKSignalBarBullish.IsValid() && // // Current Signal Bar close over prev ... conditions.hkSBarCloseBuffer[cIDX] < helper.lastHKSignalBarBullish.after && // // Prev Signal Bar not close over prev ... conditions.hkSBarCloseBuffer[pIDX] >= helper.lastHKSignalBarBullish.after // ) // ; // // Check for Vale and Peak ... // bool isPeakOverLast = // (conditions.peakBuffer[cIDX] > conditions.peakBuffer[pIDX] && conditions.peakBuffer[pIDX] <= conditions.peakBuffer[p2IDX] && conditions.bars[cIDX].close > conditions.peakBuffer[pIDX]) // || // (conditions.peakBuffer[pIDX] > conditions.peakBuffer[p2IDX] && conditions.peakBuffer[p2IDX] <= conditions.peakBuffer[p3IDX] && conditions.bars[pIDX].close > conditions.peakBuffer[p2IDX]) // || // (conditions.peakBuffer[p2IDX] > conditions.peakBuffer[p3IDX] && conditions.peakBuffer[p3IDX] <= conditions.peakBuffer[p4IDX] && conditions.bars[p2IDX].close > conditions.peakBuffer[p3IDX]) // ; // bool isValeUnderLast = // (conditions.valeBuffer[cIDX] < conditions.valeBuffer[pIDX] && conditions.valeBuffer[pIDX] >= conditions.valeBuffer[p2IDX] && conditions.bars[cIDX].close < conditions.valeBuffer[pIDX]) // || // (conditions.valeBuffer[pIDX] < conditions.valeBuffer[p2IDX] && conditions.valeBuffer[p2IDX] >= conditions.valeBuffer[p3IDX] && conditions.bars[pIDX].close < conditions.valeBuffer[p2IDX]) // || // (conditions.valeBuffer[p2IDX] < conditions.valeBuffer[p3IDX] && conditions.valeBuffer[p3IDX] >= conditions.valeBuffer[p4IDX] && conditions.bars[p2IDX].close < conditions.valeBuffer[p3IDX]) // ; // // if (isValeUnderLast) // { // Print("SALAM"); // } // // Try to Summarize Conditions ... // bool isBullishPassed = // (isPeakOverLast && isDeltaBullishStart && isVolumeBullishStart && isBarBullishPressured) // ; // bool isBearishPassed = (isValeUnderLast && isDeltaBearishStart && isVolumeBearishStart && isBarBearishPressured) // ; // // Try to Detect Trigger Block ... bool hasTB = false; int tbLoopback = 100; X121XCatbInputs mInputs = helper.GetInputs(); for (int i = barIndex; i < barIndex + tbLoopback; i++) { // // Update Helper ... helper.Update(i); // // Check TB ... hasTB = DetectTriggerBlock( // conditions.symbol, conditions.period, // tb, // drawer, barAnalyser, // // Required Buffers ... helper.atrBuffer, helper.rsiBuffer, helper.adxBuffer, helper.adxpBuffer, helper.adxnBuffer, helper.peakBuffer, helper.valeBuffer, helper.deltaBuffer, helper.sarBuffer, helper.sarStateBuffer, helper.trendBuffer, helper.trendStateBuffer, helper.atrUpperBuffer, helper.atrLowerBuffer, helper.sBarOpenBuffer, helper.sBarCloseBuffer, helper.hkSBarOpenBuffer, helper.hkSBarCloseBuffer, helper.peakGoldenBuffer, helper.valeGoldenBuffer, helper.deltaSignalBuffer, helper.bullishVolumeSignalBuffer, helper.bearishVolumeSignalBuffer, // i + 1, // // Signalling ... mInputs.signalR2R, mInputs.slAtrMultiplier, // // Configs ... mInputs.rsiOBLevel, mInputs.rsiOSLevel, mInputs.adxThreshold, // // Validators ... mInputs.forceObBarType, mInputs.forceOBFVGBarType, mInputs.forceHasSwing, mInputs.forceHasFLiquidity, mInputs.forceHasRLiquidity, mInputs.validateGapSequence, mInputs.validateBlockEdgeBreakout, // // Filters ... mInputs.filterBasedOnPV, mInputs.filterBasedOnSar, mInputs.filterBasedOnRSI, mInputs.filterBasedOnADX, mInputs.filterBasedOnATR, mInputs.filterBasedOnTrend, mInputs.filterBasedOnDelta, mInputs.filterBasedOnVolume, mInputs.filterBasedOnSignalBar, mInputs.filterBasedOnHKSignalBar // ); // // Checking Trigger Block Validation ... hasTB = // hasTB && // ( // (isBullishPassed && tb.IsBullish()) // || // (isBearishPassed && tb.IsBearish()) // ); if (hasTB) { // break; } // tb.Clean(); } // // isBullishPassed = false; // isBearishPassed = false; // // Draw Line for Detect Conditions States on Chart ... if (hasTB && (isBullishPassed || isBearishPassed)) { // color iColor = isBullishPassed ? clrAqua : clrMagenta; // datetime iTime = conditions.bars[cIDX].time; // string iName = "VL_" + ToFormatString(iTime); // long chartID = drawer.ChartIdentification(); int subWindow = drawer.SubWindowIdentification(); // CChartObjectVLine *iObj; iObj = new CChartObjectVLine(); bool isDrawn = iObj.Create( chartID, iName, subWindow, iTime // ); if (isDrawn) { // iObj.Color(iColor); } // CArrayObj *tbObjects = new CArrayObj(); DrawTriggerBlock( tb, drawer, tbObjects, conditions.bars[0].time // ); // tb.Clean(); } // // Summarizing result ... // result = (isBullishPassed || isBearishPassed); // // Cleanup Resources ... // if (!result) { // tb.Clean(); conditions.Clean(); } // return result; } // // Detect Trigger Block ... bool DetectTriggerBlock( // string symbol, ENUM_TIMEFRAMES period, // XTriggerBlock &tb, // XCPOIDrawer *drawer, XCBarAnalyser *barAnalyser, // // Required Buffers ... const double &_atrBuffer[], const double &_rsiBuffer[], const double &_adxBuffer[], const double &_adxpBuffer[], const double &_adxnBuffer[], const double &_peakBuffer[], const double &_valeBuffer[], const double &_deltaBuffer[], const double &_sarBuffer[], const double &_sarStateBuffer[], const double &_trendBuffer[], const double &_trendStateBuffer[], const double &_atrUpperBuffer[], const double &_atrLowerBuffer[], const double &_sBarOpenSBuffer[], const double &_sBarCloseBuffer[], const double &_hkSBarOpenBuffer[], const double &_hkSBarCloseBuffer[], const double &_peakGoldenBuffer[], const double &_valeGoldenBuffer[], const double &_deltaSignalBuffer[], const double &_bullishVolumeSignalBuffer[], const double &_bearishVolumeSignalBuffer[], // int barIndex, // int _r2r, double _slAtrMultiplier, // // Configs ... double _rsiOBLevel, double _rsiOSLevel, double _adxThreshold, // // Validators ... // bool _forceObBarType = false, bool _forceFVGBarType = false, bool _forceHasSwing = false, bool _forceHasFLiquidity = false, bool _forceHasRLiquidity = false, bool _validateGapSequence = false, bool _validateBlockEdgeBreakout = false, // // Filters ... bool _filterBasedOnPV = false, bool _filterBasedOnSar = false, bool _filterBasedOnRSI = false, bool _filterBasedOnADX = false, bool _filterBasedOnATR = false, bool _filterBasedOnTrend = false, bool _filterBasedOnDelta = false, bool _filterBasedOnVolume = false, bool _filterBasedOnSignalBar = false, bool _filterBasedOnHKSignalBar = false // ) { // bool result = false; // // Custom Configs ... // // // _r2r = 2; // _slAtrMultiplier = 1; // // // // Validators ... // _forceHasSwing = true; // _forceObBarType = true; // _forceFVGBarType = true; // _validateGapSequence = true; // // // _forceHasFLiquidity = false; // _forceHasRLiquidity = false; // _validateBlockEdgeBreakout = true; // // // // Filters ... // _filterBasedOnPV = true; // _filterBasedOnATR = true; // _filterBasedOnDelta = true; // _filterBasedOnVolume = true; // // // _filterBasedOnSar = true; // _filterBasedOnRSI = false; // _filterBasedOnADX = false; // _filterBasedOnTrend = false; // _filterBasedOnSignalBar = true; // _filterBasedOnHKSignalBar = true; // tb.Clean(); // result = barAnalyser != NULL; if (!result) { return result; } // int zIDX = 0; bool has = false; bool isDone = false; ENUM_X_DIRECTION iDir = X_DIRECTION_NONE; // // Retrieve Required Bars ... // XOHCL iBar; XOHCL zBar; // Current Start Checking Bar (Usually Used for Triggering) ... has = zBar.Init( symbol, period, barIndex // ); // // Detect Based Order Block ... has = has && barAnalyser.IsOB( zBar, tb.ob, _forceFVGBarType, // Force FVG Bar Type ... _forceObBarType // Force Block Two Bar Checking ... ); // // Detect Based Fair Value Gap ... has = has && barAnalyser.IsFVG( zBar, tb.fvg, _forceFVGBarType // Force FVG Bar Type ... ); // // Clone Trigger Block ... if (has) { // tb.trigger = tb.ob; tb.trigger.type = "XTRGB"; } // bool isBullish = has && tb.IsBullish(); // bool isBearish = has && tb.IsBearish(); // int toIDX = tb.ToIndex(); int fromIDX = tb.FromIndex(); // // Verifications and Filters ... // int loopback = 144; // // Forces ... // // Force Has Proper Swing ... if (has && _forceHasSwing) { // XOHCL iPBar; XOHCL iP2Bar; toIDX = tb.ToIndex(); fromIDX = tb.FromIndex(); for (int i = toIDX; i <= fromIDX; i++) { // // Initialize iBar ... isDone = iBar.Init( zBar.symbol, zBar.period, i // ); isDone = isDone && iBar.GetPreviousBar(iPBar); isDone = isDone && iPBar.GetPreviousBar(iP2Bar); isDone = isDone && barAnalyser.IsSimpleSwing( iBar, iDir // ) && iDir == tb.GetDirection(); if (isDone) { // bool canSet = !tb.swingBar.IsValid() ? true : (isBullish ? tb.swingBar.low > iP2Bar.low : tb.swingBar.high < iP2Bar.high); if (canSet) { tb.swingBar = iP2Bar; } } // iBar.Clean(); iPBar.Clean(); iP2Bar.Clean(); } // has = tb.swingBar.IsValid(); } // // Force Has Liquidity ... // TODO: Add Validation based on Liquidities // if necessary ... if (has && (_forceHasFLiquidity || _forceHasRLiquidity)) { // toIDX = tb.ToIndex(); fromIDX = tb.FromIndex(); for (int i = toIDX; i < fromIDX + loopback; i++) { // // Initialize iBar ... isDone = iBar.Init( zBar.symbol, zBar.period, i // ); // bool isRejected = isDone && barAnalyser.IsRejected( iBar, iDir, false, // Force Bar Type ... true // Force Fibo Pressure ... ); // // Following Liquidity ... bool isFLiq = isDone && isRejected && iDir == tb.GetDirection() && (isBullish ? iBar.low < tb.trigger.lower : iBar.high > tb.trigger.upper); if (isFLiq && _forceHasFLiquidity && !tb.fLiquidity.IsValid()) { // FillLiquidity( iBar, iDir, tb.fLiquidity, tb.trigger.to // ); } // // Reversal Liquidity ... bool isRLiq = isDone && isRejected && Opposit(iDir) == tb.GetDirection() && (isBullish ? iBar.low > tb.trigger.upper : iBar.high < tb.trigger.lower); if (isRLiq && _forceHasRLiquidity && !tb.rLiquidity.IsValid()) { // FillLiquidity( iBar, iDir, tb.rLiquidity, tb.trigger.to // ); } // // Checking Conditions ... isDone = (!_forceHasFLiquidity ? true : tb.fLiquidity.IsValid()) && (!_forceHasRLiquidity ? true : tb.rLiquidity.IsValid()); if (isDone) { // iBar.Clean(); break; } // iBar.Clean(); } // // Checking Conditions ... has = (!_forceHasFLiquidity ? true : tb.fLiquidity.IsValid()) && (!_forceHasRLiquidity ? true : tb.rLiquidity.IsValid()); } // // Validations ... // // Validating Gap Sequence means // Gap Bars must Follow each Other ... if (has && _validateGapSequence) { // XOHCL iPBar; toIDX = tb.fvg.ToIndex(); fromIDX = tb.fvg.FromIndex(); // for (int i = toIDX; i < fromIDX - 1; i++) { // // Initialize iBar ... has = iBar.Init( zBar.symbol, zBar.period, i // ); has = has && iBar.GetPreviousBar(iPBar); has = has && (isBullish ? iBar.low > iPBar.low : iBar.high < iPBar.high); if (!has) { break; } } // iBar.Clean(); iPBar.Clean(); } // // Validate Block Edge Breakout ... if (has && _validateBlockEdgeBreakout) { // has = tb.fvg.ToBar(iBar); has = has && (isBullish ? (iBar.GetDown() < tb.ob.upper && iBar.GetUp() > tb.ob.upper) : (iBar.GetDown() < tb.ob.lower && iBar.GetUp() > tb.ob.lower)); // iBar.Clean(); } // // Filters ... // // PV ... if (has && _filterBasedOnPV) { // double iPeak = _peakBuffer[barIndex]; double iPPeak = _peakBuffer[barIndex + 1]; double iP2Peak = _peakBuffer[barIndex + 2]; // double iPeakGolden = _peakGoldenBuffer[barIndex]; double iPPeakGolden = _peakGoldenBuffer[barIndex + 1]; double iP2PeakGolden = _peakGoldenBuffer[barIndex + 2]; // double iVale = _valeBuffer[barIndex]; double iPVale = _valeBuffer[barIndex + 1]; double iP2Vale = _valeBuffer[barIndex + 2]; // double iValeGolden = _valeGoldenBuffer[barIndex]; double iPValeGolden = _valeGoldenBuffer[barIndex + 1]; double iP2ValeGolden = _valeGoldenBuffer[barIndex + 2]; // // TODO: Fix this ... has = has && (isBullish ? (tb.trigger.lower <= iVale && tb.trigger.upper < iPeak // || tb.trigger.lower <= iValeGolden ) : (tb.trigger.upper >= iPeak && tb.trigger.lower > iVale // || tb.trigger.upper >= iPeakGolden )); } // // SAR ... if (has && _filterBasedOnSar) { // double iSarState = _sarStateBuffer[barIndex]; double iPSarState = _sarStateBuffer[barIndex + 1]; double iP2SarState = _sarStateBuffer[barIndex + 2]; // bool isSarBullish = iSarState > 0; bool isPSarBullish = iPSarState > 0; bool isP2SarBullish = iP2SarState > 0; // bool isSarBearish = iSarState < 0; bool isPSarBearish = iPSarState < 0; bool isP2SarBearish = iP2SarState < 0; // bool isSarSwitchedToBullish = isSarBullish && !isPSarBullish; // bool isSarSwitchedToBearish = isSarBearish && !isPSarBearish; // bool isSarPSwitchedToBullish = isPSarBullish && !isP2SarBullish; // bool isSarPSwitchedToBearish = isPSarBearish && !isP2SarBearish; // has = has && (isBullish ? (isSarSwitchedToBullish || isSarPSwitchedToBullish) : (isSarSwitchedToBearish || isSarPSwitchedToBearish)); } // // RSI ... if (has && _filterBasedOnRSI) { // double rsiTrend = (_rsiOBLevel + _rsiOSLevel) / 2; // double iRSI = _rsiBuffer[barIndex]; double iPRSI = _rsiBuffer[barIndex + 1]; double iP2RSI = _rsiBuffer[barIndex + 2]; // bool isRSICrossedOverOS = iRSI > _rsiOSLevel && iPRSI <= _rsiOSLevel; // bool isRSICrossedUnderOB = iRSI < _rsiOBLevel && iPRSI >= _rsiOBLevel; // bool isPRSICrossedOverOS = iPRSI > _rsiOSLevel && iP2RSI <= _rsiOSLevel; // bool isPRSICrossedUnderOB = iPRSI < _rsiOBLevel && iP2RSI >= _rsiOBLevel; // has = has && (isBullish ? (isRSICrossedOverOS || isPRSICrossedOverOS) : (isRSICrossedUnderOB || isPRSICrossedUnderOB)); } // // ADX ... if (has && _filterBasedOnADX) { // // ADX ... double iADX = _adxBuffer[barIndex]; double iPADX = _adxBuffer[barIndex + 1]; double iP2ADX = _adxBuffer[barIndex + 2]; // // ADX +DI ... double iADXP = _adxpBuffer[barIndex]; double iPADXP = _adxpBuffer[barIndex + 1]; double iP2ADXP = _adxpBuffer[barIndex + 2]; // // ADX -DI ... double iADXN = _adxnBuffer[barIndex]; double iPADXN = _adxnBuffer[barIndex + 1]; double iP2ADXN = _adxnBuffer[barIndex + 2]; // // Preparing Conditions ... // bool isADXBullish = iADX > _adxThreshold; bool isADXBearish = iADX < _adxThreshold; // bool isPADXBullish = iPADX > _adxThreshold; bool isPADXBearish = iPADX < _adxThreshold; // bool isP2ADXBullish = iP2ADX > _adxThreshold; bool isP2ADXBearish = iP2ADX < _adxThreshold; // bool isADXSwitchedToBullish = isADXBullish && !isPADXBullish; // bool isADXSwitchedToBearish = isADXBearish && !isPADXBearish; // bool isPADXSwitchedToBullish = isPADXBullish && !isP2ADXBullish; // bool isPADXSwitchedToBearish = isPADXBearish && !isP2ADXBearish; // has = has && (isBullish ? (isADXSwitchedToBullish || isPADXSwitchedToBullish) : (isADXSwitchedToBearish || isPADXSwitchedToBearish)); } // // ATR ... if (has && _filterBasedOnATR) { // fromIDX = tb.FromIndex(); double iATRUpper = _atrUpperBuffer[fromIDX]; double iATRLower = _atrLowerBuffer[fromIDX]; // has = has && (isBullish ? tb.trigger.lower < iATRLower : tb.trigger.upper > iATRUpper); } // // TREND ... if (has && _filterBasedOnTrend) { // double iTrendState = _trendStateBuffer[barIndex]; double iPTrendState = _trendStateBuffer[barIndex + 1]; // bool isTrendBullish = iTrendState > 0; bool isPTrendBullish = iPTrendState > 0; // bool isTrendBearish = iTrendState < 0; bool isPTrendBearish = iPTrendState < 0; // double trends[]; int toIDX = tb.ToIndex(); int fromIDX = tb.FromIndex(); double iTrend = _trendBuffer[toIDX]; for (int i = toIDX; i <= fromIDX; i++) { // Add( _trendBuffer[i], trends // ); } double trendsMin = GetMin(trends); double trendsMax = GetMax(trends); double trendsAVG = GetAverage(trends); // bool isTrendUp = iTrend > trendsMin && iTrend >= trendsAVG; // bool isTrendDown = iTrend < trendsMax && iTrend <= trendsAVG; // bool isTrendSwitchedToBullish = isTrendUp && isTrendBullish && !isPTrendBullish; // bool isTrendSwitchedToBearish = isTrendDown && isTrendBearish && !isPTrendBearish; // has = has && (isBullish ? isTrendSwitchedToBullish : isTrendSwitchedToBearish); } // // DELTA ... if (has && _filterBasedOnDelta) { // double iDelta = _deltaBuffer[barIndex]; double iPDelta = _deltaBuffer[barIndex + 1]; // bool isDeltaUp = iDelta > iPDelta; bool isDeltaDown = iDelta < iPDelta; // double iDeltaSignal = _deltaSignalBuffer[barIndex]; double iPDeltaSignal = _deltaSignalBuffer[barIndex + 1]; // bool isDeltaSignalUp = iDeltaSignal > iPDeltaSignal; bool isDeltaSignalDown = iDeltaSignal < iPDeltaSignal; // bool isDeltaSwitchedToBullish = isDeltaUp && isDeltaSignalUp && iDelta > iDeltaSignal && iPDelta < iPDeltaSignal; // bool isDeltaSwitchedToBearish = isDeltaDown && isDeltaSignalDown && iDelta < iDeltaSignal && iPDelta > iPDeltaSignal; // has = has && (isBullish ? isDeltaSwitchedToBullish : isDeltaSwitchedToBearish); } // // VOLUME ... if (has && _filterBasedOnVolume) { // double iBullishVolumeSignal = _bullishVolumeSignalBuffer[barIndex]; double iPBullishVolumeSignal = _bullishVolumeSignalBuffer[barIndex + 1]; // bool isBullishVolumeSignalUp = iBullishVolumeSignal > iPBullishVolumeSignal; bool isBullishVolumeSignalDown = iBullishVolumeSignal < iPBullishVolumeSignal; // double iBearishVolumeSignal = _bearishVolumeSignalBuffer[barIndex]; double iPBearishVolumeSignal = _bearishVolumeSignalBuffer[barIndex + 1]; // bool isBearishVolumeSignalUp = iBearishVolumeSignal > iPBearishVolumeSignal; bool isBearishVolumeSignalDown = iBearishVolumeSignal < iPBearishVolumeSignal; // bool isVolumeSwitchdToBullish = isBullishVolumeSignalUp && !isBearishVolumeSignalUp && iBullishVolumeSignal > iBearishVolumeSignal && iPBullishVolumeSignal < iPBearishVolumeSignal; // bool isVolumeSwitchdToBearish = isBearishVolumeSignalUp && !isBullishVolumeSignalUp && iBearishVolumeSignal > iBullishVolumeSignal && iPBearishVolumeSignal < iPBullishVolumeSignal; // has = has && (isBullish ? isVolumeSwitchdToBullish : isVolumeSwitchdToBearish); } // // SIGNAL Bar ... if (has && _filterBasedOnSignalBar) { // double iSignalOpen = _sBarOpenSBuffer[barIndex]; double iPSignalOpen = _sBarOpenSBuffer[barIndex + 1]; // double iSignalClose = _sBarCloseBuffer[barIndex]; double iPSignalClose = _sBarCloseBuffer[barIndex + 1]; // bool isSignalBarBullish = iSignalOpen < iSignalClose; bool isPSignalBarBullish = iPSignalOpen < iPSignalClose; // bool isSignalBarBearish = iSignalOpen > iSignalClose; bool isPSignalBarBearish = iPSignalOpen > iPSignalClose; // bool isSignalBarSwitchedToBullish = isSignalBarBullish && !isPSignalBarBullish; // bool isSignalBarSwitchedToBearish = isSignalBarBearish && !isPSignalBarBearish; // has = has && (isBullish ? isSignalBarSwitchedToBullish : isSignalBarSwitchedToBearish); } // // HK SIGNAL Bar ... if (has && _filterBasedOnHKSignalBar) { // double iHKSignalOpen = _hkSBarOpenBuffer[barIndex]; double iPHKSignalOpen = _hkSBarOpenBuffer[barIndex + 1]; // double iHKSignalClose = _hkSBarCloseBuffer[barIndex]; double iPHKSignalClose = _hkSBarCloseBuffer[barIndex + 1]; // bool isHKSignalBarBullish = iHKSignalOpen < iHKSignalClose; bool isPHKSignalBarBullish = iPHKSignalOpen < iPHKSignalClose; // bool isHKSignalBarBearish = iHKSignalOpen > iHKSignalClose; bool isPHKSignalBarBearish = iPHKSignalOpen > iPHKSignalClose; // bool isHKSignalBarSwitchedToBullish = isHKSignalBarBullish && !isPHKSignalBarBullish; // bool isHKSignalBarSwitchedToBearish = isHKSignalBarBearish && !isPHKSignalBarBearish; // has = has && (isBullish ? isHKSignalBarSwitchedToBullish : isHKSignalBarSwitchedToBearish); } // // Valdating Directional Trending ... bool _filterBasedOnDirection = false; if (has && _filterBasedOnDirection) { // iBar.Clean(); fromIDX = tb.FromIndex(); int loopbackForValidating = 30; for (int i = fromIDX; i < fromIDX + loopbackForValidating; i++) { // // Initialize iBar ... iBar.Clean(); has = iBar.Init( symbol, period, i // ); // has = has && (isBullish ? iBar.high < tb.trigger.upper : iBar.low > tb.trigger.lower); if (!has) { break; } } // // Update Trigger Block ... if (has) { tb.trigger.from = iBar.time; } // iBar.Clean(); } // // Preparing Signal ... if (has) { // // CArrayObj *tbObjects = new CArrayObj(); // DrawTriggerBlock( // tb, // drawer, // tbObjects, // NULL // // ); // double targets[]; for (int i = 1; i <= _r2r; i++) { // Add( (double)i, targets // ); } // double iATR = 0; if (barIndex > 0 && barIndex < ArraySize(_atrBuffer)) { iATR = _atrBuffer[barIndex]; } double slAdditional = _slAtrMultiplier * iATR; // has = ToSignal( tb.trigger, tb.signal, targets, slAdditional // ); } // result = has; // return result; } // // Draw Specific Trigger Block ... bool DrawTriggerBlock( XTriggerBlock &trigger, XCPOIDrawer *drawer, CArrayObj &objects, datetime to = NULL, // bool _drawSignals = false, int rrZoneLength = 10, // Styles ... // // Trigger Block ... int tbWidth = 1, // Trigger Block Width color tbBullishColor = clrAqua, // Trigger Block Bullish Color color tbBearishColor = clrMagenta, // Trigger Block Bearish Color ENUM_LINE_STYLE tbStyle = STYLE_DASHDOTDOT, // Trigger Block Style // // OB ... int obWidth = 1, // OB Width color obBullishColor = clrLime, // OB Bullish Color color obBearishColor = clrRed, // OB Bearish Color ENUM_LINE_STYLE obStyle = STYLE_DOT, // OB Style // // FVG ... int fvgWidth = 2, // FVG Width color fvgBullishColor = clrLime, // FVG Bullish Color color fvgBearishColor = clrRed, // FVG Bearish Color ENUM_LINE_STYLE fvgStyle = STYLE_SOLID // FVG Style ) { // bool result = false; // // Validate Args ... result = trigger.IsValid() && drawer != NULL; if (!result) { return result; } // // Update To ... bool canUpdateTo = IsValid(to); if (canUpdateTo) { // trigger.trigger.to = to; trigger.rLiquidity.to = to; trigger.fLiquidity.to = to; } // bool isBullish = trigger.IsBullish(); // // Draw OB ... if (trigger.ob.IsValid()) { // XCBoxObject *iOBObj; result = drawer.DrawBox( trigger.ob, iOBObj // ); if (result) { // // Style Object ... // color iClr = isBullish ? obBullishColor : obBearishColor; // iOBObj.BoxColor(iClr); iOBObj.BoxWidth(obWidth); iOBObj.BoxStyle(obStyle); // // Store Object ... objects.Add(iOBObj); } ZeroMemory(iOBObj); // if (!result) { return result; } } // // Draw FVG ... if (trigger.fvg.IsValid()) { // XCBoxObject *iFVGObj; result = drawer.DrawBox( trigger.fvg, iFVGObj // ); if (result) { // // Style Object ... // color iClr = isBullish ? fvgBullishColor : fvgBearishColor; // iFVGObj.BoxColor(iClr); iFVGObj.BoxWidth(fvgWidth); iFVGObj.BoxStyle(fvgStyle); // // Store Object ... objects.Add(iFVGObj); } ZeroMemory(iFVGObj); // if (!result) { return result; } } // // Draw Trigger ... if (trigger.trigger.IsValid()) { // XCBoxObject *iTriggerObj; result = drawer.DrawBox( trigger.trigger, iTriggerObj // ); if (result) { // // Style Object ... // color iClr = isBullish ? tbBullishColor : tbBearishColor; // iTriggerObj.BoxColor(iClr); iTriggerObj.BoxWidth(tbWidth); iTriggerObj.BoxStyle(tbStyle); // // Store Object ... objects.Add(iTriggerObj); } ZeroMemory(iTriggerObj); // if (!result) { return result; } } // // Draw Liquidities ... // // Reversla Liquidity ... if (trigger.rLiquidity.IsValid()) { // XCBoxObject *iLiqObj; result = drawer.DrawBox( trigger.rLiquidity, iLiqObj // ); if (result) { objects.Add(iLiqObj); } ZeroMemory(iLiqObj); // if (!result) { return result; } } // // Following Liquidity ... if (trigger.fLiquidity.IsValid()) { // XCBoxObject *iLiqObj; result = drawer.DrawBox( trigger.fLiquidity, iLiqObj // ); if (result) { objects.Add(iLiqObj); } ZeroMemory(iLiqObj); // if (!result) { return result; } } // // Draw Swing Bar ... if (trigger.swingBar.IsValid()) { // color swingColor = trigger.fvg.IsBullish() ? clrAqua : clrMagenta; ENUM_X_PRICE swingPType = trigger.fvg.IsBullish() ? X_PRICE_LOW : X_PRICE_HIGH; // XCBarArrowObject *swingObj; result = drawer.CreateBarArrow( trigger.swingBar, swingObj, swingPType, 159, swingColor // ); if (result) { objects.Add(swingObj); } ZeroMemory(swingObj); // if (!result) { return result; } } // // Draw RR of Signal ... if (_drawSignals && trigger.signal.IsValid() && rrZoneLength > 0) { // XCRRObject *iRRObj; iRRObj = new XCRRObject(); result = iRRObj.Create( drawer.ChartIdentification(), drawer.SubWindowIdentification(), trigger.signal, rrZoneLength // ); if (result) { // int iWidth = 2; ENUM_LINE_STYLE iStyle = STYLE_SOLID; // iRRObj.TPWidth(iWidth); iRRObj.SLWidth(iWidth); iRRObj.EntryWidth(iWidth); iRRObj.TargetWidth(iWidth); // iRRObj.TPStyle(iStyle); iRRObj.SLStyle(iStyle); iRRObj.EntryStyle(iStyle); iRRObj.TargetStyle(iStyle); // iRRObj.TPColor(clrLime); iRRObj.SLColor(clrRed); iRRObj.EntryColor(clrYellow); iRRObj.TargetColor(clrLightBlue); // objects.Add(iRRObj); } ZeroMemory(iRRObj); // if (result) { return result; } } // return result; }