diff --git a/X121SMCEA/Classes/x-121.smc.chart.objects.class.mq5 b/Documents/BKP/x-121.smc.chart.objects.class.mq5 similarity index 100% rename from X121SMCEA/Classes/x-121.smc.chart.objects.class.mq5 rename to Documents/BKP/x-121.smc.chart.objects.class.mq5 diff --git a/Libraries/x-saherelm.x-poi.lib.mq5 b/Libraries/x-saherelm.x-poi.lib.mq5 index de427e6b..a258d7bd 100644 --- a/Libraries/x-saherelm.x-poi.lib.mq5 +++ b/Libraries/x-saherelm.x-poi.lib.mq5 @@ -2995,6 +2995,427 @@ struct XPOIState Clean(bearishFairValueGaps); } + /** + * Validate ... + * + * @return ( bool ) + */ + bool IsValid() + { + // + bool result = false; + + // + result = + IsSpecifiedValid(symbol) && + IsSpecifiedValid(period) && + IsSpecifiedValid(time); + + // + return result; + } + + /** + * Check State has Childs or not ... + * + * @return ( bool ) + */ + bool HasChild() + { + // + bool result = false; + + // + result = + // + IsValidSize(CountSwingHighs()) || + IsValidSize(CountSwingLows()) || + IsValidSize(CountBullishMomentumBars()) || + IsValidSize(CountBearishMomentumBars()) || + IsValidSize(CountBullishRejectionBars()) || + IsValidSize(CountBearishRejectionBars()) || + IsValidSize(CountSupportZones()) || + IsValidSize(CountResistanceZones()) || + IsValidSize(CountSupplyZones()) || + IsValidSize(CountDemandZones()) || + IsValidSize(CountBullishOrderBlocks()) || + IsValidSize(CountBearishOrderBlocks()) || + IsValidSize(CountBullishFairValueGaps()) || + IsValidSize(CountBearishFairValueGaps()) + // + ; + + // + return result; + } + + /** + * Fill Dest State by Current State's Data ... + * + * @param dest: XPOIState instance, reference to specified dest ... + * + */ + void Fill(XPOIState &dest) + { + // + dest.Clean(); + + // + if (!IsValid() || + !HasChild()) + { + return; + } + + // + dest.symbol = symbol; + dest.period = period; + dest.time = time; + + // + Copy( + swingHighs, + dest.swingHighs, + false // + ); + Copy( + swingLows, + dest.swingLows, + false // + ); + Copy( + bullishMomentumBars, + dest.bullishMomentumBars, + false // + ); + Copy( + bearishMomentumBars, + dest.bearishMomentumBars, + false // + ); + Copy( + bullishRejectionBars, + dest.bullishRejectionBars, + false // + ); + Copy( + bearishRejectionBars, + dest.bearishRejectionBars, + false // + ); + Copy( + supportZones, + dest.supportZones, + false // + ); + Copy( + resistanceZones, + dest.resistanceZones, + false // + ); + Copy( + supplyZones, + dest.supplyZones, + false // + ); + Copy( + demandZones, + dest.demandZones, + false // + ); + Copy( + bullishOrderBlocks, + dest.bullishOrderBlocks, + false // + ); + Copy( + bearishOrderBlocks, + dest.bearishOrderBlocks, + false // + ); + Copy( + bullishFairValueGaps, + dest.bullishFairValueGaps, + false // + ); + Copy( + bearishFairValueGaps, + dest.bearishFairValueGaps, + false // + ); + + // + } + + // + // Counters ... + + // + int CountSwingHighs() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(swingHighs); + + // + return result; + } + + // + int CountSwingLows() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(swingLows); + + // + return result; + } + + // + int CountBullishMomentumBars() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(bullishMomentumBars); + + // + return result; + } + + // + int CountBearishMomentumBars() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(bearishMomentumBars); + + // + return result; + } + + // + int CountBullishRejectionBars() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(bullishRejectionBars); + + // + return result; + } + + // + int CountBearishRejectionBars() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(bearishRejectionBars); + + // + return result; + } + + // + int CountSupportZones() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(supportZones); + + // + return result; + } + + // + int CountResistanceZones() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(resistanceZones); + + // + return result; + } + + // + int CountSupplyZones() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(supplyZones); + + // + return result; + } + + // + int CountDemandZones() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(demandZones); + + // + return result; + } + + // + int CountBullishOrderBlocks() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(bullishOrderBlocks); + + // + return result; + } + + // + int CountBearishOrderBlocks() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(bearishOrderBlocks); + + // + return result; + } + + // + int CountBullishFairValueGaps() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(bullishFairValueGaps); + + // + return result; + } + + // + int CountBearishFairValueGaps() + { + // + int result = 0; + + // + if (!IsValid()) + { + return result; + } + + // + result = ArraySize(bearishFairValueGaps); + + // + return result; + } + // }; diff --git a/X121SMCEA/Classes/x-121.smc.base.strategy.class.mq5 b/X121SMCEA/Classes/x-121.smc.base.strategy.class.mq5 index b5c3f309..3635eb92 100644 --- a/X121SMCEA/Classes/x-121.smc.base.strategy.class.mq5 +++ b/X121SMCEA/Classes/x-121.smc.base.strategy.class.mq5 @@ -979,6 +979,7 @@ class XCX121SMCBaseStrategy : public XCBaseAlert */ void DrawState( XPOIState &state, + bool forceUpdateTo = false, bool drawSwingHighs = true, bool drawSwingLows = true, bool drawSupportZones = true, @@ -997,6 +998,7 @@ class XCX121SMCBaseStrategy : public XCBaseAlert { // int count = 0; + datetime cTime = TimeCurrent(); // // Swings ... @@ -1073,6 +1075,9 @@ class XCX121SMCBaseStrategy : public XCBaseAlert { // XCSupportZone item = state.supportZones[i]; + if (forceUpdateTo) { + item.To(cTime); + } // XCSupportZoneObject *iObj; @@ -1101,6 +1106,9 @@ class XCX121SMCBaseStrategy : public XCBaseAlert { // XCResistanceZone item = state.resistanceZones[i]; + if (forceUpdateTo) { + item.To(cTime); + } // XCResistanceZoneObject *iObj; @@ -1132,6 +1140,9 @@ class XCX121SMCBaseStrategy : public XCBaseAlert { // XCSupplyZone item = state.supplyZones[i]; + if (forceUpdateTo) { + item.To(cTime); + } // XCSupplyZoneObject *iObj; @@ -1160,6 +1171,9 @@ class XCX121SMCBaseStrategy : public XCBaseAlert { // XCDemandZone item = state.demandZones[i]; + if (forceUpdateTo) { + item.To(cTime); + } // XCDemandZoneObject *iObj; @@ -1191,6 +1205,9 @@ class XCX121SMCBaseStrategy : public XCBaseAlert { // XCOrderBlock item = state.bullishOrderBlocks[i]; + if (forceUpdateTo) { + item.To(cTime); + } // XCBullishOrderBlockObject *iObj; @@ -1219,6 +1236,9 @@ class XCX121SMCBaseStrategy : public XCBaseAlert { // XCOrderBlock item = state.bearishOrderBlocks[i]; + if (forceUpdateTo) { + item.To(cTime); + } // XCBearishOrderBlockObject *iObj; @@ -1250,6 +1270,9 @@ class XCX121SMCBaseStrategy : public XCBaseAlert { // XCFVG item = state.bullishFairValueGaps[i]; + if (forceUpdateTo) { + item.To(cTime); + } // XCBullishFairValueGapObject *iObj; @@ -1278,6 +1301,9 @@ class XCX121SMCBaseStrategy : public XCBaseAlert { // XCFVG item = state.bearishFairValueGaps[i]; + if (forceUpdateTo) { + item.To(cTime); + } // XCBearishFairValueGapObject *iObj; @@ -1415,6 +1441,8 @@ class XCX121SMCBaseStrategy : public XCBaseAlert // Ticks Zone ... if (state.ticksZone != NULL) { + // + // TODO: Implement this ... } } diff --git a/X121SMCEA/Classes/x-121.smc.cobjects.class.mq5 b/X121SMCEA/Classes/x-121.smc.cobjects.class.mq5 index a524c83d..bc455b99 100644 --- a/X121SMCEA/Classes/x-121.smc.cobjects.class.mq5 +++ b/X121SMCEA/Classes/x-121.smc.cobjects.class.mq5 @@ -93,6 +93,25 @@ class XCXPVPivotObject : public XCBaseObject ObjName(name); } + // + string mTrendName = "MID_" + name; + double mid = pivot.CalculateMid(); + result = mTrend.Create( + chart_id, + mTrendName, + window, + pivot.from, + mid, + pivot.to, + mid // + ); + if (!result) + { + // + mRect.Delete(); + mRect.Detach(); + } + // return result; } @@ -115,6 +134,7 @@ class XCXPVPivotObject : public XCBaseObject // mRect.Width(value); + mTrend.Width(value); } /** @@ -124,7 +144,9 @@ class XCXPVPivotObject : public XCBaseObject */ void PivotColor(color value) { + // mRect.Color(value); + mTrend.Color(value); } /** @@ -134,7 +156,9 @@ class XCXPVPivotObject : public XCBaseObject */ void PivotStyle(ENUM_LINE_STYLE value) { + // mRect.Style(value); + mTrend.Style(value); } /** @@ -167,4 +191,5 @@ class XCXPVPivotObject : public XCBaseObject // // Props ... CChartObjectRectangle mRect; + CChartObjectTrend mTrend; }; \ No newline at end of file diff --git a/X121SMCEA/Libraries/x-121.smc.lib.mq5 b/X121SMCEA/Libraries/x-121.smc.lib.mq5 index 35be9db4..63c702f0 100644 --- a/X121SMCEA/Libraries/x-121.smc.lib.mq5 +++ b/X121SMCEA/Libraries/x-121.smc.lib.mq5 @@ -61,6 +61,9 @@ struct XPVPivot // ENUM_XPV_PIVOTS type; + // + XPOIState state; + // XPVPivot() { @@ -90,6 +93,9 @@ struct XPVPivot // type = XPV_NONE; + + // + state.Clean(); } /** @@ -930,4 +936,544 @@ bool DetectPivotDirection( return result; } +/** + * Detect all POIs which inside a Pivot ... + * + * @param pivot: XPVPivot instance, Specified Pivot ... + * @param source: XPOIState instance, Reference to Source State ... + * @param state: XPOIState instance, Reference to Detected Pivots ... + * @param lookupSwingHighs: Boolean ... + * @param lookupSwingLows: Boolean ... + * @param lookupSupportZones: Boolean ... + * @param lookupResistanceZones: Boolean ... + * @param lookupSupplyZones: Boolean ... + * @param lookupDemandZones: Boolean ... + * @param lookupBullishOrderBlocks: Boolean ... + * @param lookupBearishOrderBlocks: Boolean ... + * @param lookupBullishFairValueGaps: Boolean ... + * @param lookupBearishFairValueGaps: Boolean ... + * @param lookupBullishRejectionBars: Boolean ... + * @param lookupBearishRejectionBars: Boolean ... + * @param lookupBullishMomentumBars: Boolean ... + * @param lookupBearishMomentumBars: Boolean ... + */ +void DetectPivotPOIs( + XPVPivot &pivot, + XPOIState &source, + XPOIState &state, + bool lookupSwingHighs = true, + bool lookupSwingLows = true, + bool lookupSupportZones = true, + bool lookupResistanceZones = true, + bool lookupSupplyZones = true, + bool lookupDemandZones = true, + bool lookupBullishOrderBlocks = true, + bool lookupBearishOrderBlocks = true, + bool lookupBullishFairValueGaps = true, + bool lookupBearishFairValueGaps = true, + bool lookupBullishRejectionBars = true, + bool lookupBearishRejectionBars = true, + bool lookupBullishMomentumBars = true, + bool lookupBearishMomentumBars = true // +) +{ + // + state.Clean(); + + // + if (!pivot.IsValid()) + { + return; + } + + // + int count = 0; + + // + state.symbol = pivot.symbol; + state.period = pivot.period; + state.time = TimeCurrent(); + + // + // Swings ... + + // + // Swing High ... + if (lookupSwingHighs) + { + // + count = ArraySize(source.swingHighs); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCSwing *iSwing = source.swingHighs[i]; + + // + XOHCL iBar; + bool isFilled = iSwing.FillBar(iBar); + if (!isFilled) + { + continue; + } + + // + bool isInside = iBar.high <= pivot.upper; + if (isInside) + { + // + Add( + iSwing, + state.swingHighs // + ); + } + } + } + } + + // + // Swing Low ... + if (lookupSwingLows) + { + // + count = ArraySize(source.swingLows); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCSwing *iSwing = source.swingLows[i]; + + // + XOHCL iBar; + bool isFilled = iSwing.FillBar(iBar); + if (!isFilled) + { + continue; + } + + // + bool isInside = iBar.low >= pivot.lower; + if (isInside) + { + // + Add( + iSwing, + state.swingLows // + ); + } + } + } + } + + // + // Support and Resistance Zones ... + + // + // Support Zones ... + if (lookupSupportZones) + { + // + count = ArraySize(source.supportZones); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCSupportZone *iZone = source.supportZones[i]; + + // + bool isInside = + iZone.Upper() <= pivot.upper && + iZone.Lower() >= pivot.lower; + if (isInside) + { + // + Add( + iZone, + state.supportZones // + ); + } + } + } + } + + // + // Resistance Zones ... + if (lookupResistanceZones) + { + // + count = ArraySize(source.resistanceZones); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCResistanceZone *iZone = source.resistanceZones[i]; + + // + bool isInside = + iZone.Upper() <= pivot.upper && + iZone.Lower() >= pivot.lower; + if (isInside) + { + // + Add( + iZone, + state.resistanceZones // + ); + } + } + } + } + + // + // Supply and Demand Zones ... + + // + // Supply Zones ... + if (lookupSupplyZones) + { + // + count = ArraySize(source.supplyZones); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCSupplyZone *iZone = source.supplyZones[i]; + + // + bool isInside = + iZone.Upper() <= pivot.upper && + iZone.Lower() >= pivot.lower; + if (isInside) + { + // + Add( + iZone, + state.supplyZones // + ); + } + } + } + } + + // + // Demand Zones ... + if (lookupDemandZones) + { + // + count = ArraySize(source.demandZones); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCDemandZone *iZone = source.demandZones[i]; + + // + bool isInside = + iZone.Upper() <= pivot.upper && + iZone.Lower() >= pivot.lower; + if (isInside) + { + // + Add( + iZone, + state.demandZones // + ); + } + } + } + } + + // + // Order Blocks ... + + // + // Bullish Order Blocks ... + if (lookupBullishOrderBlocks) + { + // + count = ArraySize(source.bullishOrderBlocks); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCOrderBlock *iZone = source.bullishOrderBlocks[i]; + + // + bool isInside = + iZone.Upper() <= pivot.upper && + iZone.Lower() >= pivot.lower; + if (isInside) + { + // + Add( + iZone, + state.bullishOrderBlocks // + ); + } + } + } + } + + // + // Bearish Order Blocks ... + if (lookupBearishOrderBlocks) + { + // + count = ArraySize(source.bearishOrderBlocks); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCOrderBlock *iZone = source.bearishOrderBlocks[i]; + + // + bool isInside = + iZone.Upper() <= pivot.upper && + iZone.Lower() >= pivot.lower; + if (isInside) + { + // + Add( + iZone, + state.bearishOrderBlocks // + ); + } + } + } + } + + // + // Fair Value Gaps ... + + // + // Bullish Fair Value Gaps ... + if (lookupBullishFairValueGaps) + { + // + count = ArraySize(source.bullishFairValueGaps); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCFVG *iZone = source.bullishFairValueGaps[i]; + + // + bool isInside = + iZone.Upper() <= pivot.upper && + iZone.Lower() >= pivot.lower; + if (isInside) + { + // + Add( + iZone, + state.bullishFairValueGaps // + ); + } + } + } + } + + // + // Bearish Fair Value Gaps ... + if (lookupBearishFairValueGaps) + { + // + count = ArraySize(source.bearishFairValueGaps); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCFVG *iZone = source.bearishFairValueGaps[i]; + + // + bool isInside = + iZone.Upper() <= pivot.upper && + iZone.Lower() >= pivot.lower; + if (isInside) + { + // + Add( + iZone, + state.bearishFairValueGaps // + ); + } + } + } + } + + // + // Rejection Bars ... + + // + // Bullish Rejection Bars ... + if (lookupBullishRejectionBars) + { + // + count = ArraySize(source.bullishRejectionBars); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCRejectionBar *iRejection = source.bullishRejectionBars[i]; + + // + XOHCL iBar; + bool isFilled = iRejection.FillBar(iBar); + if (!isFilled) + { + continue; + } + + // + bool isInside = iBar.low <= pivot.upper && + iBar.low >= pivot.lower; + if (isInside) + { + // + Add( + iRejection, + state.bullishRejectionBars // + ); + } + } + } + } + + // + // Bearish Rejection Bars ... + if (lookupBearishRejectionBars) + { + // + count = ArraySize(source.bearishRejectionBars); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCRejectionBar *iRejection = source.bearishRejectionBars[i]; + + // + XOHCL iBar; + bool isFilled = iRejection.FillBar(iBar); + if (!isFilled) + { + continue; + } + + // + bool isInside = iBar.high <= pivot.upper && + iBar.high >= pivot.lower; + if (isInside) + { + // + Add( + iRejection, + state.bearishRejectionBars // + ); + } + } + } + } + + // + // Momentum Bars ... + + // + // Bullish Momentum Bars ... + if (lookupBullishMomentumBars) + { + // + count = ArraySize(source.bullishMomentumBars); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCMomentumBar *iMomentum = source.bullishMomentumBars[i]; + + // + XOHCL iBar; + bool isFilled = iMomentum.FillBar(iBar); + if (!isFilled) + { + continue; + } + + // + bool isInside = iBar.low <= pivot.upper && + iBar.low >= pivot.lower; + if (isInside) + { + // + Add( + iMomentum, + state.bullishMomentumBars // + ); + } + } + } + } + + // + // Bearish Momenum Bars ... + if (lookupBearishMomentumBars) + { + // + count = ArraySize(source.bearishMomentumBars); + if (IsValidSize(count)) + { + // + for (int i = 0; i < count; i++) + { + // + XCMomentumBar *iMomentum = source.bearishMomentumBars[i]; + + // + XOHCL iBar; + bool isFilled = iMomentum.FillBar(iBar); + if (!isFilled) + { + continue; + } + + // + bool isInside = iBar.high <= pivot.upper && + iBar.high >= pivot.lower; + if (isInside) + { + // + Add( + iMomentum, + state.bearishMomentumBars // + ); + } + } + } + } +} + // \ No newline at end of file diff --git a/X121SMCEA/Strategy/x-121.smc.test.strategy.class.mq5 b/X121SMCEA/Strategy/x-121.smc.test.strategy.class.mq5 index 5289141b..dee80b76 100644 --- a/X121SMCEA/Strategy/x-121.smc.test.strategy.class.mq5 +++ b/X121SMCEA/Strategy/x-121.smc.test.strategy.class.mq5 @@ -182,6 +182,9 @@ class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy return result; } + // + RedrawOrderFlow(); + // XPVPivot lastPivot; result = GetLastItem( @@ -192,11 +195,6 @@ class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy { return result; } - XPOIState pivotState; - DetectPivotPOIs( - lastPivot, - pivotState // - ); // // Prepare Areas ... @@ -244,16 +242,32 @@ class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy if (isCHOCHHappens) { // - DrawStateSwings(_5MState); + // When Chouch Happens we Have to Destry Order Flow and + // Clean another ... + + // Print("CHOCH ..."); + + // + result = false; + ResetOrderFlow(); + return result; } // if (isBOSHappens) { // - DrawStateSwings(_5MState); + // When Chouch Happens we Have to Destry Order Flow and + // Clean another ... + + // Print("BOS ..."); + + // + result = false; + ResetOrderFlow(); + return result; } // @@ -486,52 +500,6 @@ class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy mOrderFlowDir // ); - // - int orderFlowCount = ArraySize(mOrderFlow); - if (IsValidSize(orderFlowCount)) - { - // - for (int i = 0; i < orderFlowCount; i++) - { - // - XPVPivot iPivot = mOrderFlow[i]; - - // - XCXPVPivotObject *iObj; - iObj = new XCXPVPivotObject(); - bool isCreated = iObj.Create( - mPOIDrawer.ChartIdentification(), - mPOIDrawer.SubWindowIdentification(), - iPivot // - ); - if (isCreated) - { - // - if (iPivot.IsPeak()) - { - // - iObj.PivotWidth(1); - iObj.PivotFill(false); - iObj.PivotColor(clrAqua); - iObj.PivotStyle(STYLE_SOLID); - } - - // - if (iPivot.IsVale()) - { - // - iObj.PivotWidth(1); - iObj.PivotFill(false); - iObj.PivotStyle(STYLE_SOLID); - iObj.PivotColor(clrMagenta); - } - - // - AddObjectIfNotExists(iObj); - } - } - } - // result = IsValidSize(ArraySize(mOrderFlow)); if (!result) @@ -844,301 +812,419 @@ class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy return result; } + // + // Find State Inside Pivots and Attached Them to Pivot ... + int orderFlowCount = ArraySize(mOrderFlow); + if (IsValidSize(orderFlowCount)) + { + // + bool lookupSwingHighs = true; + bool lookupSwingLows = true; + bool lookupSupportZones = true; + bool lookupResistanceZones = true; + bool lookupSupplyZones = true; + bool lookupDemandZones = true; + bool lookupBullishOrderBlocks = true; + bool lookupBearishOrderBlocks = true; + bool lookupBullishFairValueGaps = true; + bool lookupBearishFairValueGaps = true; + bool lookupBullishRejectionBars = true; + bool lookupBearishRejectionBars = true; + bool lookupBullishMomentumBars = true; + bool lookupBearishMomentumBars = true; + + // + // Loop Through Order Flow ... + for (int i = 0; i < orderFlowCount; i++) + { + // + XPVPivot iPivot = mOrderFlow[i]; + + // + // D1 ... + XPOIState d1; + if (_1DState.HasChild()) + { + // + DetectPivotPOIs( + iPivot, + _1DState, + d1, + lookupSwingHighs, + lookupSwingLows, + lookupSupportZones, + lookupResistanceZones, + lookupSupplyZones, + lookupDemandZones, + lookupBullishOrderBlocks, + lookupBearishOrderBlocks, + lookupBullishFairValueGaps, + lookupBearishFairValueGaps, + lookupBullishRejectionBars, + lookupBearishRejectionBars, + lookupBullishMomentumBars, + lookupBearishMomentumBars // + ); + + // + if (d1.HasChild()) + { + d1.Fill(mOrderFlow[i].state); + } + } + + // + // H4 ... + XPOIState h4; + if (_4HState.HasChild()) + { + // + DetectPivotPOIs( + iPivot, + _4HState, + h4, + lookupSwingHighs, + lookupSwingLows, + lookupSupportZones, + lookupResistanceZones, + lookupSupplyZones, + lookupDemandZones, + lookupBullishOrderBlocks, + lookupBearishOrderBlocks, + lookupBullishFairValueGaps, + lookupBearishFairValueGaps, + lookupBullishRejectionBars, + lookupBearishRejectionBars, + lookupBullishMomentumBars, + lookupBearishMomentumBars // + ); + + // + if (h4.HasChild()) + { + h4.Fill(mOrderFlow[i].state); + } + } + + // + // H2 ... + XPOIState h2; + if (_2HState.HasChild()) + { + // + DetectPivotPOIs( + iPivot, + _2HState, + h2, + lookupSwingHighs, + lookupSwingLows, + lookupSupportZones, + lookupResistanceZones, + lookupSupplyZones, + lookupDemandZones, + lookupBullishOrderBlocks, + lookupBearishOrderBlocks, + lookupBullishFairValueGaps, + lookupBearishFairValueGaps, + lookupBullishRejectionBars, + lookupBearishRejectionBars, + lookupBullishMomentumBars, + lookupBearishMomentumBars // + ); + + // + if (h2.HasChild()) + { + h2.Fill(mOrderFlow[i].state); + } + } + + // + // H1 ... + XPOIState h1; + if (_1HState.HasChild()) + { + // + DetectPivotPOIs( + iPivot, + _1HState, + h1, + lookupSwingHighs, + lookupSwingLows, + lookupSupportZones, + lookupResistanceZones, + lookupSupplyZones, + lookupDemandZones, + lookupBullishOrderBlocks, + lookupBearishOrderBlocks, + lookupBullishFairValueGaps, + lookupBearishFairValueGaps, + lookupBullishRejectionBars, + lookupBearishRejectionBars, + lookupBullishMomentumBars, + lookupBearishMomentumBars // + ); + + // + if (h1.HasChild()) + { + h1.Fill(mOrderFlow[i].state); + } + } + + // + // M15 ... + XPOIState m15; + if (_15MState.HasChild()) + { + // + DetectPivotPOIs( + iPivot, + _15MState, + m15, + lookupSwingHighs, + lookupSwingLows, + lookupSupportZones, + lookupResistanceZones, + lookupSupplyZones, + lookupDemandZones, + lookupBullishOrderBlocks, + lookupBearishOrderBlocks, + lookupBullishFairValueGaps, + lookupBearishFairValueGaps, + lookupBullishRejectionBars, + lookupBearishRejectionBars, + lookupBullishMomentumBars, + lookupBearishMomentumBars // + ); + + // + if (m15.HasChild()) + { + m15.Fill(mOrderFlow[i].state); + } + } + + // + // M5 ... + XPOIState m5; + if (_5MState.HasChild()) + { + // + DetectPivotPOIs( + iPivot, + _5MState, + m5, + lookupSwingHighs, + lookupSwingLows, + lookupSupportZones, + lookupResistanceZones, + lookupSupplyZones, + lookupDemandZones, + lookupBullishOrderBlocks, + lookupBearishOrderBlocks, + lookupBullishFairValueGaps, + lookupBearishFairValueGaps, + lookupBullishRejectionBars, + lookupBearishRejectionBars, + lookupBullishMomentumBars, + lookupBearishMomentumBars // + ); + + // + if (m5.HasChild()) + { + m5.Fill(mOrderFlow[i].state); + } + } + + // + // M1 ... + XPOIState m1; + if (_1MState.HasChild()) + { + // + DetectPivotPOIs( + iPivot, + _1MState, + m1, + lookupSwingHighs, + lookupSwingLows, + lookupSupportZones, + lookupResistanceZones, + lookupSupplyZones, + lookupDemandZones, + lookupBullishOrderBlocks, + lookupBearishOrderBlocks, + lookupBullishFairValueGaps, + lookupBearishFairValueGaps, + lookupBullishRejectionBars, + lookupBearishRejectionBars, + lookupBullishMomentumBars, + lookupBearishMomentumBars // + ); + + // + if (m1.HasChild()) + { + m1.Fill(mOrderFlow[i].state); + } + } + } + } + // return result; } - void DetectPivotPOIs( - XPVPivot &pivot, - XPOIState &state, - bool lookupSwingHighs = true, - bool lookupSwingLows = true, - bool lookupSupportZones = true, - bool lookupResistanceZones = true, - bool lookupSupplyZones = true, - bool lookupDemandZones = true, - bool lookupBullishOrderBlocks = true, - bool lookupBearishOrderBlocks = true, - bool lookupBullishFairValueGaps = true, - bool lookupBearishFairValueGaps = true, - bool lookupBullishRejectionBars = true, - bool lookupBearishRejectionBars = true, - bool lookupBullishMomentumBars = true, - bool lookupBearishMomentumBars = true // + /** + * Validate Order Flow ... + * + * @return ( bool ) + */ + bool HasValidOrderFlow() + { + // + bool result = false; + + // + int orderFlowCount = ArraySize(mOrderFlow); + result = + IsValidSize(orderFlowCount) && + mOrderFlowDir != X_DIRECTION_ALL && + mOrderFlowDir != X_DIRECTION_NONE; + + // + return result; + } + + /** + * Reset Order Flow ... + */ + void ResetOrderFlow() + { + // + Clean(mOrderFlow); + mOrderFlowDir = X_DIRECTION_NONE; + + // + ClearDraws(); + } + + /** + * Draw Order Flow ... + */ + void RedrawOrderFlow( + bool forceClearDraws = true, + bool drawOrderFlow = true, + bool drawOrderFlowState = true, + bool drawOnlyLastOrderFlow = false, + bool drawOnlyLastOrderFlowState = true // ) { // - state.Clean(); + if (forceClearDraws) + { + ClearDraws(); + } // - if (!pivot.IsValid()) + if (!drawOrderFlow || + !HasValidOrderFlow()) { return; } // - int count = 0; - - // - // Swings ... - - // - // Swing High ... - if (lookupSwingHighs) + int orderFlowCount = ArraySize(mOrderFlow); + for (int i = 0; i < orderFlowCount; i++) { // - count = ArraySize(state.swingHighs); - if (IsValidSize(count)) + bool isLast = i == orderFlowCount - 1; + bool canDraw = + !drawOnlyLastOrderFlow || + (isLast && + drawOnlyLastOrderFlow); + if (!canDraw) + { + continue; + } + + // + XPVPivot iPivot = mOrderFlow[i]; + + // + XCXPVPivotObject *iObj; + iObj = new XCXPVPivotObject(); + bool isCreated = iObj.Create( + mPOIDrawer.ChartIdentification(), + mPOIDrawer.SubWindowIdentification(), + iPivot // + ); + if (isCreated) { // - for (int i = 0; i < count; i++) + bool canDrawState = + drawOrderFlowState && + (!drawOnlyLastOrderFlowState || + (isLast && + drawOnlyLastOrderFlowState)); + if (canDrawState) + { + CustomStateDrawing(iPivot.state); + } + + // + if (iPivot.IsPeak()) { // - XCSwing iSwing = state.swingHighs[i]; + iObj.PivotWidth(1); + iObj.PivotFill(false); + iObj.PivotColor(clrAqua); + iObj.PivotStyle(STYLE_SOLID); + } + // + if (iPivot.IsVale()) + { // - + iObj.PivotWidth(1); + iObj.PivotFill(false); + iObj.PivotStyle(STYLE_SOLID); + iObj.PivotColor(clrMagenta); } - } - } - // - // Swing Low ... - if (lookupSwingLows) - { - // - count = ArraySize(state.swingLows); - if (IsValidSize(count)) - { // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Support and Resistance Zones ... - - // - // Support Zones ... - if (lookupSupportZones) - { - // - count = ArraySize(state.supportZones); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Resistance Zones ... - if (lookupResistanceZones) - { - // - count = ArraySize(state.resistanceZones); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Supply and Demand Zones ... - - // - // Supply Zones ... - if (lookupSupplyZones) - { - // - count = ArraySize(state.supplyZones); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Demand Zones ... - if (lookupDemandZones) - { - // - count = ArraySize(state.demandZones); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Order Blocks ... - - // - // Bullish Order Blocks ... - if (lookupBullishOrderBlocks) - { - // - count = ArraySize(state.bullishOrderBlocks); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Bearish Order Blocks ... - if (lookupBearishOrderBlocks) - { - // - count = ArraySize(state.bearishOrderBlocks); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Fair Value Gaps ... - - // - // Bullish Fair Value Gaps ... - if (lookupBullishFairValueGaps) - { - // - count = ArraySize(state.bullishFairValueGaps); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Bearish Fair Value Gaps ... - if (lookupBearishFairValueGaps) - { - // - count = ArraySize(state.bearishFairValueGaps); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Rejection Bars ... - - // - // Bullish Rejection Bars ... - if (lookupBullishRejectionBars) - { - // - count = ArraySize(state.bullishRejectionBars); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Bearish Rejection Bars ... - if (lookupBearishRejectionBars) - { - // - count = ArraySize(state.bearishRejectionBars); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Momentum Bars ... - - // - // Bullish Momentum Bars ... - if (lookupBullishMomentumBars) - { - // - count = ArraySize(state.bullishMomentumBars); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } - } - } - - // - // Bearish Momenum Bars ... - if (lookupBearishMomentumBars) - { - // - count = ArraySize(state.bearishMomentumBars); - if (IsValidSize(count)) - { - // - for (int i = 0; i < count; i++) - { - } + AddObjectIfNotExists(iObj); } } } /** - * This function fulfills the will of the developer - * @param state: Argument 1 + * Custom Drawing State ... + * + * @param state: XPOIState instance reference, Specified Which state to Draw ... */ - void DrawStateSwings(XPOIState &state) + void CustomStateDrawing(XPOIState &state) { // DrawState( state, // State ... - true, // Draw SwingHighs .. - true, // Draw SwingLows .. + true, // Update To of all Drawings Till now ... + false, // Draw SwingHighs .. + false, // Draw SwingLows .. false, // Draw SupportZones .. false, // Draw ResistanceZones .. false, // Draw SupplyZones .. false, // Draw DemandZones .. true, // Draw BullishOrderBlocks .. true, // Draw BearishOrderBlocks .. - true, // Draw BullishFairValueGaps .. - true, // Draw BearishFairValueGaps .. - true, // Draw BullishRejectionBars .. - true, // Draw BearishRejectionBars .. - true, // Draw BullishMomentumBars .. - true // Draw BearishMomentumBars .. + false, // Draw BullishFairValueGaps .. + false, // Draw BearishFairValueGaps .. + false, // Draw BullishRejectionBars .. + false, // Draw BearishRejectionBars .. + false, // Draw BullishMomentumBars .. + false // Draw BearishMomentumBars .. ); } @@ -1237,9 +1323,9 @@ class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy x3vwapInputs.Default(); // - x3vwapInputs.showFast = false; - x3vwapInputs.showMid = false; - x3vwapInputs.showSlow = false; + x3vwapInputs.showFast = true; + x3vwapInputs.showMid = true; + x3vwapInputs.showSlow = true; // x3vwapHelper = new XCX3VWAPHelper();