/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Class Library // ---------------------------------------------- // Name: XSCX121EA // Description: an Expert Class which // used X121 Setup ... // // // 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 // // START Import and Inclused requirements ... // // // Includes ... #include "../Classes/x-saherelm.xea.class.mq5" #include "../Libraries/x-saherelm.x121.draw.lib.mq5" #include "../Libraries/x-saherelm.x121.support.lib.mq5" #include "../Libraries/x-saherelm.x121.signaller.lib.mq5" #include "../Classes/x-saherelm.x121.provider.class.mq5" // // END Import and Inclused requirements ... // // // START Definitions ... // // // an Structure to Holds a Support of Support ... struct XSupport { // // Supported Position ... XPosition position; // // Last Support Date ... ulong lastSupport; // // Last SUpported Volume ... double lastSupportVolume; }; // // END Definitions ... // // // START Overrides ... // // // END Overrides ... // // // an Expert Advisor Class by X121Provider ... class XSCX121EA : public XSCBaseEA { // // Public ... public: // // Props ... // // Constructor ... void XSCX121EA( string symbol, // Trading Symbol ENUM_TIMEFRAMES period, // Trading Time Frame ulong magic, // Magic Number int slippage, // Slippgae TOnStopLoss onStopLossTriggered = NULL, // On StopLoass Triggered Event Handler TOnTakeProfit onTakeProfitTriggered = NULL, // On TakeProfit Triggered Event Handler TOnDealsChanged onDealsChangedHandler = NULL, // On Deals Changed Event Handler TOnOrdersChanged onOrdersChangedHandler = NULL, // On Orders Changed Event Handler TOnPositionsChanged onPositionsChangedHandler = NULL, // On Positions Changed Event Handler TOnTradeStateChanged onTradeStateChangedHandler = NULL, // On Trade State Changed Event Handler TOnSignalConditions onSignalConditions = NULL // On SignalConditions Event Handler ) : XSCBaseEA(symbol, period, magic, slippage, onStopLossTriggered, onTakeProfitTriggered, onDealsChangedHandler, onOrdersChangedHandler, onPositionsChangedHandler, onTradeStateChangedHandler) { mOnSignalConditions = onSignalConditions; } // // DeConstructor ... void ~XSCX121EA() { // int providersCount = ArraySize(mProviders); if (providersCount > 0) { // for (int i = 0; i < providersCount; i++) { // X121SignalProvider iProvider = mProviders[i]; // delete iProvider.provider; } } } // // START Properties ... // // // Add Provider ... bool AddProvider( X121SignalProvider &provider // Specific Provider ... ) { // bool result = false; // // Validate Provider ... if (provider.symbol == NULL || provider.period == NULL || provider.riskAmount <= 0 || StringLen(provider.symbol) == 0 || ArraySize(provider.providers) == 0) { return result; } // // Check Exists or not ... int idx = GetProviderIndex( provider.symbol, provider.period); if (idx >= 0) { return result; } // PrepareProviderConfig(); // // Make Instance of X121Provider Class ... provider.provider = new XSCX121Provider( mSymbol, mPeriod); // // Attach Event Listener ... if (mOnSignalConditions != NULL) { // // Attach Event Handlers ... provider.provider.AddOnSignalConditionEventHandler(mOnSignalConditions); } // // Set Signallers to Provider Class ... result = provider.provider.SetSignallers(provider.providers); if (!result) { return result; } // // Initialize Provider ... result = provider.provider.SetConfig(mProviderConfig); // // Add Prepared Provider to Providers ... Add( provider, mProviders); // return result; } // // Add Providers ... int AddProviders( X121SignalProvider &providers[] // Specific Providers ... ) { // int result = 0; // int providersCount = ArraySize(providers); if (providersCount <= 0) { return result; } // for (int i = 0; i < providersCount; i++) { // X121SignalProvider iProvider = providers[i]; // bool isAdded = AddProvider(iProvider); if (isAdded) { result++; } } // return result; } // // END Properties ... // // // START Overrides ... // // void OnPositionsChangedHandler(int count) { // XPosition positions[]; mTrader.GetPositions(positions); int positionsCount = ArraySize(positions); if (positionsCount <= 0) { return; } // for (int i = 0; i < positionsCount; i++) { // XPosition iPosition = positions[i]; // XPositionPack pack; bool hasPositionPack = mTrader.GetPositionPack( iPosition.ticket, pack); if (hasPositionPack) { continue; } } } // // Handle TakeProfit Event ... void OnTakeProfitTriggered(const XDeal &deal) { // // Get Take Profit Position ... ulong ticket = deal.positionId; string symbol = deal.symbol; // XOrder supportOrders[]; // XOrder orders[]; mTrader.GetOrders( orders, symbol, NULL, ORDER_STATE_PLACED); int ordersCount = ArraySize(orders); if (ordersCount <= 0) { return; } // for (int i = 0; i < ordersCount; i++) { // XOrder iOrder = orders[i]; // string params[]; bool isSupport = ExtractSupportParams( iOrder.comment, params); if (!isSupport) { continue; } // ulong parentTicket = ExtractParentTicket(iOrder.comment); if (parentTicket != ticket) { continue; } // Add( iOrder, supportOrders); } // int supportOrdersCount = ArraySize(supportOrders); if (supportOrdersCount <= 0) { return; } // bool isCanceled = mTrader.CancelOrders(supportOrders); if (isCanceled) { // string message = "Close (" + ToString(supportOrdersCount) + ") Support of: (" + ToString(ticket) + ") due it's Take Profit ..."; // LogMessage(message); } } // // END Overrides ... // // // START Inheritance Functions ... // // void PrepareTag() { mTag = "X121EA:" + mSymbol + "," + ToString(mPeriod) + (string)mMagic; } // // Check Providers Guard States ... bool CheckGuard(XGuard &guards[]) { // bool result = false; // Clean(guards); // int providersCount = ArraySize(mProviders); if (providersCount <= 0) { return result; } // for (int i = 0; i < providersCount; i++) { // X121SignalProvider iProvider = mProviders[i]; // XGuard iGuards[]; bool iHasGuard = iProvider.provider.GuardCheck(iGuards); if (iHasGuard) { // Copy( iGuards, guards, false); } } // // Here we Can Implement Custom Guards Senario ... // // Do Management Equity ... HandleEquityManagement(); // result = ArraySize(guards) > 0; // return result; } // // Check Providers for Signals ... bool SignalCheck(XSignal &signals[]) { // bool result = false; // Clean(signals); // // Check Max Allowed Positions ... result = ChecPositionsForTrade(); if (!result) { return result; } // // Check Equity ... result = CheckEquityForTrade(); if (!result) { return result; } // int providersCount = ArraySize(mProviders); if (providersCount <= 0) { return result; } // for (int i = 0; i < providersCount; i++) { // X121SignalProvider iProvider = mProviders[i]; // int iFoundedPivots = iProvider.provider.CountPivots(); int iReuiredPivots = iProvider.provider.GetMinPivots(); if (iFoundedPivots < iReuiredPivots) { // iProvider.provider.ProccessPivotPoints(); // continue; } // X121MarketConditions iConditions; // // By Use this Template we Can Test Signallers // then Make Them Traditional ... bool iHasSignal = XTMPProcessSignal( iConditions, iProvider.provider); // // TODO: Fix this ... // iProvider.provider.ProcessTick(iConditions); // if (iHasSignal && iConditions.hasSignal) { // // Check Signalling is Enabled by Signal type ... bool isiSignalLong = IsLong(iConditions.signal.type); if ((isiSignalLong && !mEnableLongs) || (!isiSignalLong && !mEnableShorts)) { continue; } // PrepareConditionsSignal(iConditions); // // Generate Support Signals ... // GenerateSignalSupports( // iConditions.signal, // iProvider.provider); // // DrawConditionsSignalOnChart(iConditions); // Add( iConditions.signal, signals); } } // result = ArraySize(signals) > 0; // // IMPORTANT: // Since we have to Implement our Signal Execution Senario // Ignore this here for Default behaviour and implememt or Execution ... if (result) { // XSignal allowedSignals[]; // // Select Which Signal need To Execute ... bool hasEquity = CheckEquityForTrade(); if (hasEquity) { // // Since we have necessary Equity for Trade ... // Accept all incomming Signals ... Copy( signals, allowedSignals); // // TODO: // Implement Trade Policies ... } else { // // How to Select Signals when there is no Equity for Trade ... LogMessage("No Equity ..."); } // int allowedSignalsCount = ArraySize(allowedSignals); if (allowedSignalsCount > 0) { // // Execute Signals oly when allowed ... mTrader.ExecuteSignals(allowedSignals); } // // Prevent Default Base Signal Execution ... // Clean(signals); // return false; } // return result; } // // END Inheritance Functions ... // // // START Provided Actions ... // // // END Provided Actions ... // // // Protected ... protected: // // Private ... private: // // Props ... X121SignalProvider mProviders[]; X121ProviderInputs mProviderConfig; TOnSignalConditions mOnSignalConditions; // // Actions ... // // SUPPORT ... // // // EQUITYMANAGEMENT ... // Supported Positions ... XSupport mSupports[]; // // EQUITYMANAGEMENT ... // Check Support of Supports Exists or ot ... bool HasSuppors() { return CountSupports() > 0; } // // EQUITYMANAGEMENT ... // Count Exists Support of Supports ... int CountSupports() { return ArraySize(mSupports); } // // EQUITYMANAGEMENT ... // Retrieve Supported of Supports ... int GetSupportsIndex( ulong ticket // Desired Support Position Ticket ... ) { // int result = -1; // int supportsCount = CountSupports(); if (supportsCount <= 0) { return result; } // for (int i = 0; i < supportsCount; i++) { // XSupport iSupport = mSupports[i]; // if (iSupport.position.ticket != 0 && iSupport.position.ticket == ticket) { // result = i; break; } } // return result; } // // EQUITYMANAGEMENT ... // Add Supported of Supports ... bool AddSupports( XSupport &support // Support item ... ) { // bool result = false; // // Check Support Exists or not ... int supIndex = GetSupportsIndex(support.position.ticket); if (supIndex < 0) { // // Add New ... Add(support, mSupports); // result = true; } else { // // Update Exists ... // int supportsCount = CountSupports(); XSupport collection[]; for (int i = 0; i < supportsCount; i++) { // XSupport iSupport = mSupports[i]; // if (iSupport.position.ticket == support.position.ticket) { continue; } // Add(iSupport, collection); } // Add(support, collection); // Copy( collection, mSupports, true); // Clean(collection); // result = true; } // return result; } // // EQUITYMANAGEMENT ... // Remove Supported Of Supports ... bool RemoveSupports( XSupport &support // Support item ... ) { // bool result = false; // // Check Support Exists or not ... int supIndex = GetSupportsIndex(support.position.ticket); if (supIndex < 0) { return result; } // int supportsCount = CountSupports(); XSupport collection[]; for (int i = 0; i < supportsCount; i++) { // XSupport iSupport = mSupports[i]; // if (iSupport.position.ticket == support.position.ticket) { continue; } // Add(iSupport, collection); } // Copy( collection, mSupports, true); // Clean(collection); // result = true; // return result; } // // EQUITYMANAGEMENT ... int GetSupportAge( int index // Supported Index ) { // int result = -1; // int supportsCount = CountSupports(); if (index < 0 || index > supportsCount - 1) { return result; } // // Retrieve Required Info ... string symbol = mSupports[index].position.symbol; ENUM_TIMEFRAMES period = mSupports[index].position.period; datetime lastDate = MilliSecondsToTiem(mSupports[index].lastSupport); // // Calculate Age ... result = iBarShift( symbol, period, lastDate); // return result; } // // EQUITYMANAGEMENT ... // // // Do All Equity Management Works here ... void HandleEquityManagement() { // // Handle Hedging Positions ... HandleHedging(); // return; // // Close All Long Time Placed Support Signals // Which doesn't Triggered yest ... HandleCancelAllUntriggeredSupports(); // // Check Equity ... bool hasEquity = CheckEquityForTrade(); if (hasEquity) { return; } // // Retrieve Provider Count ... int providersCount = ArraySize(mProviders); if (providersCount <= 0) { // // We Have at least two Position for Hedging ... return; } // // Loop Through Registered Provider Instances ... for (int i = 0; i < providersCount; i++) { // bool canIgnoreSupporting = false; // X121SignalProvider iSProvider = mProviders[i]; // string symbol = iSProvider.symbol; ENUM_TIMEFRAMES period = iSProvider.period; XSCX121Provider *analyzer = iSProvider.provider; // // We Have to Detect Each Providers In DrawDown Signals and then // Found any Support Signals for them ... // 1- must have at least TWO Support Signal without tp ... // 2- there are some signals by providing tp ... // 3- Trend base and Conditional Supports by tp ... // XPosition inDrawdownPositions[]; GetInDrawdownPositions( inDrawdownPositions, // Result ... symbol, NULL, // All Types ... period, NULL, // All Providers ... NULL // Select All ... ); int inDrawdownPositionsCount = ArraySize(inDrawdownPositions); if (inDrawdownPositionsCount <= 0) { continue; } // // Find Oldest Position to CHeck Trade Age ... XPosition oldestInDrawdownPosition; int oldestInDrawdownPositionAge = GetOldest( oldestInDrawdownPosition, inDrawdownPositions); bool isTooOldForSupport = oldestInDrawdownPositionAge >= oldAgePositionForSupportFactor; if (!isTooOldForSupport) { continue; } // // Now we Have to Check Exists EQM Supports ... XOrder orders[]; GetOrders( orders, symbol, NULL, // All Types ... NULL, // All States ... period, NULL // All Providers ... ); int ordersCount = ArraySize(orders); if (ordersCount > 0) { // // Extract EQM Support Signals ... XOrder supportOrders[]; ordersCount = GetEQMSupportOrders( supportOrders, orders, period); if (ordersCount > 0) { // // Since there are EQM Untriggere Support Orders here ... // we have to check theirs longest Age ... XOrder longestUntriggeredSupportOrder; int longestUntriggeredSupportOrderAge = GetOldest( longestUntriggeredSupportOrder, supportOrders); canIgnoreSupporting = longestUntriggeredSupportOrderAge < oldAgeSupportForReNewFactor; if (canIgnoreSupporting) { continue; } } } // // Here we Have To Generate new Support Signals and Execute them ... XSignal supports[]; int supportsCount = GenerateMarketSupports( supports, symbol, // Trading Symbol ... period, // Trading Timeframe ... analyzer // Market Analizer ( Signal Provider Instance ) ... ); if (supportsCount <= 0) { continue; } // PrepareSignals(supports); // string comment = GenerateXEQMSupportComment(period); int executed = mTrader.ExecuteSignals( supports, comment); } } // // Close All Positions in Summary Profit ... bool HandleHedging() { // bool result = false; // // List All Open Positions and Calculate Profit Summary ... // double profit = 0; double requiredProfit = 0; // XPosition positions[]; GetPositions( positions, // Result ... NULL, // All Symbols ... NULL, // All Types ... NULL, // All Period ... NULL // All Providers ... ); int positionsCount = ArraySize(positions); if (positionsCount <= 0) { return result; } // for (int i = 0; i < positionsCount; i++) { // XPosition iPosition = positions[i]; // profit += iPosition.profit; requiredProfit += ((iPosition.volume / minProfitPerVolumeFactor) * minProfitPerTrade) + (-1 * iPosition.swap); } // // Check We Can Hedge or not ... result = profit >= requiredProfit; if (!result) { // // Here we Have to Close Long In Profit Trades ... // Open Positions ... XPosition longestInProfitPosition; int longestInProfitPositionAge = GetOldest( longestInProfitPosition, positions); double requireProfit = minProfitPerTrade * (longestInProfitPosition.profit / minProfitPerVolumeFactor) + -1 * (longestInProfitPosition.swap); bool canClose = longestInProfitPositionAge >= oldAgePositionForSupportFactor && longestInProfitPosition.profit > 0 && longestInProfitPosition.profit > requireProfit; if (canClose) { // string comment = "EQM Close In Profit ..."; // bool isClosed = mTrader.Close( longestInProfitPosition.ticket, comment); if (isClosed) { // // Force Cancel All Pending Orders ... HandleCancelAllUntriggeredSupports(true); // string message = "EQM Close Position (" + ToString(longestInProfitPosition.ticket) + ") by: " + ToString(longestInProfitPosition.profit); // LogMessage(message); // result = true; } } // // Check if one Position is Open and it's in Drawdown and ore than // longest age ... // close it ... // if (!result) // { // // // if (longestInProfitPositionAge >= oldAgePositionForSupportFactor) // { // // // string comment = "EQM Close In DD ..."; // // // int closed = mTrader.ClosePositions( // positions, // comment); // result = closed == positionsCount; // } // } // return result; } // string comment = "EQM Hedge ..."; int closed = mTrader.ClosePositions( positions, comment); // result = closed == positionsCount; if (result) { // // Force Cancel All Pending Orders ... HandleCancelAllUntriggeredSupports(true); // string message = "EQM Close (" + ToString(closed) + ") Positions due HEDGE by: " + ToString(profit); // LogMessage(message); } // return result; } // // We Have To Cancell All Untriggered Supports ... void HandleCancelAllUntriggeredSupports( bool force = false // Force Close All ... ) { // // Retrieve all Placed EQM Supports ... XOrder orders[]; GetOrders( orders, NULL, // All Symbols ... NULL, // All Types ... NULL, // All State ... NULL, // All Periods ... NULL // All Providers ... ); int ordersCount = ArraySize(orders); if (ordersCount <= 0) { return; } // XOrder supports[]; int supportsCount = GetEQMSupportOrders( supports, orders, NULL // All Time Frames ... ); if (supportsCount <= 0) { return; } // XOrder oldest; int oldestAge = GetOldest( oldest, orders); bool isTooOldForCancel = oldestAge >= oldAgeSupportForReNewFactor; if (!force && !isTooOldForCancel) { return; } // bool isCanceled = mTrader.CancelOrders( supports); } // // Pepare a Collection Of Signals ... void PrepareSignals(XSignal &signals[]) { // int signalsCount = ArraySize(signals); if (signalsCount <= 0) { return; } // for (int i = 0; i < signalsCount; i++) { // PrepareSignal(signals[i]); } } // // PROVIDERS ... // // // Find Specific Provider Index by using give symbol and period ... int GetProviderIndex( string symbol, // Trading Symbol ... ENUM_TIMEFRAMES period // Trading Time frame ... ) { // int result = -1; // // Validate Args ... if (period == NULL || symbol == NULL || StringLen(symbol) == 0) { return result; } // int providersCount = ArraySize(mProviders); if (providersCount <= 0) { return result; } // for (int i = 0; i < providersCount; i++) { // X121SignalProvider iProvider = mProviders[i]; // if (iProvider.symbol == symbol && iProvider.period == period) { // result = i; break; } } // return result; } // // Prepare Default Configurations for X121Provider Setup ... void PrepareProviderConfig() { // // XCT ... // Candle Timing ... mProviderConfig.xctConfig.clr = clrBlueViolet; mProviderConfig.xctConfig.corner = CORNER_RIGHT_UPPER; mProviderConfig.xctConfig.showCandleTime = true; // // XCC ... // Candle Styling ... mProviderConfig.xccConfig.upColor = clrLime; mProviderConfig.xccConfig.downColor = clrRed; mProviderConfig.xccConfig.lineColor = clrLime; mProviderConfig.xccConfig.bearishColor = clrRed; mProviderConfig.xccConfig.bullishColor = clrLime; mProviderConfig.xccConfig.volumesColor = clrGreen; mProviderConfig.xccConfig.showCandles = true; // // XHK ... // HikenAshi Candle Representing ... mProviderConfig.xhkConfig.drawCandleLines = false; // // XTM ... // Trend Magic ... mProviderConfig.xtmConfig.length = 35; mProviderConfig.xtmConfig.shift = 0; mProviderConfig.xtmConfig.method = MODE_SMA; mProviderConfig.xtmConfig.appliedTo = PRICE_LOW; mProviderConfig.xtmConfig.showLine = false; // // XPV ... // Peaks And Vales ... mProviderConfig.xpvConfig.shortLength = 9; mProviderConfig.xpvConfig.mediumLength = 17; mProviderConfig.xpvConfig.longLength = 26; mProviderConfig.xpvConfig.hindLength = 35; mProviderConfig.xpvConfig.fiboLevel1 = 0.382; mProviderConfig.xpvConfig.fiboLevel2 = 0.5; mProviderConfig.xpvConfig.fiboLevel3 = 0.618; mProviderConfig.xpvConfig.hhMode = MODE_HIGH; mProviderConfig.xpvConfig.llMode = MODE_LOW; mProviderConfig.xpvConfig.showPeaksAndVales = false; mProviderConfig.xpvConfig.showLevels = false; mProviderConfig.xpvConfig.showFibo1Levels = false; mProviderConfig.xpvConfig.showFibo2Levels = false; mProviderConfig.xpvConfig.showFibo3Levels = false; // // XAMA ... // Adaptive Moving Average ... mProviderConfig.xamaConfig.length = 52; mProviderConfig.xamaConfig.fastEMA = 2; mProviderConfig.xamaConfig.slowEMA = 30; mProviderConfig.xamaConfig.maShift = 0; mProviderConfig.xamaConfig.appliedTo = PRICE_LOW; mProviderConfig.xamaConfig.showLine = false; // // XMRB ... // Moving Average Ribbon ... mProviderConfig.xmrbConfig.fast1Length = 3; mProviderConfig.xmrbConfig.slow1Length = 5; mProviderConfig.xmrbConfig.fast2Length = 8; mProviderConfig.xmrbConfig.slow2Length = 13; mProviderConfig.xmrbConfig.fast3Length = 21; mProviderConfig.xmrbConfig.slow3Length = 34; mProviderConfig.xmrbConfig.fast4Length = 55; mProviderConfig.xmrbConfig.slow4Length = 89; mProviderConfig.xmrbConfig.fast5Length = 144; mProviderConfig.xmrbConfig.slow5Length = 233; mProviderConfig.xmrbConfig.ribbonMode = MODE_EMA; mProviderConfig.xmrbConfig.ribbonAppliedTo = PRICE_CLOSE; mProviderConfig.xmrbConfig.showFastMa = false; mProviderConfig.xmrbConfig.showSlowMa = false; mProviderConfig.xmrbConfig.showRibbon = false; // // XCHE ... // Chandelier Exit Points ... mProviderConfig.xcheConfig.length = 35; mProviderConfig.xcheConfig.loopback = 26; mProviderConfig.xcheConfig.multiplier1 = 3; mProviderConfig.xcheConfig.multiplier2 = 3.5; mProviderConfig.xcheConfig.upAppliedTo = PRICE_HIGH; mProviderConfig.xcheConfig.downAppliedTo = PRICE_LOW; mProviderConfig.xcheConfig.showLongExit1Line = false; mProviderConfig.xcheConfig.showShortExit1Line = false; mProviderConfig.xcheConfig.showLongExit2Line = false; mProviderConfig.xcheConfig.showShortExit2Line = false; // // XICH ... // Ichimopku Kinko Hyo ... mProviderConfig.xichConfig.tenkanSenLength = 9; mProviderConfig.xichConfig.tenkanSenMode = X_XICH_HH_LL_MODE; mProviderConfig.xichConfig.kijunSenLength = 26; mProviderConfig.xichConfig.kijunSenMode = X_XICH_HH_LL_MODE; mProviderConfig.xichConfig.senkouSpanBLength = 52; mProviderConfig.xichConfig.senkouSpanBMode = X_XICH_HH_LL_MODE; mProviderConfig.xichConfig.chikuoSpanAppliedTo = PRICE_CLOSE; mProviderConfig.xichConfig.showTenkanSen = false; mProviderConfig.xichConfig.showKijunSen = false; mProviderConfig.xichConfig.showKijunSenPlus = false; mProviderConfig.xichConfig.showKijunSenNegative = false; mProviderConfig.xichConfig.showChikouSpan = false; mProviderConfig.xichConfig.showSenkouSpanA = false; mProviderConfig.xichConfig.showSenkouSpanB = false; mProviderConfig.xichConfig.showKumo = false; mProviderConfig.xichConfig.shiftKumo = true; // // XTRND ... // Trend Detector ... mProviderConfig.xtrndConfig.cycleLength = 2; mProviderConfig.xtrndConfig.numberOfVerifications = 2; mProviderConfig.xtrndConfig.hhMode = MODE_HIGH; mProviderConfig.xtrndConfig.llMode = MODE_LOW; mProviderConfig.xtrndConfig.l1Method = X_PERIOD_AUTO; mProviderConfig.xtrndConfig.l1Period = NULL; mProviderConfig.xtrndConfig.l2Method = X_PERIOD_AUTO; mProviderConfig.xtrndConfig.l2Period = NULL; mProviderConfig.xtrndConfig.l3Method = X_PERIOD_AUTO; mProviderConfig.xtrndConfig.l3Period = NULL; mProviderConfig.xtrndConfig.showConsolidations = false; mProviderConfig.xtrndConfig.showTrend = false; mProviderConfig.xtrndConfig.showL1Trend = false; mProviderConfig.xtrndConfig.showL2Trend = false; mProviderConfig.xtrndConfig.showL3Trend = false; // // XSSLC ... // SSL Channel ... mProviderConfig.xsslcConfig.length = 36; mProviderConfig.xsslcConfig.method = MODE_SMA; mProviderConfig.xsslcConfig.upAppliedTo = PRICE_HIGH; mProviderConfig.xsslcConfig.downAppliedTo = PRICE_LOW; mProviderConfig.xsslcConfig.showUp = false; mProviderConfig.xsslcConfig.showDown = false; // // XHULL ... // Hull Trend Detection Channel ... mProviderConfig.xhullConfig.length = 72; mProviderConfig.xhullConfig.divisor = 2; mProviderConfig.xhullConfig.upAppliedTo = PRICE_HIGH; mProviderConfig.xhullConfig.downAppliedTo = PRICE_LOW; mProviderConfig.xhullConfig.showUpZone = false; mProviderConfig.xhullConfig.showDownZone = false; // // XOSC ... mProviderConfig.xoscConfig.atrLength = 14; mProviderConfig.xoscConfig.rviLength = 10; mProviderConfig.xoscConfig.bullpLength = 13; mProviderConfig.xoscConfig.bearpLength = 13; mProviderConfig.xoscConfig.volumeAppliedTo = VOLUME_TICK; mProviderConfig.xoscConfig.rsiLength = 14; mProviderConfig.xoscConfig.rsiAppliedTo = PRICE_CLOSE; mProviderConfig.xoscConfig.cciLength = 14; mProviderConfig.xoscConfig.cciAppliedTo = PRICE_TYPICAL; mProviderConfig.xoscConfig.stddevLength = 20; mProviderConfig.xoscConfig.stddevShift = 0; mProviderConfig.xoscConfig.stddevMethod = MODE_SMA; mProviderConfig.xoscConfig.stddevAppliedTo = PRICE_CLOSE; mProviderConfig.xoscConfig.momentumLength = 14; mProviderConfig.xoscConfig.momentumAppliedTo = PRICE_CLOSE; mProviderConfig.xoscConfig.sarStep = 0.02; mProviderConfig.xoscConfig.sarMaximum = 0.2; mProviderConfig.xoscConfig.macdFastLength = 12; mProviderConfig.xoscConfig.macdSlowLength = 26; mProviderConfig.xoscConfig.macdSignaLength = 9; mProviderConfig.xoscConfig.macdAppliedTo = PRICE_CLOSE; mProviderConfig.xoscConfig.stochKLength = 5; mProviderConfig.xoscConfig.stochDLength = 3; mProviderConfig.xoscConfig.stochSlowing = 3; mProviderConfig.xoscConfig.stochMaMethod = MODE_SMA; mProviderConfig.xoscConfig.stochMode = STO_LOWHIGH; // // XSTR ... mProviderConfig.xstrConfig.atrLength = 12; mProviderConfig.xstrConfig.atrMultiplier = 3.0; mProviderConfig.xstrConfig.atrAppliedTo = PRICE_MEDIAN; mProviderConfig.xstrConfig.showTrends = false; mProviderConfig.xstrConfig.fillTrends = false; // // XFBB ... mProviderConfig.xfbbConfig.length = 200; mProviderConfig.xfbbConfig.multiplier = 3.0; mProviderConfig.xfbbConfig.appliedTo = PRICE_TYPICAL; mProviderConfig.xfbbConfig.showBase = false; mProviderConfig.xfbbConfig.showBand = false; mProviderConfig.xfbbConfig.showGoldenArea = false; mProviderConfig.xfbbConfig.showOthers = false; // // XDEMA ... mProviderConfig.xdemaConfig.length = 200; mProviderConfig.xdemaConfig.shift = 0; mProviderConfig.xdemaConfig.showDema = false; mProviderConfig.xdemaConfig.showEMA = false; mProviderConfig.xdemaConfig.showEMAOfEMA = false; // PreDefineProviderConfig(); } // void PreDefineProviderConfig() { // // Default Configs For Different States ... bool showPV = false; bool showHK = false; bool showTM = false; bool showCHE = false; bool showSTR = false; bool showFBB = false; bool showMRB = false; bool showTRND = false; bool showDEMA = false; bool showHULL = false; bool showSimpleIchi = false; // // Predefine ... // // X786 ... showPV = true; // showTM = false; // showHK = false; showCHE = true; // showSTR = false; // showDEMA = true; showTRND = true; // showHULL = false; // showSimpleIchi = false; // if (showHK) { // // Hiken Ashi ... mProviderConfig.xccConfig.showCandles = false; mProviderConfig.xhkConfig.drawCandles = true; } if (showPV) { // // Peaks and Vales ... mProviderConfig.xpvConfig.showLevels = true; mProviderConfig.xpvConfig.showFibo1Levels = true; mProviderConfig.xpvConfig.showFibo2Levels = true; mProviderConfig.xpvConfig.showFibo3Levels = true; mProviderConfig.xpvConfig.showPeaksAndVales = true; } if (showSimpleIchi) { // // Simple Ichimoku Kinko Hyo ... mProviderConfig.xichConfig.showKijunSen = true; mProviderConfig.xichConfig.showTenkanSen = true; mProviderConfig.xichConfig.showSenkouSpanA = true; mProviderConfig.xichConfig.showSenkouSpanB = true; } if (showCHE) { // // Chandelier Exit ... mProviderConfig.xcheConfig.showLongExit1Line = true; mProviderConfig.xcheConfig.showLongExit2Line = true; mProviderConfig.xcheConfig.showShortExit1Line = true; mProviderConfig.xcheConfig.showShortExit2Line = true; } if (showTRND) { // // Show Trend ... mProviderConfig.xtrndConfig.showTrend = true; mProviderConfig.xtrndConfig.showL1Trend = true; mProviderConfig.xtrndConfig.showL2Trend = true; mProviderConfig.xtrndConfig.showL3Trend = true; mProviderConfig.xtrndConfig.showConsolidations = false; } if (showSTR) { // // Show Super Trend ... mProviderConfig.xstrConfig.showTrends = true; } if (showFBB) { // // Show Fibonacci Band ... mProviderConfig.xfbbConfig.showBase = true; mProviderConfig.xfbbConfig.showBand = true; mProviderConfig.xfbbConfig.showGoldenArea = true; } if (showDEMA) { // // Show Double EMA ... mProviderConfig.xdemaConfig.showDema = true; } if (showMRB) { // mProviderConfig.xmrbConfig.showFastMa = true; mProviderConfig.xmrbConfig.showSlowMa = true; mProviderConfig.xmrbConfig.showRibbon = false; } if (showTM) { mProviderConfig.xtmConfig.showLine = true; } if (showHULL) { // mProviderConfig.xhullConfig.showUpZone = true; mProviderConfig.xhullConfig.showDownZone = true; } // // X128 ... // // XTM ... // Trend Magic ... // mProviderConfig.xtmConfig.length = 17; // mProviderConfig.xtmConfig.shift = 0; // mProviderConfig.xtmConfig.method = MODE_SMA; // mProviderConfig.xtmConfig.appliedTo = PRICE_CLOSE; // mProviderConfig.xtmConfig.showLine = false; // // XAMA ... // Adaptive Moving Average ... // mProviderConfig.xamaConfig.length = 52; // mProviderConfig.xamaConfig.fastEMA = 2; // mProviderConfig.xamaConfig.slowEMA = 6; // mProviderConfig.xamaConfig.maShift = 0; // mProviderConfig.xamaConfig.appliedTo = PRICE_CLOSE; // mProviderConfig.xamaConfig.showLine = false; } // void PrepareConditionsSignal(X121MarketConditions &conditions) { // if (!conditions.hasSignal) { return; } // bool isLong = IsLong(conditions.signal.type); // // Check Calculate TP ... if ( conditions.signal.sl > 0 && conditions.signal.r2r > 0 && conditions.signal.entry > 0 && conditions.signal.calculateTP) { // double riskPrice = MathAbs(conditions.signal.entry - conditions.signal.sl); double riskPoint = PriceToPoint( conditions.signal.symbol, riskPrice); double rewardPoint = riskPoint * conditions.signal.r2r; double rewardPrice = PointToPrice( conditions.signal.symbol, rewardPoint); // double tp = isLong ? conditions.signal.entry + rewardPrice : conditions.signal.entry - rewardPrice; // conditions.signal.tp = tp; } // PrepareSignal(conditions.signal); } // void DrawConditionsSignalOnChart(X121MarketConditions &conditions) { // ulong mTicket = MathRand() * 100000; // DrawSignal( mTicket, conditions.signal); // DrawSupportResistance( 0, conditions.supportResistances, conditions.signal.providers[0]); } }; // // START Usefull Functions ... // // // END Usefull Functions ... //