/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Indicator // ------------------------------------------------- // Name: X121 XPOI // Description: XPOI ... // // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... #property copyright "Copyright 2023, SaherElm IT Center" #property link "https://saherelm.ir" #property version "1.00" #property description "SaherElm X121 XPOI Indicator" #property strict // // Definitions ... // #define ShortName "X121 XPOI" // // Includes Common Library ... #include "../Classes/x-saherelm.x-poi.class.mq5" #include "../Libraries/x-saherelm.common.lib.mq5" #include "../Libraries/x-saherelm.draw.lib.mq5" // // Inputs ... // // Market ... input group "Market"; input int maxNumberOfPOIs = 50; // Max Number Of Holding POI(s) input int maxNumberOfRequiredPOIs = 50; // Max Number of Required POI(s) input int swingRange = 7; // Swing Detection Range input int orderBlocksSameBars = 3; // Order Block Same Bars input int ticksRangeZoneLevel = 10; // Number of Ticks Zone's Levels input int ticksRangeZoneRange = 144; // Lenght of Tick Zones Calculation input int fairValueGapsSameBars = 3; // Fair Value Gaps Same Bars input int momentumBarExtendRange = 2; // Momentum Bars Extends Range input int supplyAndDemandRange = 144; // Supply and Demand Range input int rejectionBarExtendRange = 2; // Rejection Bars Extends Range input int supportAndResistanceRange = 7; // Support and Resistance Range input double momentumBarBodyPercent = 70; // Momentum Bars Body Range input double rejectionBarShadowPercent = 70; // Rejection Bars Body Range // // Presentation ... input group "Presentation"; // input int startCalculationForLastBars = 2000; // Calculate Last n Bars // input int swingLowsArrowCode = 159; // Swing Lows Arrow Code input int swingHighsArrowCode = 159; // Swing Highs Arrow Code input int bullishMomentumBarsArrowCode = 233; // Bullish Momentum Bars Arrow Code input int bearishMomentumBarsArrowCode = 234; // Bearish Momentum Bars Arrow Code input int bullishRejectionBarsArrowCode = 241; // Bullish Rejection Bars Arrow Code input int bearishRejectionBarsArrowCode = 242; // Bearish Rejection Bars Arrow Code // input color bullishColor = clrAqua; // Bullish Color input color bearishColor = clrMagenta; // Bearish Color // input ENUM_LINE_STYLE orderBlockStyle = STYLE_SOLID; // Order Block Style input ENUM_LINE_STYLE fairValueGapStyle = STYLE_DASH; // Fair Value Gap Style input ENUM_LINE_STYLE supResStyle = STYLE_DASHDOT; // Support and Resistance Style input ENUM_LINE_STYLE supDemStyle = STYLE_DASHDOTDOT; // Supply and Demand Style // input bool drawSwingLows = false; // Draw Swing Lows input bool drawSwingHighs = false; // Draw Swing Highs input bool drawSupplyZones = false; // Draw Supply Zones input bool drawDemandZones = false; // Draw Demand Zones input bool drawSupportZones = false; // Draw Support Zones input bool drawResistanceZones = false; // Draw Resistance Zones input bool drawBullishOrderBlocks = true; // Draw Bullish Order Blocks input bool drawBearishOrderBlocks = true; // Draw Bearish Order Blocks input bool drawBullishFairValueGaps = true; // Draw Bullish Fair Vlue Gaps input bool drawBearishFairValueGaps = true; // Draw Bearish Fair Vlue Gaps input bool drawBullishMomentumBars = true; // Draw Bullish Momentum Bars input bool drawBearishMomentumBars = true; // Draw Bearish Momentum Bars input bool drawBullishRejectionBars = true; // Draw Bullish Rejection Bars input bool drawBearishRejectionBars = true; // Draw Bearish Rejection Bars // #property indicator_chart_window // #property indicator_buffers 6 #property indicator_plots 6 // // Plot Buffers ... // // XSWING ... // // HIGH ... #define swingHighsBufferIndex 0 double swingHighsBuffer[]; // #property indicator_label1 "X121 XPOI SWH" #property indicator_type1 DRAW_ARROW #property indicator_color1 clrMagenta #property indicator_width1 3 // // LOW ... #define swingLowsBufferIndex 1 double swingLowsBuffer[]; // #property indicator_label2 "X121 XPOI SWL" #property indicator_type2 DRAW_ARROW #property indicator_color2 clrAqua #property indicator_width2 3 // // MOMENTUM ... // // BULLISH ... #define bullishMomentumBarsBufferIndex 2 double bullishMomentumBarsBuffer[]; // #property indicator_label3 "X121 XPOI BULLMNTM" #property indicator_type3 DRAW_ARROW #property indicator_color3 clrAqua #property indicator_width3 3 // // BEARISH ... #define bearishMomentumBarsBufferIndex 3 double bearishMomentumBarsBuffer[]; // #property indicator_label4 "X121 XPOI BEARNTM" #property indicator_type4 DRAW_ARROW #property indicator_color4 clrMagenta #property indicator_width4 3 // // REJECTION ... // // BULLISH ... #define bullishRejectionBarsBufferIndex 4 double bullishRejectionBarsBuffer[]; // #property indicator_label5 "X121 XPOI BULLMRJCT" #property indicator_type5 DRAW_ARROW #property indicator_color5 clrAqua #property indicator_width5 3 // // BEARISH ... #define bearishRejectionBarsBufferIndex 5 double bearishRejectionBarsBuffer[]; // #property indicator_label6 "X121 XPOI BEARRJCT" #property indicator_type6 DRAW_ARROW #property indicator_color6 clrMagenta #property indicator_width6 3 // // Data Buffers ... // // Variables, Properties and etc ... // // this counts Available Bars ... int limit; // int maxLength; // bool isPOIRequested = false; string iPrefix = ShortName + "_" + ToString(_Period); // XCPOIDrawer *mPOIDrawer; XCPOIDetector *mPOIDetector; // // Supported POIS ... // // Swings ... XCSwing *mSwingHighs[]; XCSwing *mSwingLows[]; // // Rejections ... XCRejectionBar *mBullishRejectionBars[]; XCRejectionBar *mBearishRejectionBars[]; // // Momentums ... XCMomentumBar *mBullishMomentumBars[]; XCMomentumBar *mBearishMomentumBars[]; // // Order Block ... XCOrderBlock *mBullishOrderBlocks[]; XCOrderBlock *mBearishOrderBlocks[]; // // Fair Value Gap ... XCFVG *mBullishFairValueGaps[]; XCFVG *mBearishFairValueGaps[]; // // Support and Resistances ... XCSupportZone *mSupportZones[]; XCResistanceZone *mResistanceZones[]; // // Supply and Demand ... XCSupplyZone *mSupplyZones[]; XCDemandZone *mDemandZones[]; // XCBaseObject *mPOIObjects[]; // // Event Handlers ... /** * Initialize Indicator ... * * @return ( int ) */ int OnInit() { // // Validate Inputs ... if (!ValidateInputs()) { return INIT_PARAMETERS_INCORRECT; } // // Initialize POI Detector ... InitialiDetector(); // // because in some cases we may have more than one input for // calculation and we must prevent any calculation // untill we pass the biggest input length, here we get max Input length // and then wait until pass it ... maxLength = ExtractMaxLengthOfInputs(); // // Define Index Buffers ... DefineBuffers(); // // Set Indicator ShortName ... SetIndicatorName(); IndicatorSetInteger(INDICATOR_DIGITS, 2); // // Init Succeed ... return INIT_SUCCEEDED; } /** * De Initialize Indicator ... * * @param reason: Integer, De Initialization Reason ... */ void OnDeinit(const int reason) { // // REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function // REASON_REMOVE 1 Program removed from a chart // REASON_RECOMPILE 2 Program recompiled // REASON_CHARTCHANGE 3 A symbol or a chart period is changed // REASON_CHARTCLOSE 4 Chart closed // REASON_PARAMETERS 5 Inputs changed by a user // REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings // REASON_TEMPLATE 7 Another chart template applied // REASON_INITFAILED 8 The OnInit() handler returned a non-zero value // REASON_CLOSE 9 Terminal closed // Clean(mSupplyZones); Clean(mDemandZones); Clean(mSupportZones); Clean(mResistanceZones); Clean(mBullishOrderBlocks); Clean(mBearishOrderBlocks); Clean(mBullishFairValueGaps); Clean(mBearishFairValueGaps); // Clean(mSwingLows); Clean(mSwingHighs); Clean(mBullishMomentumBars); Clean(mBearishMomentumBars); Clean(mBullishRejectionBars); Clean(mBearishRejectionBars); // CleanChart(); // mPOIDetector.Destroy(); // ZeroMemory(mPOIDrawer); ZeroMemory(mPOIDetector); } /** * Calculate Bars ... * * @param rates_total: Integer, Total Bars on Chart ... * @param prev_calculated: Integer, Total Calculated Bars on Charts ... * @param time: DateTime Array, History of Open Time ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param low: Double Array, History of Low Prices ... * @param close: Double Array, History of Close Prices ... * @param tick_volume: Long, History of Tick Volumes on Bar ... * @param volume: Long, History of Trade Volumes ... * @param spread: Double, History of Spread Price ... * * @return ( int ) */ int OnCalculate( const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[] // ) { // // Prepare Buffers ... ArraySetAsSeries(time, true); ArraySetAsSeries(open, true); ArraySetAsSeries(high, true); ArraySetAsSeries(low, true); ArraySetAsSeries(close, true); ArraySetAsSeries(tick_volume, true); ArraySetAsSeries(volume, true); ArraySetAsSeries(spread, true); // limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1; // // Main Loop ... for (int i = limit - 1; i >= 0 && !IsStopped(); i--) { // CalculateBuffers( i, prev_calculated, rates_total, // open, high, close, low, tick_volume // ); } // return rates_total; } // // Functions ... /** * Validate Input Args for Initialization ... * * @return ( bool ) */ bool ValidateInputs() { // bool result = false; // result = // true // ; // return result; } /** * Extract Max Length of Inputs ... * * @return ( int ) */ int ExtractMaxLengthOfInputs() { // int result = 0; // result = MathMax(result, result); // return result; } /** * Set Indicator Short Name and also we can define Buffers Labels ... */ void SetIndicatorName() { IndicatorSetString(INDICATOR_SHORTNAME, ShortName); } /** * Define Required Buffers ... */ void DefineBuffers() { // // Plot Buffers ... // // SWING ... // // LOW ... ENUM_DRAW_TYPE swingLowsDrawType = drawSwingLows ? DRAW_ARROW : DRAW_NONE; // ArraySetAsSeries(swingLowsBuffer, true); SetIndexBuffer(swingLowsBufferIndex, swingLowsBuffer, INDICATOR_DATA); // PlotIndexSetInteger(swingLowsBufferIndex, PLOT_SHOW_DATA, drawSwingLows); PlotIndexSetInteger(swingLowsBufferIndex, PLOT_DRAW_TYPE, swingLowsDrawType); // PlotIndexSetDouble(swingLowsBufferIndex, PLOT_EMPTY_VALUE, 0); PlotIndexSetInteger(swingLowsBufferIndex, PLOT_ARROW, swingLowsArrowCode); // // LOW ... ENUM_DRAW_TYPE swingHighsDrawType = drawSwingLows ? DRAW_ARROW : DRAW_NONE; // ArraySetAsSeries(swingHighsBuffer, true); SetIndexBuffer(swingHighsBufferIndex, swingHighsBuffer, INDICATOR_DATA); // PlotIndexSetInteger(swingHighsBufferIndex, PLOT_SHOW_DATA, drawSwingLows); PlotIndexSetInteger(swingHighsBufferIndex, PLOT_DRAW_TYPE, swingHighsDrawType); // PlotIndexSetDouble(swingHighsBufferIndex, PLOT_EMPTY_VALUE, 0); PlotIndexSetInteger(swingHighsBufferIndex, PLOT_ARROW, swingHighsArrowCode); // // REJECTION ... // // BULLISH ... ENUM_DRAW_TYPE bullishRejectionBarsDrawType = drawSwingLows ? DRAW_ARROW : DRAW_NONE; // ArraySetAsSeries(bullishRejectionBarsBuffer, true); SetIndexBuffer(bullishRejectionBarsBufferIndex, bullishRejectionBarsBuffer, INDICATOR_DATA); // PlotIndexSetInteger(bullishRejectionBarsBufferIndex, PLOT_SHOW_DATA, drawSwingLows); PlotIndexSetInteger(bullishRejectionBarsBufferIndex, PLOT_DRAW_TYPE, bullishRejectionBarsDrawType); // PlotIndexSetDouble(bullishRejectionBarsBufferIndex, PLOT_EMPTY_VALUE, 0); PlotIndexSetInteger(bullishRejectionBarsBufferIndex, PLOT_ARROW, bullishRejectionBarsArrowCode); // // BEARISH ... ENUM_DRAW_TYPE bearishRejectionBarsDrawType = drawSwingLows ? DRAW_ARROW : DRAW_NONE; // ArraySetAsSeries(bearishRejectionBarsBuffer, true); SetIndexBuffer(bearishRejectionBarsBufferIndex, bearishRejectionBarsBuffer, INDICATOR_DATA); // PlotIndexSetInteger(bearishRejectionBarsBufferIndex, PLOT_SHOW_DATA, drawSwingLows); PlotIndexSetInteger(bearishRejectionBarsBufferIndex, PLOT_DRAW_TYPE, bearishRejectionBarsDrawType); // PlotIndexSetDouble(bearishRejectionBarsBufferIndex, PLOT_EMPTY_VALUE, 0); PlotIndexSetInteger(bearishRejectionBarsBufferIndex, PLOT_ARROW, bearishRejectionBarsArrowCode); // // MOMENTUM ... // // BULLISH ... ENUM_DRAW_TYPE bullishMomentumBarsDrawType = drawSwingLows ? DRAW_ARROW : DRAW_NONE; // ArraySetAsSeries(bullishMomentumBarsBuffer, true); SetIndexBuffer(bullishMomentumBarsBufferIndex, bullishMomentumBarsBuffer, INDICATOR_DATA); // PlotIndexSetInteger(bullishMomentumBarsBufferIndex, PLOT_SHOW_DATA, drawSwingLows); PlotIndexSetInteger(bullishMomentumBarsBufferIndex, PLOT_DRAW_TYPE, bullishMomentumBarsDrawType); // PlotIndexSetDouble(bullishMomentumBarsBufferIndex, PLOT_EMPTY_VALUE, 0); PlotIndexSetInteger(bullishMomentumBarsBufferIndex, PLOT_ARROW, bullishMomentumBarsArrowCode); // // BEARISH ... ENUM_DRAW_TYPE bearishMomentumBarsDrawType = drawSwingLows ? DRAW_ARROW : DRAW_NONE; // ArraySetAsSeries(bearishMomentumBarsBuffer, true); SetIndexBuffer(bearishMomentumBarsBufferIndex, bearishMomentumBarsBuffer, INDICATOR_DATA); // PlotIndexSetInteger(bearishMomentumBarsBufferIndex, PLOT_SHOW_DATA, drawSwingLows); PlotIndexSetInteger(bearishMomentumBarsBufferIndex, PLOT_DRAW_TYPE, bearishMomentumBarsDrawType); // PlotIndexSetDouble(bearishMomentumBarsBufferIndex, PLOT_EMPTY_VALUE, 0); PlotIndexSetInteger(bearishMomentumBarsBufferIndex, PLOT_ARROW, bearishMomentumBarsArrowCode); // // Data Buffers ... } /** * Initialize POI Detector ... */ void InitialiDetector() { // ArraySetAsSeries(mSwingLows, true); ArraySetAsSeries(mSwingHighs, true); ArraySetAsSeries(mBullishMomentumBars, true); ArraySetAsSeries(mBearishMomentumBars, true); ArraySetAsSeries(mBullishRejectionBars, true); ArraySetAsSeries(mBearishRejectionBars, true); // ArraySetAsSeries(mSupplyZones, true); ArraySetAsSeries(mDemandZones, true); ArraySetAsSeries(mSupportZones, true); ArraySetAsSeries(mResistanceZones, true); ArraySetAsSeries(mBullishOrderBlocks, true); ArraySetAsSeries(mBearishOrderBlocks, true); ArraySetAsSeries(mBullishFairValueGaps, true); ArraySetAsSeries(mBearishFairValueGaps, true); // mPOIDetector = new XCPOIDetector( _Symbol, _Period // ); // // Configure POI Detector ... mPOIDetector.SwingRange(swingRange); mPOIDetector.MaxNumberOfPOIs(maxNumberOfPOIs); mPOIDetector.OrderBlocksSameBars(orderBlocksSameBars); mPOIDetector.TicksRangeZoneLevel(ticksRangeZoneLevel); mPOIDetector.TicksRangeZoneRange(ticksRangeZoneRange); mPOIDetector.SupplyAndDemandRange(supplyAndDemandRange); mPOIDetector.FairValueGapsSameBars(fairValueGapsSameBars); mPOIDetector.MomentumBarExtendRange(momentumBarExtendRange); mPOIDetector.MomentumBarBodyPercent(momentumBarBodyPercent); mPOIDetector.MaxNumberOfRequiredPOIs(maxNumberOfRequiredPOIs); mPOIDetector.RejectionBarExtendRange(rejectionBarExtendRange); mPOIDetector.RejectionBarShadowPercent(rejectionBarShadowPercent); mPOIDetector.SupportAndResistanceRange(supportAndResistanceRange); // mPOIDrawer = new XCPOIDrawer(); // // Configure Drawer ... mPOIDrawer.Prefix(iPrefix); // mPOIDrawer.BarBullishColor(bullishColor); mPOIDrawer.BarBearishColor(bearishColor); // mPOIDrawer.DemandZoneColor(bullishColor); mPOIDrawer.BullishFVGColor(bullishColor); mPOIDrawer.SupportZoneColor(bullishColor); mPOIDrawer.BullishOrderBlockColor(bullishColor); // mPOIDrawer.SupplyZoneColor(bearishColor); mPOIDrawer.BearishFVGColor(bearishColor); mPOIDrawer.ResistanceZoneColor(bearishColor); mPOIDrawer.BearishOrderBlockColor(bearishColor); // mPOIDrawer.SupplyZoneStyle(supDemStyle); mPOIDrawer.DemandZoneStyle(supDemStyle); mPOIDrawer.SupportZoneStyle(supResStyle); mPOIDrawer.ResistanceZoneStyle(supResStyle); mPOIDrawer.BullishFVGStyle(fairValueGapStyle); mPOIDrawer.BearishFVGStyle(fairValueGapStyle); mPOIDrawer.BullishOrderBlockStyle(orderBlockStyle); mPOIDrawer.BearishOrderBlockStyle(orderBlockStyle); // } /** * Calculate Custom Buffers ... * * @param bar_index: Integer, Represent Current Bar ... * @param prevCalculated: Integer, Represent Previous Calculated Bars ... * @param ratesTotal: Integer, Represents All Available Bars ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param close: Double Array, History of Close Prices ... * @param low: Double Array, History of Low Prices ... * @param tickVolume: Long, History of Tick Volumes on Bar ... */ void CalculateBuffers( int bar_index, // Selected Bar Index const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // int barsLimit = startCalculationForLastBars > 0 ? startCalculationForLastBars : 0; // bool canCalculate = barsLimit == 0 || bar_index <= barsLimit; if (canCalculate) { // if (bar_index == 0) { // XPOIState state; ENUM_XPOI_EVENTS events[]; int numberOfEvents = mPOIDetector.Update(events); bool hasEvents = IsValidSize(numberOfEvents); if (hasEvents) { // mPOIDetector.GetState(state); bool isStateValid = state.IsValid() && state.HasChild(); if (isStateValid) { // // Order Blocks ... // // Bullish ... bool hasBullOB = Contains( X_BULLISH_ORDERBLOCK_DETECTED, events // ); if (hasBullOB) { // int count = state.CountBullishOrderBlocks(); if (IsValidSize(count)) { // Add( state.bullishOrderBlocks[count - 1], mBullishOrderBlocks // ); } } // // Bearish ... bool hasBearOB = Contains( X_BEARISH_ORDERBLOCK_DETECTED, events // ); if (hasBearOB) { // int count = state.CountBearishOrderBlocks(); if (IsValidSize(count)) { // Add( state.bearishOrderBlocks[count - 1], mBearishOrderBlocks // ); } } // // Fair Value Gaps ... // // Bullish ... bool hasBullFVG = Contains( X_BULLISH_FVG_DETECTED, events // ); if (hasBullFVG) { // int count = state.CountBullishFairValueGaps(); if (IsValidSize(count)) { // Add( state.bullishFairValueGaps[count - 1], mBullishFairValueGaps // ); } } // // Bearish ... bool hasBearFVG = Contains( X_BEARISH_FVG_DETECTED, events // ); if (hasBearFVG) { // int count = state.CountBearishFairValueGaps(); if (IsValidSize(count)) { // Add( state.bearishFairValueGaps[count - 1], mBearishFairValueGaps // ); } } // // Support and Resistance ... // // Support ... bool hasSupportZone = Contains( X_SUPPORT_ZONE_DETECTED, events // ); if (hasSupportZone) { // int count = state.CountSupportZones(); if (IsValidSize(count)) { // Add( state.supportZones[count - 1], mSupportZones // ); } } // // Resistance ... bool hasResistanceZone = Contains( X_RESISTANCE_ZONE_DETECTED, events // ); if (hasResistanceZone) { // int count = state.CountResistanceZones(); if (IsValidSize(count)) { // Add( state.resistanceZones[count - 1], mResistanceZones // ); } } // // Supply and Demand ... // // Supply ... bool hasSupplyZone = Contains( X_SUPPLY_ZONE_DETECTED, events // ); if (hasSupplyZone) { // int count = state.CountSupplyZones(); if (IsValidSize(count)) { // Add( state.supplyZones[count - 1], mSupplyZones // ); } } // // Demand ... bool hasDemandZone = Contains( X_DEMAND_ZONE_DETECTED, events // ); if (hasDemandZone) { // int count = state.CountDemandZones(); if (IsValidSize(count)) { // Add( state.demandZones[count - 1], mDemandZones // ); } } // // // // // Swings ... // // Low ... bool hasSwingLow = Contains( X_SWING_LOW_DETECTED, events // ); if (hasSwingLow) { // int count = state.CountSwingLows(); if (IsValidSize(count)) { // Add( state.swingLows[count - 1], mSwingLows // ); } } // // High ... bool hasSwingHigh = Contains( X_SWING_HIGH_DETECTED, events // ); if (hasSwingHigh) { // int count = state.CountSwingHighs(); if (IsValidSize(count)) { // Add( state.swingHighs[count - 1], mSwingHighs // ); } } // // Momentum ... // // Bullish ... bool hasBullishMomentumBar = Contains( X_BULLISH_MOMENTUM_BAR_DETECTED, events // ); if (hasBullishMomentumBar) { // int count = state.CountBullishMomentumBars(); if (IsValidSize(count)) { // Add( state.bullishMomentumBars[count - 1], mBullishMomentumBars // ); } } // // Bearish ... bool hasBearishMomentumBar = Contains( X_BEARISH_MOMENTUM_BAR_DETECTED, events // ); if (hasBearishMomentumBar) { // int count = state.CountBearishMomentumBars(); if (IsValidSize(count)) { // Add( state.bearishMomentumBars[count - 1], mBearishMomentumBars // ); } } // // Rejection ... // // Bullish ... bool hasBullishRejectionBar = Contains( X_BULLISH_REJECTION_BAR_DETECTED, events // ); if (hasBullishRejectionBar) { // int count = state.CountBullishRejectionBars(); if (IsValidSize(count)) { // Add( state.bullishRejectionBars[count - 1], mBullishRejectionBars // ); } } // // Bearish ... bool hasBearishRejectionBar = Contains( X_BEARISH_REJECTION_BAR_DETECTED, events // ); if (hasBearishRejectionBar) { // int count = state.CountBearishRejectionBars(); if (IsValidSize(count)) { // Add( state.bearishRejectionBars[count - 1], mBearishRejectionBars // ); } } // } } // if (bar_index == 0 && !isPOIRequested) { // mPOIDetector.Init(); isPOIRequested = true; } // if (isPOIRequested && bar_index == 0 && !mPOIDetector.IsLocked()) { // mPOIDetector.GetState(state); bool isStateValid = state.IsValid() && state.HasChild(); if (isStateValid) { // // Order Blocks ... // // Bullish ... int bullishOBsCount = state.CountBullishOrderBlocks(); bool hasBullishOBs = IsValidSize(bullishOBsCount); if (hasBullishOBs) { // for (int i = 0; i < bullishOBsCount; i++) { // XOHCL activatedBar; ENUM_X_DIRECTION activatedDir; bool isActivated = state.bullishOrderBlocks[i].IsActivated( activatedBar, activatedDir // ); if (!isActivated) { // Add( state.bullishOrderBlocks[i], mBullishOrderBlocks // ); } } } // // Bearish ... int bearishOBsCount = state.CountBearishOrderBlocks(); bool hasBearishOBs = IsValidSize(bearishOBsCount); if (hasBearishOBs) { // for (int i = 0; i < bearishOBsCount; i++) { // XOHCL activatedBar; ENUM_X_DIRECTION activatedDir; bool isActivated = state.bearishOrderBlocks[i].IsActivated( activatedBar, activatedDir // ); if (!isActivated) { // Add( state.bearishOrderBlocks[i], mBearishOrderBlocks // ); } } } // // Fair Value Gaps ... // // Bullish ... int bullishFVGsCount = state.CountBullishFairValueGaps(); bool hasBullishFVGs = IsValidSize(bullishFVGsCount); if (hasBullishFVGs) { // for (int i = 0; i < bullishFVGsCount; i++) { // XOHCL activatedBar; ENUM_X_DIRECTION activatedDir; bool isActivated = state.bullishFairValueGaps[i].IsActivated( activatedBar, activatedDir // ); if (!isActivated) { // Add( state.bullishFairValueGaps[i], mBullishFairValueGaps // ); } } } // // Bearish ... int bearishFVGsCount = state.CountBearishFairValueGaps(); bool hasBearishFVGs = IsValidSize(bearishFVGsCount); if (hasBearishFVGs) { // for (int i = 0; i < bearishFVGsCount; i++) { // XOHCL activatedBar; ENUM_X_DIRECTION activatedDir; bool isActivated = state.bearishFairValueGaps[i].IsActivated( activatedBar, activatedDir // ); if (!isActivated) { // Add( state.bearishFairValueGaps[i], mBearishFairValueGaps // ); } } } // // Support and Resistance ... // // Support ... int supportZonesCount = state.CountSupportZones(); bool hasSupportZones = IsValidSize(supportZonesCount); if (hasSupportZones) { // for (int i = 0; i < supportZonesCount; i++) { // Add( state.supportZones[i], mSupportZones // ); } } // // Resistance ... int resistanceZonesCount = state.CountResistanceZones(); bool hasResistanceZones = IsValidSize(resistanceZonesCount); if (hasResistanceZones) { // for (int i = 0; i < resistanceZonesCount; i++) { // Add( state.resistanceZones[i], mResistanceZones // ); } } // // Supply and Demand ... // // Supply ... int supplyZonesCount = state.CountSupplyZones(); bool hasSupplyZones = IsValidSize(supplyZonesCount); if (hasSupplyZones) { // for (int i = 0; i < supplyZonesCount; i++) { // Add( state.supplyZones[i], mSupplyZones // ); } } // // Demand ... int demandZonesCount = state.CountDemandZones(); bool hasDemandZones = IsValidSize(demandZonesCount); if (hasDemandZones) { // for (int i = 0; i < demandZonesCount; i++) { // Add( state.demandZones[i], mDemandZones // ); } } // // // // // Swings ... // // Low ... int swingLowsCount = state.CountSwingLows(); bool hasSwingLows = IsValidSize(swingLowsCount); if (hasSwingLows) { // for (int i = 0; i < swingLowsCount; i++) { // Add( state.swingLows[i], mSwingLows // ); } } // // Highs... int swingHighsCount = state.CountSwingHighs(); bool hasSwingHighs = IsValidSize(swingHighsCount); if (hasSwingHighs) { // for (int i = 0; i < swingHighsCount; i++) { // Add( state.swingHighs[i], mSwingHighs // ); } } // // Momentum Bars ... // // Bullish ... int bullishMomentumBarsCount = state.CountBullishMomentumBars(); bool hasBullishMomentumBars = IsValidSize(bullishMomentumBarsCount); if (hasBullishMomentumBars) { // for (int i = 0; i < bullishMomentumBarsCount; i++) { // Add( state.bullishMomentumBars[i], mBullishMomentumBars // ); } } // // Bearish ... int bearishMomentumBarsCount = state.CountBearishMomentumBars(); bool hasBearishMomentumBars = IsValidSize(bearishMomentumBarsCount); if (hasBearishMomentumBars) { // for (int i = 0; i < bearishMomentumBarsCount; i++) { // Add( state.bearishMomentumBars[i], mBearishMomentumBars // ); } } // // Rejection Bars ... // // Bullish ... int bullishRejectionBarsCount = state.CountBullishRejectionBars(); bool hasBullishRejectionBars = IsValidSize(bullishRejectionBarsCount); if (hasBullishRejectionBars) { // for (int i = 0; i < bullishRejectionBarsCount; i++) { // Add( state.bullishRejectionBars[i], mBullishRejectionBars // ); } } // // Bearish ... int bearishRejectionBarsCount = state.CountBearishRejectionBars(); bool hasBearishRejectionBars = IsValidSize(bearishRejectionBarsCount); if (hasBearishRejectionBars) { // for (int i = 0; i < bearishRejectionBarsCount; i++) { // Add( state.bearishRejectionBars[i], mBearishRejectionBars // ); } } // } } // UpdatePOIs( bar_index, prevCalculated // ); } } else { FillBuffersZero(bar_index); } } /** * Fill All Bufers to Zero Vlue for Specified Bar Index ... * * @param barIndex: Integer ... */ void FillBuffersZero(int barIndex) { // swingLowsBuffer[barIndex] = 0; swingHighsBuffer[barIndex] = 0; bullishMomentumBarsBuffer[barIndex] = 0; bearishMomentumBarsBuffer[barIndex] = 0; bullishRejectionBarsBuffer[barIndex] = 0; bearishRejectionBarsBuffer[barIndex] = 0; } /** * Update nd Validate POIS ... */ void UpdatePOIs( int barIndex, const int prevCalculated // ) { // // CleanChart(); FillBuffersZero(barIndex); // if (prevCalculated <= 0) { return; } // // CleanChart(); datetime cTime = TimeCurrent(); // XOHCL iBar; bool isInited = iBar.Init( _Symbol, _Period, barIndex // ); if (!isInited) { return; } // XOHCL iPBar; isInited = iPBar.Init( _Symbol, _Period, barIndex + 1 // ); if (!isInited) { return; } // // Order Blcoks ... // // Bullish ... int bullOBsCount = ArraySize(mBullishOrderBlocks); if (IsValidSize(bullOBsCount)) { // for (int i = 0; i < bullOBsCount; i++) { // // Check OB Activation ... // XOHCL activatedBar; // ENUM_X_DIRECTION activatedDir; // bool isActivated = mBullishOrderBlocks[i].IsActivated( // activatedBar, // activatedDir // // ); // // Check OB Breake ... XOHCL breakerBar; ENUM_X_DIRECTION breakerDir; bool isBreaked = mBullishOrderBlocks[i].IsBreaked( breakerBar, breakerDir // ); if (!isBreaked) { mBullishOrderBlocks[i].To(cTime); } else { mBullishOrderBlocks[i].To(breakerBar.time); } // if (drawBullishOrderBlocks) { // XCBullishOrderBlockObject *iObj; bool isCreated = mPOIDrawer.CreateBullishOrderBlock( mBullishOrderBlocks[i], iObj // ); if (isCreated) { // Add( (XCBaseObject *)iObj, mPOIObjects // ); } } } } // // Bearish ... int bearOBsCount = ArraySize(mBearishOrderBlocks); if (IsValidSize(bearOBsCount)) { // for (int i = 0; i < bearOBsCount; i++) { // // Check OB Activation ... // XOHCL activatedBar; // ENUM_X_DIRECTION activatedDir; // bool isActivated = mBearishOrderBlocks[i].IsActivated( // activatedBar, // activatedDir // // ); // // Check OB Breake ... XOHCL breakerBar; ENUM_X_DIRECTION breakerDir; bool isBreaked = mBearishOrderBlocks[i].IsBreaked( breakerBar, breakerDir // ); if (!isBreaked) { mBearishOrderBlocks[i].To(cTime); } else { mBearishOrderBlocks[i].To(breakerBar.time); } // if (drawBearishOrderBlocks) { // XCBearishOrderBlockObject *iObj; bool isCreated = mPOIDrawer.CreateBearishOrderBlock( mBearishOrderBlocks[i], iObj // ); if (isCreated) { // Add( (XCBaseObject *)iObj, mPOIObjects // ); } } } } // // Fair Value Gap ... // // Bullish ... int bullFVGsCount = ArraySize(mBullishFairValueGaps); if (IsValidSize(bullFVGsCount)) { // for (int i = 0; i < bullFVGsCount; i++) { // // Check OB Activation ... // XOHCL activatedBar; // ENUM_X_DIRECTION activatedDir; // bool isActivated = mBullishFairValueGaps[i].IsActivated( // activatedBar, // activatedDir // // ); // // Check OB Breake ... XOHCL breakerBar; ENUM_X_DIRECTION breakerDir; bool isBreaked = mBullishFairValueGaps[i].IsBreaked( breakerBar, breakerDir // ); if (!isBreaked) { mBullishFairValueGaps[i].To(cTime); } else { mBullishFairValueGaps[i].To(breakerBar.time); } // if (drawBullishFairValueGaps) { // XCBullishFairValueGapObject *iObj; bool isCreated = mPOIDrawer.CreateBullishFairValueGap( mBullishFairValueGaps[i], iObj // ); if (isCreated) { // Add( (XCBaseObject *)iObj, mPOIObjects // ); } } } } // // Bearish ... int bearFVGsCount = ArraySize(mBearishFairValueGaps); if (IsValidSize(bearFVGsCount)) { // for (int i = 0; i < bearFVGsCount; i++) { // // Check OB Activation ... // XOHCL activatedBar; // ENUM_X_DIRECTION activatedDir; // bool isActivated = mBearishFairValueGaps[i].IsActivated( // activatedBar, // activatedDir // // ); // // Check OB Breake ... XOHCL breakerBar; ENUM_X_DIRECTION breakerDir; bool isBreaked = mBearishFairValueGaps[i].IsBreaked( breakerBar, breakerDir // ); if (!isBreaked) { mBearishFairValueGaps[i].To(cTime); } else { mBearishFairValueGaps[i].To(breakerBar.time); } // if (drawBearishFairValueGaps) { // XCBearishFairValueGapObject *iObj; bool isCreated = mPOIDrawer.CreateBearishFairValueGap( mBearishFairValueGaps[i], iObj // ); if (isCreated) { // Add( (XCBaseObject *)iObj, mPOIObjects // ); } } } } // // Support and Resistance Zones ... // // Support Zones ... int supportZonesCount = ArraySize(mSupportZones); if (IsValidSize(supportZonesCount)) { // for (int i = 0; i < supportZonesCount; i++) { // // Check OB Activation ... // XOHCL activatedBar; // ENUM_X_DIRECTION activatedDir; // bool isActivated = mSupportZones[i].IsActivated( // activatedBar, // activatedDir // // ); // // Check OB Breake ... XOHCL breakerBar; ENUM_X_DIRECTION breakerDir; bool isBreaked = mSupportZones[i].IsBreaked( breakerBar, breakerDir // ); if (!isBreaked) { mSupportZones[i].To(cTime); } else { mSupportZones[i].To(breakerBar.time); } // if (drawSupportZones) { // XCSupportZoneObject *iObj; bool isCreated = mPOIDrawer.CreateSupportZone( mSupportZones[i], iObj // ); if (isCreated) { // Add( (XCBaseObject *)iObj, mPOIObjects // ); } } } } // // Resistance Zones ... int resistanceZonesCount = ArraySize(mResistanceZones); if (IsValidSize(resistanceZonesCount)) { // for (int i = 0; i < resistanceZonesCount; i++) { // // Check OB Activation ... // XOHCL activatedBar; // ENUM_X_DIRECTION activatedDir; // bool isActivated = mResistanceZones[i].IsActivated( // activatedBar, // activatedDir // // ); // // Check OB Breake ... XOHCL breakerBar; ENUM_X_DIRECTION breakerDir; bool isBreaked = mResistanceZones[i].IsBreaked( breakerBar, breakerDir // ); if (!isBreaked) { mResistanceZones[i].To(cTime); } else { mResistanceZones[i].To(breakerBar.time); } // if (drawResistanceZones) { // XCResistanceZoneObject *iObj; bool isCreated = mPOIDrawer.CreateResistanceZone( mResistanceZones[i], iObj // ); if (isCreated) { // Add( (XCBaseObject *)iObj, mPOIObjects // ); } } } } // // Supply and Demand Zones ... // // Supply Zones ... int supplyZonesCount = ArraySize(mSupplyZones); if (IsValidSize(supplyZonesCount)) { // for (int i = 0; i < supplyZonesCount; i++) { // // Check OB Activation ... // XOHCL activatedBar; // ENUM_X_DIRECTION activatedDir; // bool isActivated = mSupplyZones[i].IsActivated( // activatedBar, // activatedDir // // ); // // Check OB Breake ... XOHCL breakerBar; ENUM_X_DIRECTION breakerDir; bool isBreaked = mSupplyZones[i].IsBreaked( breakerBar, breakerDir // ); if (!isBreaked) { mSupplyZones[i].To(cTime); } else { mSupplyZones[i].To(breakerBar.time); } // if (drawSupplyZones) { // XCSupplyZoneObject *iObj; bool isCreated = mPOIDrawer.CreateSupplyZone( mSupplyZones[i], iObj // ); if (isCreated) { // Add( (XCBaseObject *)iObj, mPOIObjects // ); } } } } // // Demand Zones ... int demandZonesCount = ArraySize(mDemandZones); if (IsValidSize(demandZonesCount)) { // for (int i = 0; i < demandZonesCount; i++) { // // Check OB Activation ... // XOHCL activatedBar; // ENUM_X_DIRECTION activatedDir; // bool isActivated = mDemandZones[i].IsActivated( // activatedBar, // activatedDir // // ); // // Check OB Breake ... XOHCL breakerBar; ENUM_X_DIRECTION breakerDir; bool isBreaked = mDemandZones[i].IsBreaked( breakerBar, breakerDir // ); if (!isBreaked) { mDemandZones[i].To(cTime); } else { mDemandZones[i].To(breakerBar.time); } // if (drawDemandZones) { // XCDemandZoneObject *iObj; bool isCreated = mPOIDrawer.CreateDemandZone( mDemandZones[i], iObj // ); if (isCreated) { // Add( (XCBaseObject *)iObj, mPOIObjects // ); } } } } // // // // double swingsDistance = _Point * 5; double momentumBarsDistance = _Point * 20; double rejectionBarsDistance = _Point * 40; // // Swings ... // // Lows ... int swingLowsCount = ArraySize(mSwingLows); if (IsValidSize(swingLowsCount)) { // for (int i = 0; i < swingLowsCount; i++) { // XCSwing *iSwing = mSwingLows[i]; // double iValue = iSwing.GetValue() - swingsDistance; int iIDX = iBarShift( _Symbol, _Period, iSwing.GetTime() // ); // swingLowsBuffer[iIDX] = iValue; } } // // Highs ... int swingHighsCount = ArraySize(mSwingHighs); if (IsValidSize(swingHighsCount)) { // for (int i = 0; i < swingHighsCount; i++) { // XCSwing *iSwing = mSwingHighs[i]; // double iValue = iSwing.GetValue() + swingsDistance; int iIDX = iBarShift( _Symbol, _Period, iSwing.GetTime() // ); // swingHighsBuffer[iIDX] = iValue; } } // // Momentum Bars ... // // Bullish ... int bullishMomentumBarsCount = ArraySize(mBullishMomentumBars); if (IsValidSize(bullishMomentumBarsCount)) { // for (int i = 0; i < bullishMomentumBarsCount; i++) { // XCMomentumBar *iMomentumBar = mBullishMomentumBars[i]; // XOHCL iBar; bool isIBarFilled = iMomentumBar.FillBar(iBar); // double iValue = iBar.low - momentumBarsDistance; int iIDX = iBar.Index(); // bullishMomentumBarsBuffer[iIDX] = iValue; } } // // Bearish ... int bearishMomentumBarsCount = ArraySize(mBearishMomentumBars); if (IsValidSize(bearishMomentumBarsCount)) { // for (int i = 0; i < bearishMomentumBarsCount; i++) { // XCMomentumBar *iMomentumBar = mBearishMomentumBars[i]; // XOHCL iBar; bool isIBarFilled = iMomentumBar.FillBar(iBar); // double iValue = iBar.high + momentumBarsDistance; int iIDX = iBar.Index(); // bearishMomentumBarsBuffer[iIDX] = iValue; } } // // Rejection Bars ... // // Bullish ... int bullishRejectionBarsCount = ArraySize(mBullishRejectionBars); if (IsValidSize(bullishRejectionBarsCount)) { // for (int i = 0; i < bullishRejectionBarsCount; i++) { // XCRejectionBar *iRejectionBar = mBullishRejectionBars[i]; // XOHCL iBar; bool isIBarFilled = iRejectionBar.FillBar(iBar); // double iValue = iBar.low - rejectionBarsDistance; int iIDX = iBar.Index(); // bullishRejectionBarsBuffer[iIDX] = iValue; } } // // Bearish ... int bearishRejectionBarsCount = ArraySize(mBearishRejectionBars); if (IsValidSize(bearishRejectionBarsCount)) { // for (int i = 0; i < bearishRejectionBarsCount; i++) { // XCRejectionBar *iRejectionBar = mBearishRejectionBars[i]; // XOHCL iBar; bool isIBarFilled = iRejectionBar.FillBar(iBar); // double iValue = iBar.high + rejectionBarsDistance; int iIDX = iBar.Index(); // bearishRejectionBarsBuffer[iIDX] = iValue; } } } /** * Clear all Drawn Objects ... */ void CleanChart() { // long chartID = mPOIDrawer.ChartIdentification(); int subWindow = mPOIDrawer.SubWindowIdentification(); string objName = NULL; // int count = ArraySize(mPOIObjects); if (IsValidSize(count)) { // for (int i = 0; i < count; i++) { // objName = mPOIObjects[i].ObjName(); mPOIObjects[i].Delete(); mPOIObjects[i].Detach(); // RemoveDraw( objName, chartID, subWindow // ); } } // RemoveDraws( iPrefix, chartID, subWindow // ); // Clean(mPOIObjects); // ZeroMemory(mPOIObjects); }