/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 X121 SMC Signal Class // ------------------------------------------------- // Name: XICH // Description: provide all Signalling functions ... // // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... #property library #property copyright "Copyright 2023, SaherElm IT Center" #property link "https://www.saherelm.ir" #property version "1.00" #property strict // // Imports ... #include "../Classes/x-121.smc.market.cycle.helper.class.mq5" #include "../Libraries/x-121.smc.guard.lib.mq5" #include "../Libraries/x-121.smc.lib.mq5" #include "./x-121.smc.xind.signal.lib.mq5" // // Definition ... class XCX121SMCXINDSignalDetector : public XCBase { // public: // // Props ... bool useGuards; double rfReward; bool isPassedBoxes; XBoxZone mWaitingBoxes[]; XBoxZone mBreakedBoxes[]; XBoxZone mActivatedBoxes[]; bool continuesRFTillTarget; XBoxZone mUnAvailableBoxes[]; X121SMCStrategyXINDSignalConditions mConditions; X121SMCStrategyXINDSignalConditions mConditionsCollection[]; // // Constructor(s) ... XCX121SMCXINDSignalDetector( string _symbol, ENUM_TIMEFRAMES _period // ) { // symbol = _symbol; period = _period; Init(); } // // Deconstructor ... ~XCX121SMCXINDSignalDetector() { DeInit(); } // // // /** * Detect Setup Conditions based on Signalling ... * * @param provider: X121SMCStrategySignalProviderData instance Reference, Specified Data for Cycles ... * @param maxAllowedSLDistanceInPoint: int, Max Allowed SL Distance in Points (if Bigger thn Zero Provided) ... * * @return ( bool ) */ bool DetectSignalSetup( X121SMCStrategySignalProviderData &provider, double tpReward = 3, double maxAllowedSLDistanceInPoint = 300 // ) { // bool result = false; // tpReward = NormalizeDouble(tpReward, 2); // // Validate Cycle Helpers ... result = provider.IsValid(); if (!result) { // mConditions.Clean(); // return result; } // bool isBullish = false; bool isBearish = false; // int zIndex = 0; int cIndex = zIndex + 1; int pIndex = cIndex + 1; int ppIndex = pIndex + 1; // int loopback = 10; // mConditions.symbol = symbol; mConditions.period = period; // double ask = GetAsk(symbol); double bid = GetBid(symbol); datetime cTime = TimeCurrent(); double points = GetPoints(symbol); // // Cycles Conditions ... result = provider.Prepare( zIndex, loopback, true, // Trigger ... true, // Decision ... true, // Analyse ... true, // Verification ... true, // Consolidation ... true // Vision ... ); if (!result) { // mConditions.Clean(); return result; } // // Select Drawer Class ... XCPOIDrawer *drawer = provider.visionCycleHelper.mPOIDrawer; // // Detecting Bars based on Decision Cycle ... XOHCL zBar; XOHCL cBar; XOHCL pBar; XOHCL pPBar; XOHCL consolidationZBar; result = zBar.Init( provider.decisionXConditions.symbol, provider.decisionXConditions.period, zIndex // ); result = result && zBar.GetPreviousBar(cBar); result = result && cBar.GetPreviousBar(pBar); result = result && pBar.GetPreviousBar(pPBar); result = result && provider.consolidationCycleHelper.GetBar( consolidationZBar, zIndex // ); if (!result) { // zBar.Clean(); cBar.Clean(); pBar.Clean(); pPBar.Clean(); consolidationZBar.Clean(); // return result; } // bool drawBar = false; if (drawBar) { // DrawBar( consolidationZBar, drawer // ); } // // // // // Setup Conditions ... double sls[]; double sl = 0; double pivot = 0; double point = 0; double targets[]; XBoxZone signalBox; XBoxZone signalZone; bool hasSignalBox = false; ENUM_X_DIRECTION signalBoxDir = X_DIRECTION_NONE; ENUM_X121SMC_XIND_PROVIDERS signalProvider = X121SMC_XIND_PROVIDER_NONE; // // // // int waitingBoxesCount = UpdateWaitingBoxes( X_CYCLE_ANALYSE, X_CYCLE_DECISION, provider // ); bool hasWaitingBoxes = IsValidSize(waitingBoxesCount); // DrawBoxes(drawer); // // Detect Signal Boxes ... hasSignalBox = HasXINDConditions( mWaitingBoxes, mActivatedBoxes, mBreakedBoxes, X_CYCLE_DECISION, signalBox, signalZone, signalBoxDir, provider, zIndex // ); if (hasSignalBox) { // signalProvider = X121SMC_XIND_PROVIDER_XIND; // MakeSignalBoxUnAvailable(signalBox); MakeSignalBoxUnAvailable(signalZone); } // // // // // Cleanup Signal if UnApproved ... if (!hasSignalBox) { // signalBox.Clean(); isBullish = false; isBearish = false; signalBoxDir = X_DIRECTION_NONE; } // // Summarize Results ... result = hasSignalBox; // if (result) { // int idx = -1; bool has = false; // // Draw Signal Box ... XCBoxObject *object; has = drawer.DrawBox( signalBox, object // ); if (has) { mObjects.Add(object); } // // Detect Signal Direction ... isBullish = IsBullish(signalBoxDir); isBearish = IsBearish(signalBoxDir); // pivot = isBullish ? signalBox.lower : signalBox.upper; // point = isBullish ? signalBox.upper : signalBox.lower; // double entry = GetEntry( signalBox.symbol, signalBoxDir // ); // // Selecting SL(s) ... // double iSL = 0; // // Default SL ... iSL = pivot; // Add( iSL, sls // ); // // Select and Provide SL Based on ... double iAtr = 0; if (signalProvider == X121SMC_XIND_PROVIDER_XIND) { // iAtr = provider.decisionXConditions.atrBuffer[1]; iAtr *= 0; // // Fix rf Reward ... rfReward = 2; } // // Select Condition SL ... // double slsMin = GetMin(sls); double slsMax = GetMax(sls); // double longSL = slsMax - iAtr; double shortSL = slsMin + iAtr; // sl = isBullish ? longSL : shortSL; // // Targets ... // double risk = MathAbs(entry - sl); // // Checking risk ... if (risk >= maxAllowedSLDistanceInPoint) { // Print("Max Aloowed Risk Point Reached ..."); } // // Reward to RF ... if (rfReward > 0) { // double iRFReward = rfReward * risk; double iRFTP = isBullish ? entry + iRFReward : entry - iRFReward; // Add( iRFTP, targets // ); // if (continuesRFTillTarget && rfReward < tpReward) { // double iReward = rfReward + 1; while (iReward < tpReward - 1) { // iRFReward = iReward * risk; iRFTP = isBullish ? entry + iRFReward : entry - iRFReward; // Add( iRFTP, targets // ); // iReward++; } } } // Copy( sls, mConditions.sls // ); Copy( targets, mConditions.targets // ); // mConditions.sl = sl; mConditions.pivot = pivot; mConditions.point = point; mConditions.setupTime = cTime; mConditions.dir = signalBoxDir; mConditions.signalBox = signalBox; mConditions.provider = signalProvider; } // // // // // Cleanup Resources ... // Clean(sls); Clean(targets); // provider.Clean(); // zBar.Clean(); cBar.Clean(); pBar.Clean(); pPBar.Clean(); signalBox.Clean(); ZeroMemory(drawer); consolidationZBar.Clean(); // return result; } /** * Detect Trigger Conditions for Specified Signal ... * * @param conditions: X121SMCStrategyXINDSignalConditions instance Reference, Specified Signal Conditions ... * @param provider: X121SMCStrategySignalProviderData instance Reference, Specified Data for Cycles ... * @param maxAllowedSetupAge: specified Setup Age for Expiration (if bigger than Zero) ... * * @return ( bool ) */ bool DetectSignalTrigger( X121SMCStrategyXINDSignalConditions &conditions, X121SMCStrategySignalProviderData &provider, int maxAllowedSetupAge = 60 // ) { // bool result = false; // result = // provider.IsValid() // ; if (!result) { return result; } // result = conditions.IsSetuped(); if (!result) { return result; } // datetime setupTime = conditions.setupTime; ENUM_X_DIRECTION setupDir = conditions.dir; // bool isBullish = IsBullish(setupDir); bool isBearish = IsBearish(setupDir); // int zIndex = 0; int cIndex = zIndex + 1; int pIndex = cIndex + 1; int ppIndex = pIndex + 1; // int loopback = 10; // double ask = GetAsk(symbol); double bid = GetBid(symbol); datetime cTime = TimeCurrent(); double points = GetPoints(symbol); // // Cycles Conditions ... result = provider.Prepare( zIndex, loopback // ); if (!result) { return result; } // double iAtr = provider.decisionXConditions.atrBuffer[1]; iAtr *= 1.5; // // Check Signal Validation ... // IMPORTANT: since all Validations done in SetUp Process ... // here we only Execute Signal ... // result = isBullish || isBearish; // if (result) { // conditions.triggerTime = cTime; conditions.type = isBullish ? X_POSITION_TYPE_LONG : X_POSITION_TYPE_SHORT; // } // // Cleanup ... // provider.Clean(); // return result; } /** * Detect Guards bsed on Signalling Class ... * * @param guards: X121SMCGuard instance Collection, Holds Provided Guards ... * @param positions: XPosition instance Collection, Provides Signalling Based Positions for Apply Guards on them ... * @param provider: X121SMCStrategySignalProviderData instance Reference, Specified Data for Cycles ... * * @return ( bool ) */ bool DetectGuards( X121SMCGuard &guards[], const XPosition &positions[], X121SMCStrategySignalProviderData &provider) { // bool result = false; // if (!useGuards) { return result; } // Clean(guards); // // Set Provider for Common Guards ... string signalProvider = ToString(X121SMC_XIND_PROVIDER_XTKKUMO); // int zIndex = 0; int cIndex = zIndex + 1; int pIndex = cIndex + 1; int ppIndex = pIndex + 1; // XOHCL cBar; // int loopback = 10; // double ask = GetAsk(symbol); double bid = GetBid(symbol); datetime cTime = TimeCurrent(); double points = GetPoints(symbol); // // Cycles Conditions ... result = provider.IsValid(); result = result && provider.Prepare( zIndex, loopback // ); if (!result) { // provider.Clean(); return result; } // // Select Own Positions ... int count = ArraySize(positions); result = IsValidSize(count); if (!result) { return result; } // XPosition ownPositions[]; XPosition ownLongPositions[]; XPosition ownShortPositions[]; for (int i = 0; i < count; i++) { // XPosition iPosition = positions[i]; bool isOwn = iPosition .IsFiltersPassed( symbol, signalProvider, NULL, X_POSITION_TYPE_ALL, iPosition.magic // ); if (isOwn) { // AddRef( iPosition, ownPositions // ); // bool isLong = IsLong(positions[i].type); if (isLong) { // AddRef( iPosition, ownLongPositions // ); } else { // AddRef( iPosition, ownShortPositions // ); } } } // // Check Extracted Positions ... // count = ArraySize(ownPositions); // int longsCount = ArraySize(ownLongPositions); bool hasLongs = IsValidSize(longsCount); // int shortsCount = ArraySize(ownShortPositions); bool hasShorts = IsValidSize(shortsCount); // // Validate Own Positions ... result = IsValidSize(count); if (!result) { // Clean(ownPositions); Clean(ownLongPositions); Clean(ownShortPositions); // return result; } // // // // // Get Global and Common Guards ... // // ENUM_X_121_SMC_GUARD_ACTIONS ignoreGuards[1] = { // X_121_SMC_GUARD_ACTION_TRAIL_STOP // // }; // result = DetectX121SMCGuards( // signalProvider, // guards, // positions, // provider, // // // ignoreGuards // // // ); // // // // // Implement Custom Implemented Guards ... // // Here we Are Sure there is Positions to Guard ... // based on Current Provider ... // // Selected Consolidation Zones ... // int idx = -1; bool has = false; // bool hasBullishConsolidationZone = false; XConsolidationZone bullishConsolidationZone; has = provider.decisionState.HasBullishConsolidationZones(); if (has) { // idx = GetYoungest(provider.decisionState.bullishConsolidationZones); hasBullishConsolidationZone = IsValidIndex(idx); if (hasBullishConsolidationZone) { bullishConsolidationZone = provider.decisionState.bullishConsolidationZones[idx]; } } // bool hasBearishConsolidationZone = false; XConsolidationZone bearishConsolidationZone; has = provider.decisionState.HasBearishConsolidationZones(); if (has) { // idx = GetYoungest(provider.decisionState.bearishConsolidationZones); hasBearishConsolidationZone = IsValidIndex(idx); if (hasBearishConsolidationZone) { bearishConsolidationZone = provider.decisionState.bearishConsolidationZones[idx]; } } // XBoxZone bullishBox; bool hasBullishBox = false; bool isBullishBoxBreaked = false; if (!hasBullishBox) { // XCOrderBlock *ob = NULL; idx = GetYoungest(provider.analyseState.bullishOrderBlocks); has = IsValidIndex(idx); if (has) { // ob = provider.analyseState.bullishOrderBlocks[idx]; // hasBullishBox = ToBox( bullishBox, ob // ); } // if (!hasBullishBox) { bullishBox.Clean(); } // ZeroMemory(ob); } // XBoxZone bearishBox; bool hasBearishBox = false; bool isBearishBoxBreaked = false; if (!hasBearishBox) { // XCOrderBlock *ob = NULL; idx = GetYoungest(provider.analyseState.bearishOrderBlocks); has = IsValidIndex(idx); if (has) { // ob = provider.analyseState.bearishOrderBlocks[idx]; // hasBearishBox = ToBox( bearishBox, ob // ); } // if (!hasBearishBox) { bearishBox.Clean(); } // ZeroMemory(ob); } // // Here We Have all Requirements for Guarding Positions ... // // Available Guards: // X_121_SMC_GUARD_ACTION_NONE // X_121_SMC_GUARD_ACTION_CLOSE // X_121_SMC_GUARD_ACTION_CLOSE_ALL // X_121_SMC_GUARD_ACTION_CLOSE_LONGS // X_121_SMC_GUARD_ACTION_CLOSE_SHORTS // X_121_SMC_GUARD_ACTION_PARTIAL_CLOSE // X_121_SMC_GUARD_ACTION_TRAIL_STOP // X_121_SMC_GUARD_ACTION_TRAIL_TARGET // X_121_SMC_GUARD_ACTION_HEDGE // // X_121_SMC_GUARD_ACTION_CLOSE: // Close Specified Position on Specified Conditions ... // // X_121_SMC_GUARD_ACTION_CLOSE_ALL: // Close All Positions on Specified Conditions ... // // X_121_SMC_GUARD_ACTION_CLOSE_LONGS: // Close All Long Positions on Specified Conditions ... // // X_121_SMC_GUARD_ACTION_CLOSE_SHORTS: // Close All Short Positions on Specified Conditions ... // // X_121_SMC_GUARD_ACTION_PARTIAL_CLOSE: // Partial Close Specified Position on Specified Conditions ... // // X_121_SMC_GUARD_ACTION_TRAIL_STOP: // Trail Stop Specified Position on Specified Conditions ... bool handleStoptrailingBasedOnBoxes = true; bool handleStoptrailingBasedOnConsolidationZones = true; for (int i = 0; i < count; i++) { // XPosition iPosition = ownPositions[i]; // bool isInited = cBar.Init( iPosition.symbol, iPosition.period, cIndex // ); // isBullishBoxBreaked = isInited && hasBullishBox && cBar.high < bullishBox.lower; // isBearishBoxBreaked = isInited && hasBearishBox && cBar.low > bearishBox.upper; // bool isLong = IsLong(iPosition.type); bool isInProfit = iPosition.profit > 0; // double sl = iPosition.sl; double tp = iPosition.tp; // // Trail Stops Using Consolidation Zones ... // bool canTraiLonglUsingCZone = // handleStoptrailingBasedOnConsolidationZones && // (isLong && isInProfit && hasBullishConsolidationZone && bullishConsolidationZone.lower > iPosition.sl && bullishConsolidationZone.lower > iPosition.entry) // ; if (canTraiLonglUsingCZone) { sl = bullishConsolidationZone.lower; } // bool canTraiShortlUsingCZone = // handleStoptrailingBasedOnConsolidationZones && // (!isLong && isInProfit && hasBearishConsolidationZone && bearishConsolidationZone.upper < iPosition.sl && bearishConsolidationZone.upper < iPosition.entry) // ; if (canTraiShortlUsingCZone) { sl = bearishConsolidationZone.upper; } // bool canTrailUsingCZone = canTraiLonglUsingCZone || canTraiShortlUsingCZone; // // Trail Stop Using Boxes ... // bool canTraiLonglUsingBox = // handleStoptrailingBasedOnBoxes && // (isLong && isInProfit && hasBullishBox && bullishBox.lower > iPosition.sl && bullishBox.lower > iPosition.entry) // ; if (canTraiLonglUsingBox) { sl = bullishBox.lower; } // bool canTraiShortlUsingBox = // handleStoptrailingBasedOnBoxes && // (!isLong && isInProfit && hasBearishBox && bearishBox.upper < iPosition.sl && bearishBox.upper < iPosition.entry) // ; if (canTraiShortlUsingBox) { sl = bearishBox.upper; } // bool canTrailUsingBox = canTraiLonglUsingBox || canTraiShortlUsingBox; // bool canTraiLonglUsingBreakedBox = // handleStoptrailingBasedOnBoxes && // (isLong && isInProfit && isBearishBoxBreaked && bearishBox.upper > iPosition.sl && bearishBox.upper > iPosition.entry) // ; if (canTraiLonglUsingBreakedBox) { sl = bearishBox.upper; } // bool canTraiShortlUsingBreakedBox = // handleStoptrailingBasedOnBoxes && // (!isLong && isInProfit && isBullishBoxBreaked && bullishBox.lower < iPosition.sl && bullishBox.lower < iPosition.entry) // ; if (canTraiShortlUsingBreakedBox) { sl = bullishBox.lower; } // bool canTrailUsingBreakedBox = canTraiLonglUsingBreakedBox || canTraiShortlUsingBreakedBox; // // Summarize SL ... // bool isSLPassed = sl > 0 && (isLong ? iPosition.price - sl >= points * 15 : sl - iPosition.price >= points * 15); // bool canTrail = isSLPassed && (canTrailUsingBox || canTrailUsingCZone || canTrailUsingBreakedBox); if (canTrail) { // X121SMCGuard iGuard; // iGuard.time = cTime; iGuard.symbol = symbol; iGuard.provider = signalProvider; iGuard.action = X_121_SMC_GUARD_ACTION_TRAIL_STOP; // iGuard.ticket = iPosition.ticket; // iGuard.sl = sl; // AddGuard( iGuard, guards // ); } } // // X_121_SMC_GUARD_ACTION_TRAIL_TARGET: // Trail Target Specified Position on Specified Conditions ... // // X_121_SMC_GUARD_ACTION_HEDGE: // Hedge all Positions on Specified Conditions ... // // Cleanup Collections ... // cBar.Clean(); // provider.Clean(); // bullishBox.Clean(); bearishBox.Clean(); // bullishConsolidationZone.Clean(); bearishConsolidationZone.Clean(); // count = ArraySize(guards); result = IsValidSize(count); // return result; } /** * Detect and Manage Important Zones and Categorized them for Signalling Clss ... * * @param cycle: ENUM_X_CYCLES member, Specified Source Cycle for Detecting ... * @param provider: X121SMCStrategySignalProviderData instance Reference, Specified Data for Cycles ... * * @return ( int ) */ int UpdateWaitingBoxes( ENUM_X_CYCLES cycle, ENUM_X_CYCLES vCycle, X121SMCStrategySignalProviderData &provider, int maxAllowedAge = 0 // ) { // int result = ArraySize(mWaitingBoxes) + ArraySize(mActivatedBoxes); // int count = 0; bool has = false; // // Fil Selected Data ... XPOIState cState; X121Conditions cXConditions; XPOIStateEvents cStateEvents; XC121SMCCycleHelper *cHelper; X121SMCCycleConditions cConditions; has = provider.SelectCycle( cycle, cState, cStateEvents, cXConditions, cHelper, cConditions // ); if (!has) { // cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); cStateEvents.Clean(); // return result; } // // Detecting New Boxes ... // // At First Try Check All Exists FVGs // then Only Check Youngest FVG ... if (!isPassedBoxes) { // XBoxZone tmpBoxes[]; count = cState.FairValueGapsAsBox(tmpBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { // XBoxZone iBox = tmpBoxes[i]; // // Regular Validation of Boxes ... bool isValid = IsBoxValid( iBox, 0, iBox.period // ); if (!isValid) { // iBox.Clean(); continue; } // // Conditional Validation of FVG Boxes ... isValid = IsFVGBoxValid( iBox, vCycle, provider // ); if (!isValid) { // iBox.Clean(); continue; } // has = IsBoxExists(iBox); if (!has) { // AddRef( iBox, mWaitingBoxes // ); } // iBox.Clean(); } } Clean(tmpBoxes); // isPassedBoxes = true; } else { // XBoxZone iBox; has = cStateEvents.hasNewFairValueGap; if (has) { // int idx = GetYoungest(cState.fairValueGaps); has = IsValidIndex(idx); if (has) { // has = ToBox( iBox, cState.fairValueGaps[idx] // ); if (has) { // // Regular Validation of Boxes ... bool isValid = IsBoxValid( iBox, 0, iBox.period // ); if (isValid) { // // Conditional Validation of FVG Boxes ... isValid = IsFVGBoxValid( iBox, vCycle, provider // ); if (isValid) { // has = IsBoxExists(iBox); if (!has) { // AddRef( iBox, mWaitingBoxes // ); } } } } } } // iBox.Clean(); } // // Update Times ... datetime requireTime = GetBarTime( cState.symbol, cState.period, 1 // ); // count = ArraySize(mWaitingBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { mWaitingBoxes[i].to = requireTime; } } // count = ArraySize(mActivatedBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { mActivatedBoxes[i].to = requireTime; } } // // Validate Exists Boxes ... // // Waiting Boxes ... count = ArraySize(mWaitingBoxes); has = IsValidSize(count); if (has) { // int mustRemove[]; for (int i = 0; i < count; i++) { // XBoxZone iBox = mWaitingBoxes[i]; // // Check Box Validation ... bool isValid = IsBoxValid( iBox, 0, iBox.period // ); // // Check Box Breaked ... bool isBreaked = IsBoxBreaked( iBox, 0, iBox.period // ); // // Checking Box Age ... int age = iBox.GetAge(); bool isAgeBreaked = maxAllowedAge > 0 && age > maxAllowedAge; if (isAgeBreaked) { // Add( i, mustRemove // ); // AddRef( iBox, mUnAvailableBoxes // ); // iBox.Clean(); continue; } // // Box Waiting ... if (isValid) { // iBox.Clean(); continue; } // // Box Breaked ... if (isBreaked) { // Add( i, mustRemove // ); // AddRef( iBox, mBreakedBoxes // ); // iBox.Clean(); continue; } // // Box Activated ... if (!isValid) { // Add( i, mustRemove // ); // AddRef( iBox, mActivatedBoxes // ); // iBox.Clean(); continue; } // iBox.Clean(); } // CleanupArray( mustRemove, mWaitingBoxes // ); } // // Activated Boxes ... count = ArraySize(mActivatedBoxes); has = IsValidSize(count); if (has) { // int mustRemove[]; for (int i = 0; i < count; i++) { // XBoxZone iBox = mActivatedBoxes[i]; // // Checking Box Age ... int age = iBox.GetAge(); bool isAgeBreaked = maxAllowedAge > 0 && age > maxAllowedAge; if (isAgeBreaked) { // Add( i, mustRemove // ); // AddRef( iBox, mUnAvailableBoxes // ); // iBox.Clean(); continue; } // // Check Breaked ... bool isBreaked = IsBoxBreaked( iBox, 0, iBox.period // ); if (isBreaked) { // Add( i, mustRemove // ); // AddRef( iBox, mBreakedBoxes // ); // iBox.Clean(); continue; } // iBox.Clean(); } // CleanupArray( mustRemove, mActivatedBoxes // ); } // // Cleanup Resources ... // cState.Clean(); ZeroMemory(cHelper); cConditions.Clean(); cXConditions.Clean(); cStateEvents.Clean(); // result = ArraySize(mWaitingBoxes) + ArraySize(mActivatedBoxes); // return result; } /** * Make a Detected Signal Box UnAvailable for Prevent of Double Executing ... * * @param box: XBoxZone instance Reference, Specified Signal Box ... */ void MakeSignalBoxUnAvailable( XBoxZone &box // ) { // int idx = -1; int count = 0; bool has = false; // // Validate Box ... has = box.IsValid(); if (!has) { return; } // // Check Waiting Boxes ... count = ArraySize(mWaitingBoxes); has = IsValidSize(count); if (has) { // has = FindBoxIndex( idx, box, mWaitingBoxes // ); if (has) { // // Remove Signal Box From Collection ... ArrayRemove( mWaitingBoxes, idx, 1 // ); // // Add Signal Box to UnAvailable Boxes ... AddRef( box, mUnAvailableBoxes // ); // return; } } // // Check Activated Boxes ... count = ArraySize(mActivatedBoxes); has = IsValidSize(count); if (has) { // has = FindBoxIndex( idx, box, mActivatedBoxes // ); if (has) { // // Remove Signal Box From Collection ... ArrayRemove( mActivatedBoxes, idx, 1 // ); // // Add Signal Box to UnAvailable Boxes ... AddRef( box, mUnAvailableBoxes // ); // return; } } // // Check Breaked Boxes ... count = ArraySize(mBreakedBoxes); has = IsValidSize(count); if (has) { // has = FindBoxIndex( idx, box, mBreakedBoxes // ); if (has) { // // Remove Signal Box From Collection ... ArrayRemove( mBreakedBoxes, idx, 1 // ); // // Add Signal Box to UnAvailable Boxes ... AddRef( box, mUnAvailableBoxes // ); // return; } } } /** * Check a Box is Exists in Box Collections of Signalling Collections ... * * @param box: XBoxZone instance Reference, Specified Box to Check ... * * @return ( bool ) */ bool IsBoxExists(XBoxZone &box) { // bool result = false; // int idx = -1; int count = 0; bool has = false; // // Witing Boxes ... count = ArraySize(mWaitingBoxes); has = IsValidSize(count); if (has) { // has = FindBoxIndex( idx, box, mWaitingBoxes // ); result = has; if (result) { return result; } } // // Activated Boxes ... count = ArraySize(mActivatedBoxes); has = IsValidSize(count); if (has) { // has = FindBoxIndex( idx, box, mActivatedBoxes // ); result = has; if (result) { return result; } } // // Breaked Boxes ... count = ArraySize(mBreakedBoxes); has = IsValidSize(count); if (has) { // has = FindBoxIndex( idx, box, mBreakedBoxes // ); result = has; if (result) { return result; } } // // UnAvailable Boxes ... count = ArraySize(mUnAvailableBoxes); has = IsValidSize(count); if (has) { // has = FindBoxIndex( idx, box, mUnAvailableBoxes // ); result = has; if (result) { return result; } } // return result; } /** * Add Conditions to Conditions Collection if not Exists ... * * @param maxAllowed: int, Specified Max Allowed Holding Conditions ... * * @return ( int ) */ int AddConditionsIfNotExists( int maxAllowed = 10 // ) { // int result = 0; // bool isSetuped = IsValid(mConditions.setupTime) && HasDirection(mConditions.dir); if (!isSetuped) { return result; } // int count = ArraySize(mConditionsCollection); if (IsValidSize(count)) { // // Copy Original Items ... X121SMCStrategyXINDSignalConditions tmpItems[]; Copy( mConditionsCollection, tmpItems // ); // // Prese Item Data ... bool isBullish = IsBullish(mConditions.dir); // for (int i = 0; i < count; i++) { // X121SMCStrategyXINDSignalConditions iItem = tmpItems[i]; // bool canRemove = mConditions.dir == iItem.dir && mConditions.pivot == iItem.pivot; if (canRemove) { // ArrayRemove( mConditionsCollection, i, 1 // ); } } // Clean(tmpItems); } // AddRef( mConditions, mConditionsCollection // ); // // Remove Olds ... CleanupArray( mConditionsCollection, maxAllowed // ); // result = ArraySize(mConditionsCollection); // return result; } // // Draw Functions ... /** * Draw Specified Bar on Chart ... * * @param bar: XOHCL instance Reference, Specified Bar ... * @param forceClean: force Clean Drawn Objects ... */ void DrawBar( XOHCL &bar, XCPOIDrawer *drawer, bool forceClean = true // ) { // if (forceClean) { mBarObjects.Clear(); } // if (drawer == NULL || !bar.IsValid()) { return; } // bool isBullish = bar.IsBullish(); // int widthBar = 2; bool fillShadowsBar = true; ENUM_LINE_STYLE styleBar = STYLE_SOLID; color clrBar = isBullish ? clrAqua : clrMagenta; // datetime to = bar.NextAt(); // XCOHCLObject *iObj; bool isCreated = drawer .CreateBar( bar, iObj, to // ); if (isCreated) { // iObj.BarSpes( widthBar, clrBar, styleBar // ); // iObj.LowShadowFill(fillShadowsBar); iObj.HighShadowFill(fillShadowsBar); // mBarObjects.Add(iObj); } } /** * Draw Boxes of Signallings on Chart ... * * @param forceClean: force Clean Drawn Objects ... */ void DrawBoxes( XCPOIDrawer *drawer, bool forceClean = false // ) { // if (forceClean) { mObjects.Clear(); } // int count = 0; bool has = false; // // Waiting Boxes ... count = ArraySize(mWaitingBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { // XCBoxObject *iObj; has = drawer.DrawBox( mWaitingBoxes[i], iObj // ); if (has) { mObjects.Add(iObj); } } } // // Activated Boxes ... count = ArraySize(mActivatedBoxes); has = IsValidSize(count); if (has) { // for (int i = 0; i < count; i++) { // XCBoxObject *iObj; has = drawer.DrawBox( mActivatedBoxes[i], iObj // ); if (has) { // if (mActivatedBoxes[i].IsBullish()) { iObj.BoxColor(clrYellow); } else { iObj.BoxColor(clrOrange); } // mObjects.Add(iObj); } } } } // protected: // // private: // // Props ... string symbol; ENUM_TIMEFRAMES period; CArrayObj mObjects; CArrayObj mBarObjects; /** * Initialize ... */ void Init() { // rfReward = 2; useGuards = false; isPassedBoxes = false; continuesRFTillTarget = true; } /** * DeInitialize ... */ void DeInit() { // mConditions.Clean(); Clean(mConditionsCollection); // mObjects.Clear(); mBarObjects.Clear(); } // }; //