/////////////////////////////////////////////////////// // // SaherElm IT Center XCATB MQL5 Expert Advisor // ------------------------------------------------- // Name: XCAEA // Description: an Exper Advisor which used XCATB // // 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 "EA based on X121 XCATB indicator" #property strict // // Include Common Library ... #include "../Classes/x-saherelm.x-alert.class.mq5" #include "../Classes/x-saherelm.x-bar.analyser.class.mq5" #include "../Classes/x-saherelm.x-poi.drawer.class.mq5" #include "../Classes/x-saherelm.x-trade.class.mq5" #include "../Classes/x-saherelm.x-volume.class.mq5" #include "../Helpers/x-saherelm.x121.xcatb.helper.mq5" #include "../XCATBEA/Classes/xcatbea.signaller.class.mq5" #include "../XCATBEA/Classes/xcatbea.x-trade.manager.class.mq5" #include "../XCATBEA/Libraries/xcatbea.signaller.lib.mq5" // #define ShortName "XCATBEA" // // Inputs ... // // Common ... input group "Common"; input long eaMagicNumber = 1694056; // Magic Number input int eaSlippage = 10; // Slippgae input string eaLogSuffix = ""; // Log Suffix // // Detector ... input group "Detector"; // // Validating ... input group "Validations"; input bool eaForceHasSwing = false; // Force Block to Has Propper Swing input bool eaForceOBBarType = false; // Force Order Block to Has InDirectional Bars input int eaMinRequiredOBBar = 0; // Min Required OB Bar input bool eaForceFVGBarType = false; // Force Fair Value Gaps Bars Type input int eaLiquidityLoopback = 0; // Liquidity Detection Loopback input double eaMaxAllowedRange = 0.0; // Max Allowed Order Block Range input double eaMinAllowedRange = 0.0; // Min Allowed Order Block Range input bool eaForceHasFLiquidity = false; // Force Order Block To Has Reversal Liquidity input bool eaForceHasRLiquidity = false; // Force Order Block to Has Following Liquidity input bool eaValidateGapSequence = false; // Validate Fair Value Gaps Bar Sequences input int eaMinAllowedBlockLength = 0; // Min Allowed Block Length input bool eaValidateBlockEdgeBreakout = false; // Validate Order Block Edge Breakeout // // Filtering ... input group "Filters"; input bool eaFilterBasedOnPV = false; // Filter Based On PV input int eaBosLoopback = 0; // PV Based Filtering BOS Lookup input bool eaFilterBasedOnSar = false; // Filter Based On SAR input bool eaForceSarSwitched = false; // SAR Switched on Sides for Filtering input bool eaForceSarOnBothSide = false; // SAR Check on Both Sides for Filtering input bool eaForceSarHasBreakout = false; // SAR Must Breakout input bool eaForceSarHasReversalSide = false; // SAR Must Has Reversal Direction input bool eaFilterBasedOnRSI = false; // Filter Based On RSI input bool eaForceHasRSITrending = false; // RSI Must Has Trending input bool eaForceHasRSIVPattern = false; // RSI Must Has Pattern input bool eaForceHasRSICrossing = false; // RSI Must Has Crossing Levels input bool eaFilterBasedOnADX = false; // Filter Based On ADX input bool eaForceHasADXTrending = false; // ADX Must Has Trending input bool eaForceHasADXCrossing = false; // ADX Must Has Crossing +DI/-DI input bool eaFilterBasedOnATR = false; // Filter Based On ATR input bool eaForceHasATRTrending = false; // ATR Must Has Trending input bool eaForceHasATRBreakout = false; // ATR Must Has Breakout input bool eaFilterBasedOnTrend = false; // Filter Based On Trend input bool eaForceHasTrendDir = false; // TREND Must Has Following Direction input bool eaForceHasTrendPlace = false; // TREND Place Based Filtering input bool eaForceHasTrendChange = false; // TREND Change Filtering input bool eaForceHasTrendTrending = false; // TREND Must Has Trending input bool eaForceHasTrendRejection = false; // TREND Line Must Rejected input bool eaForceHasTrendLineInside = false; // TREND Line has Inside input bool eaForceHasTrendDirOnBothSide = false; // TREND Must Has Following Direction in Both Side input bool eaFilterBasedOnDelta = false; // Filter Based On Delta input bool eaFilterBasedOnVolume = false; // Filter Based On Volume input bool eaFilterBasedOnSignalBar = false; // Filter Based on Signal Bar input bool eaFilterBasedOnHKSignalBar = false; // Filter Based On HK Signal Bar // // Signal ... input group "Signal"; input int eaSignalR2R = 2; // Risk Reward Ratio input double eaSLAtrMultiplier = 0; // ATR Multiplier for SL // // Volume ... input group "Volume"; input ENUM_X_VOLUME_SELECT_TYPE eaVolumeSelect = X_VOLUME_EQUITY; // Volume Applying Type input double eaStaticVoluem = 0.0; // Static Volume input double eaDynamicVolumeStepBalance = 0.0; // Step of Balance for Increase Volume input double eaDynamicVolumeStepVolume = X_MIN_VOLUME; // Step of Volume Increasing input double eaConstantRiskBalance = 0.0; // Constant Risk Balance per Trade input double eaConstantPercent = 0.5; // Constant Percent of Balance Per Trade input double eaConstantBalance = 0.0; // Constant Balance for Calculations // // Management ... // eaSessions => (SYDNEY_02:00_14:00),(NY_19:00_23:00) input group "Management"; input bool eaAllowTrade = true; // Allow Trade on Signals input bool eaAllowLongs = true; // Allow Long Trades input bool eaAllowShorts = true; // Allow Short Trades input string eaSessions = ""; // Active Sessions input ENUM_XCATBEA_TRADE_RESTRICTION_PERIOD eaRestrictionsPeriod = XCATBEA_TRADE_RESTRICATION_NONE; // Restrictions Period input int eaMaxAllowedTPs = 0; // Max Allowed TP(s) in Restrictions Period input int eaMaxAllowedSLs = 0; // Max Allowed SL(s) in Restrictions Period input int eaMaxAllowedTrades = 0; // Max Allowed Trades in Restrictions Period input int eaMaxAllowedPositions = 5; // Max Allowed Same Time Trades input double eaMaxAllowedSpread = 25; // Max Allowed Spread For Trade input double eaMaxAllowedDrawdownFactor = 0.3; // Max Allowed DrawDown for Trade input string eaCloseAllOpenTradesAt = ""; // Close All Open Trades per Day At Specified Time // // Alert ... // Here we Provider All Requirements for // Configuring Alert Provider ... input group "Alert"; input bool eaEnableAlerts = true; // Enable Alerts input bool eaLogAlerts = true; // Log Alerts input bool eaMailAlerts = false; // Mail Alerts input bool eaPushAlerts = true; // Push Alerts input bool eaTerminalAlerts = false; // Terminal Alerts // // Time Report ... input group "Reports"; input bool eaReportNewMonths = false; // Report New Month input bool eaReportNewWeeks = false; // Report New Weeks input bool eaReportNewDays = true; // Report New Days input bool eaReportNewHours = false; // Report New Hours input bool eaReportTrades = true; // Report Trades input bool eaReportSignals = true; // Report Signals input bool eaReportProtector = true; // Report Protector Actions input bool eaReportAfterTradesBalance = true; // Report Balance after a Trade Finished // // Collector ... input group "Collector"; input bool eaSaveTrades = false; // Save Trades input bool eaSaveSignals = false; // Save Signals input bool eaSaveWins = false; // Save Winning Conditions input bool eaSaveLosts = false; // Save Lost Conditions // // Variables ... // XCAlert *eaAlert; XCTrade *eaTrade; string eaTag = ""; XCVolume *eaVolume; XTimeTracker eaTimeTracker; XCXCATBEASignaller *eaSignallers[]; XCXCATBEATradeManager *eaTradeManager; // // Event Handlers ... // // Initialization ... int OnInit() { // // Validate Inputs and Required Parameters // for EA to Works fine ... if (!ValidateInputs()) { return INIT_PARAMETERS_INCORRECT; } // // Initial Requirements ... InitRequirements(); // // Initialize Volume Manger ... if (!InitVolume()) { return INIT_FAILED; } // return (INIT_SUCCEEDED); } // // DeInitialization ... 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 // delete eaAlert; ZeroMemory(eaAlert); // delete eaTrade; ZeroMemory(eaTrade); // delete eaVolume; ZeroMemory(eaVolume); // eaTimeTracker.Clean(); // DestroyTimer(); } // // On Tick Handler ... void OnTick() { // // Time Report Handling ... HandleTimeReport(); // // Position Management / Protections Handling ... eaTradeManager.Manage(); // // Count Signallers ... bool has = HasChild(eaSignallers); if (!has) { return; } // XGuard guards[]; XCATBEAStrategyConditions conditions[]; // int count = ArraySize(eaSignallers); for (int i = 0; i < count; i++) { // // Retrieve indexed Signaller ... XCXCATBEASignaller *iSignaller = eaSignallers[i]; // string iSymbol = iSignaller.GetSymbol(); string iProvider = iSignaller.GetProvider(); ENUM_TIMEFRAMES iPeriod = iSignaller.GetPeriod(); // // Now we Have to Check Handle Tick Resoult ... // // Requirements ... XGuard iGuards[]; // Hold Provided Guards ... XPosition iPositions[]; // Retrieve Signaller Positions ... XCATBEAStrategyConditions iConditions; // Recieve Triggered Conditions ... // // Reading Signaller Positions ... eaTradeManager.GetPositions( iPositions, iSymbol, iProvider, iPeriod // ); // // Processing Tick for Signaller ... iSignaller.ProcessTick( iPositions, iGuards, iConditions // ); // // Check Results ... has = HasChild(iGuards); if (has) { // Copy( iGuards, guards, false // Force Clean ... ); } // // Check Triggered Conditions ... has = iConditions.IsValid() && iConditions.IsSetuped() && iConditions.CanTrigger(); if (has) { // AddRef( iConditions, conditions // ); } // // Cleanup Resources ... Clean(iGuards); Clean(iPositions); iConditions.Clean(); } // // Do Actions Based on Provided Info ... // // Guards ... has = HasChild(guards); if (has) { // // Handle Guards Firing ... } // // Triggers ... has = HasChild(conditions); if (has) { // // Handle Conditions Triggering ... } // // Cleanup Resources ... // Clean(guards); Clean(conditions); // // // eaTB.Clean(); // eaSignal.Clean(); // eaConditions.Clean(); // eaCatbConditions.Clean(); // // // bool has = false; // int barIndex = 0; // int cBarIndex = 0; // // // // Check Bar Processing ... // if (!eaBarTraker.CanProcessBar()) // { // return; // } // // // eaHelper.Check(barIndex); // // // // Reading Required Bars ... // XOHCL zBar; // XOHCL cBar; // has = zBar.Init( // _Symbol, // _Period, // barIndex // // ); // has = // has && // zBar.GetPreviousBar(cBar); // if (!has) // { // // // zBar.Clean(); // cBar.Clean(); // // // return; // } // // // cBarIndex = barIndex + 1; // // // // Update All Required Buffers ... // eaHelper.Update(cBarIndex); // // // // Check Trigger Block Detected or Not ... // if (tradeUsingTriggerBlock) // { // // // // Trigger Block Detection ... // has = DetectTriggerBlock1( // eaHelper, // eaBarAnalyser, // eaTB, // eaCatbConditions, // eaValidations, // eaFilters, // barIndex, // 10 // Loopback ... // ); // // // if (has) // { // // // // Wait for Next Bar for anything ... // eaBarTraker.Waits(); // // // // Prepare Target ... // double targets[]; // for (int i = 1; i <= eaSignalR2R; i++) // { // // // Add( // (double)i, // targets // // ); // } // // // // Calculate SL Additions ... // double iATR = 0; // if (barIndex > 0 && // barIndex < ArraySize(eaHelper.atrBuffer)) // { // iATR = eaHelper.atrBuffer[barIndex]; // } // double slAdditional = eaSLAtrMultiplier * iATR; // // // // Preparing Signal ... // has = ToSignal( // eaTB.trigger, // eaTB.signal, // targets, // slAdditional // // ); // // // // Draw Trigger Block ... // DrawTriggerBlock( // eaTB, // eaDrawer, // eaObjects, // NULL // // ); // // // // Attach Signal ... // eaSignal = eaTB.signal; // // // // Check Signal Type ... // bool isLong = IsLong(eaSignal.type); // // // // Update Entry ... // eaSignal.entry = GetEntry( // eaSignal.symbol, // eaSignal.type // // ); // // // // Update Signal Targets ... // UpdateSignalTargets(eaSignal); // // // // Handle Volume Management ... // double iVolume = eaVolume.CalculateVolume(eaSignal); // if (iVolume > X_MIN_VOLUME && // iVolume != eaSignal.volume) // { // eaSignal.volume = iVolume; // } // // // eaConditions.sl = eaSignal.sl; // eaConditions.tp = eaSignal.tp; // eaConditions.pivot = eaSignal.sl; // eaConditions.time = eaSignal.time; // eaConditions.reward = eaSignalR2R; // eaConditions.point = eaSignal.entry; // eaConditions.entry = eaSignal.entry; // eaConditions.symbol = eaSignal.symbol; // eaConditions.period = eaSignal.period; // eaConditions.setupTime = eaSignal.time; // eaConditions.triggerTime = eaSignal.time; // eaConditions.decisionZone = eaTB.trigger; // eaConditions.provider = eaSignal.provider; // eaConditions.conditions = eaCatbConditions; // eaConditions.type = ToPositionType(eaSignal.type); // eaConditions.dir = // isLong // ? X_DIRECTION_BULLISH // : X_DIRECTION_BEARISH; // Copy( // eaSignal.targets, // eaConditions.targets // // ); // eaSignal.conditions = // eaCatbConditions // .GenerateSummary( // false, // Commons ... // true, // Conditions ... // true, // Scores ... // false // Ignore Falses ... // ); // // // // Execute Signal ... // has = eaTradeManager.Execute( // eaSignal, // eaConditions // // ); // } // // // eaTB.Clean(); // } // // // // Trade Using Market Conditions ... // if (tradeUsingMarketConditions1) // { // // // XBoxZone signalZone; // X121XCatbConditions conditions; // has = DetectSignalZone( // eaDrawer, // eaHelper, // eaBarAnalyser, // signalZone, // conditions, // barIndex // // ); // if (has) // { // // // // Convert Box to Signal ... // } // } // // // // Cleanup Resources ... // // // zBar.Clean(); // cBar.Clean(); // eaTB.Clean(); // eaSignal.Clean(); // eaConditions.Clean(); // eaCatbConditions.Clean(); } // // Handle On Trade Event ... void OnTrade() { eaTrade.HandleOnTrade(); } // // On Timer ... void OnTimer() { } // // Chart Event Handler ... void OnChartEvent( const int id, const long &lparam, const double &dparam, const string &sparam // ) { } // // Event Listeners ... /** * Handle StopLoss Triggered Positions ... * * @param deal: XDeal instance ... */ void OnStopLossTriggered(const XDeal &deal) { eaTradeManager.HandleSL(deal); } /** * Handle Take Profit Triggered Positions ... * * @param deal: XDeal instance ... */ void OnTakeProfitTriggered(const XDeal &deal) { eaTradeManager.HandleTP(deal); } /** * Handle Force Close a Position ... * * @param ticket: ULONG ... * @param position: XPosition instance ... * @param comment: string ... */ void OnPositionForceClosed( const ulong ticket, const XPosition &position, const string comment // ) { eaTradeManager.HandleForceClose(position); } /** * Handle Position Partially Closed Event ... * * @param ticket: ULONG ... * @param profit: double ... * @param comment: string ... */ void OnPositionPartiallyClosed( const ulong ticket, const double profit, const string comment // ) { eaTradeManager.HandlePartiallyClosed( ticket, profit, comment // ); } /** * Handle Deals Changes ... * * @param count: Integer, Number of Changes ... */ void OnDealsChanged(int count) { } /** * Handle Orders Changes ... * * @param count: Integer, Number of Changes ... */ void OnOrdersChanged(int count) { } /** * Handle Positions Changes ... * * @param count: Integer, Number of Changes ... */ void OnPositionsChanged(int count) { } // // Custom Functions ... /** * Validate all Inputs of Expert Adviser ... * * @return ( bool ) */ bool ValidateInputs() { // bool result = false; // string errMessage = ""; // bool isCommonValid = ( // eaSlippage > 0 && eaMagicNumber > 0 // ); if (!isCommonValid) { // errMessage += "common configurations error;" + "\n"; } // result = // // Common ... isCommonValid && // // Otere ... true // ; // if (!result) { // // Since here Logger not Initiallized, we Use Raw Print Command ... Print(ShortName + " Errors: \n", errMessage); } // return result; } /** * Initialize Timer ... * * @return ( bool ) */ bool InitTimer() { // bool result = false; // // TODO: Initialize Timer if necessary ... // result = EventSetTimer(1); // result = EventSetMillisecondTimer(100); result = true; // return result; } /** * Destroy Timer ... */ void DestroyTimer() { // // TODO: Use This ... // EventKillTimer(); } /** * Initial Volume Manager Class Based on Given Configuration ... * * @return ( bool ) */ bool InitVolume() { // bool result = false; // eaVolume = new XCVolume(); // result = eaVolume.Init( eaVolumeSelect, eaStaticVoluem, eaDynamicVolumeStepBalance, eaDynamicVolumeStepVolume, eaConstantRiskBalance, eaConstantPercent, eaConstantBalance // ); // return result; } /** * Initial Requirements of EA ... */ void InitRequirements() { // // Preparing Tags ... eaTag = (IsValid(eaLogSuffix) ? eaLogSuffix + "_" : "") + ShortName; // eaAlert = new XCAlert(); eaAlert.SetPrefix(eaLogSuffix); eaAlert.SetLogAlerts(eaLogAlerts); eaAlert.SetMailAlerts(eaMailAlerts); eaAlert.SetPushAlerts(eaPushAlerts); eaAlert.SetEnableAlerts(eaEnableAlerts); eaAlert.SetTerminalAlerts(eaTerminalAlerts); // // EA Trade ... eaTrade = new XCTrade( eaSlippage, eaMagicNumber, eaMaxAllowedSpread, eaMaxAllowedPositions, eaMaxAllowedDrawdownFactor // ); eaTrade.AddOnStopLossEventHandler(OnStopLossTriggered); eaTrade.AddOnTakeProfitEventHandler(OnTakeProfitTriggered); eaTrade.AddOnForceClosePositionEventHandler(OnPositionForceClosed); eaTrade.AddOnPartialClosePositionEventHandler(OnPositionPartiallyClosed); // // EA Trae Manager ... eaTradeManager = new XCXCATBEATradeManager( eaTrade // ); // eaTradeManager.SetAlertPrefix(eaTag); eaTradeManager.SetAlertLogAlerts(eaLogAlerts); eaTradeManager.SetAlertMailAlerts(eaMailAlerts); eaTradeManager.SetAlertPushAlerts(eaPushAlerts); eaTradeManager.SetAlertEnableAlerts(eaEnableAlerts); eaTradeManager.SetAlertTerminalAlerts(eaTerminalAlerts); // eaTradeManager.SaveWins(eaSaveWins); eaTradeManager.SaveLosts(eaSaveLosts); eaTradeManager.SaveTrades(eaSaveTrades); eaTradeManager.SaveSignals(eaSaveSignals); // // Setting Trade Reports ... eaTradeManager .SetTradeReports( eaReportTrades, eaReportSignals, eaReportProtector, eaReportAfterTradesBalance // ); // // Setting Trade Permissions ... eaTradeManager .SetTradePermissions( eaAllowTrade, eaAllowLongs, eaAllowShorts // ); // // Setting Trade Restrictions ... eaTradeManager .SetTradeRestrictions( eaRestrictionsPeriod, eaMaxAllowedTPs, eaMaxAllowedSLs, eaMaxAllowedTrades // ); // // Initializing Sessions ... string sessions[]; int sessionsCount = 0; bool hasSession = IsValid(eaSessions); if (hasSession) { // // Extract Per Symbol Sessions ... sessionsCount = SplitContent( sessions, eaSessions, "," // ); // // Try to Extract Start and End Times Series ... hasSession = IsValidSize(sessionsCount); if (hasSession) { // // Iterate Sessions ... for (int i = 0; i < sessionsCount; i++) { // // Ignore unused Cases and Extracts only Content ... string iSessionDescriptorStr = ExtractString(sessions[i]); bool isInited = IsValid(iSessionDescriptorStr); if (isInited) { // // Extract Session Descriptor Data ... string parts[]; int partsCount = SplitContent( parts, iSessionDescriptorStr, "_" // ); isInited = IsValidSize(partsCount) && partsCount == 3; if (isInited) { // string iName = parts[0]; string iStart = parts[1]; string iEnd = parts[2]; isInited = IsValid(iName) && IsValid(iStart) && IsValid(iEnd); if (isInited) { // // Set Active Session ... eaTradeManager .SetTradeSession( _Symbol, iStart, iEnd, iName // ); } } } } } } // // Initializing Signaller(s) ... string symbols[]; Add( _Symbol, symbols // ); bool hasSymbols = HasChild(symbols); if (hasSymbols) { // // Prepare Signaller Inputs ... XCATBEASignallerInputs iSignallerInputs; // // Common Configs ... // // Provider Name ... iSignallerInputs.period = _Period; iSignallerInputs.provider = "XTRGB"; // // CATB Indicator ... iSignallerInputs.catbInputs.Default(); iSignallerInputs.catbInputs.Hide(); // // Trigger Block Validations ... iSignallerInputs.validations.forceHasSwing = eaForceHasSwing; iSignallerInputs.validations.forceOBBarType = eaForceOBBarType; iSignallerInputs.validations.minRequiredOBBar = eaMinRequiredOBBar; iSignallerInputs.validations.forceFVGBarType = eaForceFVGBarType; iSignallerInputs.validations.liquidityLoopback = eaLiquidityLoopback; iSignallerInputs.validations.maxAllowedRange = eaMaxAllowedRange; iSignallerInputs.validations.minAllowedRange = eaMinAllowedRange; iSignallerInputs.validations.forceHasFLiquidity = eaForceHasFLiquidity; iSignallerInputs.validations.forceHasRLiquidity = eaForceHasRLiquidity; iSignallerInputs.validations.validateGapSequence = eaValidateGapSequence; iSignallerInputs.validations.minAllowedBlockLength = eaMinAllowedBlockLength; iSignallerInputs.validations.validateBlockEdgeBreakout = eaValidateBlockEdgeBreakout; // // Trigger Block Filters ... // iSignallerInputs.filters.filterBasedOnPV = eaFilterBasedOnPV; iSignallerInputs.filters.bosLoopback = eaBosLoopback; // iSignallerInputs.filters.filterBasedOnSar = eaFilterBasedOnSar; iSignallerInputs.filters.forceSarSwitched = eaForceSarSwitched; iSignallerInputs.filters.forceSarOnBothSide = eaForceSarOnBothSide; iSignallerInputs.filters.forceSarHasBreakout = eaForceSarHasBreakout; iSignallerInputs.filters.forceSarHasReversalSide = eaForceSarHasReversalSide; // iSignallerInputs.filters.filterBasedOnRSI = eaFilterBasedOnRSI; iSignallerInputs.filters.forceHasRSITrending = eaForceHasRSITrending; iSignallerInputs.filters.forceHasRSIVPattern = eaForceHasRSIVPattern; iSignallerInputs.filters.forceHasRSICrossing = eaForceHasRSICrossing; // iSignallerInputs.filters.filterBasedOnADX = eaFilterBasedOnADX; iSignallerInputs.filters.forceHasADXTrending = eaForceHasADXTrending; iSignallerInputs.filters.forceHasADXCrossing = eaForceHasADXCrossing; // iSignallerInputs.filters.filterBasedOnATR = eaFilterBasedOnATR; iSignallerInputs.filters.forceHasATRTrending = eaForceHasATRTrending; iSignallerInputs.filters.forceHasATRBreakout = eaForceHasATRBreakout; // iSignallerInputs.filters.filterBasedOnTrend = eaFilterBasedOnTrend; iSignallerInputs.filters.forceHasTrendDir = eaForceHasTrendDir; iSignallerInputs.filters.forceHasTrendPlace = eaForceHasTrendPlace; iSignallerInputs.filters.forceHasTrendChange = eaForceHasTrendChange; iSignallerInputs.filters.forceHasTrendTrending = eaForceHasTrendTrending; iSignallerInputs.filters.forceHasTrendRejection = eaForceHasTrendRejection; iSignallerInputs.filters.forceHasTrendLineInside = eaForceHasTrendLineInside; iSignallerInputs.filters.forceHasTrendDirOnBothSide = eaForceHasTrendDirOnBothSide; // iSignallerInputs.filters.filterBasedOnDelta = eaFilterBasedOnDelta; iSignallerInputs.filters.filterBasedOnVolume = eaFilterBasedOnVolume; iSignallerInputs.filters.filterBasedOnSignalBar = eaFilterBasedOnSignalBar; iSignallerInputs.filters.filterBasedOnHKSignalBar = eaFilterBasedOnHKSignalBar; // // Loop Through Symbols for Signalling Initializing ... int symbolsCount = ArraySize(symbols); for (int i = 0; i < symbolsCount; i++) { // string iSymbol = symbols[i]; // iSignallerInputs.symbol = iSymbol; if (iSignallerInputs.IsValid()) { // // Initialize Signaller ... XCXCATBEASignaller *iSignaller = new XCXCATBEASignaller(iSignallerInputs); // // Add it to the Signallers List ... Add( iSignaller, eaSignallers // ); // ZeroMemory(iSignaller); } } // // Cleanup Resources ... iSignallerInputs.Clean(); } // } /** * Handling Time Reporting ... */ void HandleTimeReport() { // if (eaAlert == NULL) { return; } // // Monthly Report .... if (eaReportNewMonths && eaTimeTracker.IsNewMonth()) { // string msg = "New Month ..."; // eaAlert.SendAlert(msg); } // // Weekly Report .... if (eaReportNewWeeks && eaTimeTracker.IsNewWeek()) { // string msg = "New Week ..."; // eaAlert.SendAlert(msg); } // // Daily Report .... if (eaReportNewDays && eaTimeTracker.IsNewDay()) { // string msg = "New Day ..."; // eaAlert.SendAlert(msg); } // // Hourly Report .... if (eaReportNewHours && eaTimeTracker.IsNewHour()) { // string msg = "New Hour ..."; // eaAlert.SendAlert(msg); } } /** * Update Signal Targets ... */ void UpdateSignalTargets(XSignal &signal) { // bool has = signal.IsValid(); if (!has) { return; } // // Clean Signal Targets ... Clean(signal.targets); // // Calculate Requirements ... double r2r = eaSignalR2R > 0 ? eaSignalR2R : 1; double risk = signal.GetRisk(); double reward = risk * r2r; // double isLong = IsLong(signal.type); // // Handling Signal TP ... signal.tp = isLong ? signal.entry + reward : signal.entry - reward; // // Try to Apply Money Management ... // // if (r2r <= 1) // { // return; // } // // XTarget iTarget; // // // // Partial Close 0.5 of Position on Reward 1 ... // reward = risk * 1; // iTarget.target = // isLong // ? signal.entry + reward // : signal.entry - reward; // iTarget.volumeMultiplier = 0.5; // // // AddRef(iTarget, signal.targets); // iTarget.Clean(); // // // if (r2r <= 2) // { // return; // } // // Making Loop ... // for (int i = 2; i < ((int)r2r - 1); i++) // { // // // iTarget.Clean(); // // // reward = i * risk; // iTarget.target = // isLong // ? signal.entry + reward // : signal.entry - reward; // iTarget.volumeMultiplier = 1 / (r2r - 2); // // // AddRef(iTarget, signal.targets); // } // // Sort Targets ... ENUM_X_DIRECTION sortingDir = isLong ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; ApplySortOnTargets( sortingDir, signal.targets // ); } //