From 038dbc8fa86f1a999e611b84b2716303abe9043e Mon Sep 17 00:00:00 2001 From: Hadi Khazaee Asl Date: Tue, 30 Apr 2024 19:09:35 +0330 Subject: [PATCH] last ... --- MQLTestWorkspace/BKPS/BKP/flTracker.mq5 | 80 + .../BKPS/INDICATORS/x-saherelm.x121.xman.mq5 | 3919 +++++++++++++++++ 2 files changed, 3999 insertions(+) create mode 100644 MQLTestWorkspace/BKPS/BKP/flTracker.mq5 create mode 100644 MQLTestWorkspace/BKPS/INDICATORS/x-saherelm.x121.xman.mq5 diff --git a/MQLTestWorkspace/BKPS/BKP/flTracker.mq5 b/MQLTestWorkspace/BKPS/BKP/flTracker.mq5 new file mode 100644 index 0000000..7f60774 --- /dev/null +++ b/MQLTestWorkspace/BKPS/BKP/flTracker.mq5 @@ -0,0 +1,80 @@ + + +// +// FLTRCK ... + +// +// FLUPTRCK ... +ArraySetAsSeries(flUpTrackerBuffer, true); +SetIndexBuffer(flUpTrackerBufferIndex, flUpTrackerBuffer, INDICATOR_DATA); +PlotIndexSetInteger(flUpTrackerBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); +PlotIndexSetInteger(flUpTrackerBufferPlotIndex, PLOT_SHOW_DATA, showFiboTracker); + +// +// FLUPTRCK Color ... +ArraySetAsSeries(flUpTrackerColorBuffer, true); +SetIndexBuffer(flUpTrackerColorBufferIndex, flUpTrackerColorBuffer, INDICATOR_COLOR_INDEX); + +// +// FLDOWNTRCK ... +ArraySetAsSeries(flDownTrackerBuffer, true); +SetIndexBuffer(flDownTrackerBufferIndex, flDownTrackerBuffer, INDICATOR_DATA); +PlotIndexSetInteger(flDownTrackerBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); +PlotIndexSetInteger(flDownTrackerBufferPlotIndex, PLOT_SHOW_DATA, showFiboTracker); + +// +// FLDOWNTRCK Color ... +ArraySetAsSeries(flDownTrackerColorBuffer, true); +SetIndexBuffer(flDownTrackerColorBufferIndex, flDownTrackerColorBuffer, INDICATOR_COLOR_INDEX); + +// +// FL Tracker Lines ... + +// +#define flUpTrackerBufferIndex 57 +#define flUpTrackerBufferPlotIndex 28 +double flUpTrackerBuffer[]; + +// +#define flUpTrackerColorBufferIndex 58 +double flUpTrackerColorBuffer[]; + +// +#property indicator_label29 "X121_XMAN FLTCK Up" +#property indicator_type29 DRAW_COLOR_LINE +#property indicator_color29 CLR_NONE, clrAqua +#property indicator_width29 1 + +// +#define flDownTrackerBufferIndex 59 +#define flDownTrackerBufferPlotIndex 29 +double flDownTrackerBuffer[]; + +// +#define flDownTrackerColorBufferIndex 60 +double flDownTrackerColorBuffer[]; + +// +#property indicator_label30 "X121_XMAN FLTCK DOWN" +#property indicator_type30 DRAW_COLOR_LINE +#property indicator_color30 CLR_NONE, clrMagenta +#property indicator_width30 1 + +// +// double fibAvg = ((((upPrice - downPrice) / 2) - fibLevel1Value + fibLevel2Value + fibLevel3Value) / 3); +double fibAvg = MathAbs(fibLevel1Value - fibLevel3Value) + ; +double flUpTracker = upPrice - fibAvg; +flUpTrackerBuffer[bar_index] = flUpTracker; +double flDownTracker = downPrice + fibAvg; +flDownTrackerBuffer[bar_index] = flDownTracker; + +// +double flTrackerColor = mHideColorIDX; +if (showFiboTracker) +{ + flTrackerColor = 1; +} + +// +flUpTrackerColorBuffer[bar_index] = flTrackerColor; +flDownTrackerColorBuffer[bar_index] = flTrackerColor; diff --git a/MQLTestWorkspace/BKPS/INDICATORS/x-saherelm.x121.xman.mq5 b/MQLTestWorkspace/BKPS/INDICATORS/x-saherelm.x121.xman.mq5 new file mode 100644 index 0000000..57df4f9 --- /dev/null +++ b/MQLTestWorkspace/BKPS/INDICATORS/x-saherelm.x121.xman.mq5 @@ -0,0 +1,3919 @@ +/////////////////////////////////////////////////////// +// SaherElm IT Center MQL5 Indicator +// ------------------------------------------- +// Name: X121_XMAN +// Description: Market Analyzer +// - Find Peaks and Vales +// - Find Trend +// - Find Market Direction +// - Detect Pivot Points and Swings +// +// Contains: +// ----------- +// - 4 Cycle of TimeFrames +// - Fibonacci Golden Zone +// - Trend Detection using True Range Averaging +// - Trend Detecting using Moving Averages Ribbon +// - Trend Detecting using SSL Channel +// - Trend Detecting using Hull Implementation +// +// 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_XMAN Indicator" +#property strict + +// +// START Constants ... +// + +// +// Indicator Short Name ... +#define ShortName "X121_XMAN" + +// +// XPERIOD Calculation Method ... +// USED For Multiple Time Frames ... +enum ENUM_X_PERIOD_METHOD +{ + // + X_PERIOD_NOTHING, // Nothing + X_PERIOD_AUTO, // Auto Select + X_PERIOD_MANUALLY // Manually +}; + +// +enum ENUM_X_MA_METHOD +{ + X_MA_NOTHING, // Nothing + X_MA_SMA, // Simple + X_MA_EMA, // Expotential + X_MA_SMMA, // Smoothed Simple + X_MA_LWMA, // Linear Weighted + X_MA_AMA // Adaptive +}; + +// +struct XHullData +{ + // + double value; + double value3; + + // + double wsum1; + double wsum2; + double wsum3; + + // + double lsum1; + double lsum2; + double lsum3; +}; + +// +// Holds an SnapShot of Charts Configuration ... +struct XChartStyle +{ + // + // chart's ID ... + long chartId; + // + // chart's mode ... + ENUM_CHART_MODE mode; + // + // show bid line ... + bool showBidLine; + // + // show ask line ... + bool showAskLine; + // + // show grids on chart ... + bool showGrid; + // + // show volumes ... + bool showVolumes; + // + // Displaying trade levels in the chart (levels of open positions, Stop Loss, Take Profit and pending orders) ... + bool showTradeLevels; + // + // chart autoscroll ... + bool autoScroll; + // + // chart quick navigation state ... + bool quickNavigation; + // + // chart's foreground color ... + color foreGroundColor; + // + // chart's background color ... + color backGroundColor; + // + // Up Color ... + color upColor; + // + // Down Color ... + color downColor; + // + // Bullish color ... + color bullishColor; + // + // Bearish color ... + color bearishColor; + // + // grid color ... + color gridColor; + // + // bid line color ... + color bidLineColor; + // + // ask line color ... + color askLineColor; + // + // line mode and doji candlestick color ... + color lineColor; + // + // Color of stop order levels (Stop Loss and Take Profit) ... + color stopColor; + // + // volumes color ... + color volumesColor; +}; + +// +struct XMRBColorInfo +{ + double clr; + double state; +}; + +// +// a Class For Hull Calculations ... +class XSCHull +{ + // +public: + // + // Constructor ... + XSCHull() : mFullPeriod(1), mHalfPeriod(1), mSqrtPeriod(1), mArraySize(-1) + { + // + // These are a way above to assign Private variables at Construct time ... + } + + // + // Deconstructor ... + ~XSCHull() + { + ArrayFree(mData); + } + + // + // Initial Hull ... + bool Init( + int mPeriod, + double mDivisor) + { + // + bool result = false; + + // + mFullPeriod = (int)(mPeriod > 1 ? mPeriod : 1); + mHalfPeriod = (int)(mFullPeriod > 1 ? mFullPeriod / (mDivisor > 1 ? mDivisor : 1) : 1); + mSqrtPeriod = (int)MathSqrt(mFullPeriod); + + // + mArraySize = -1; + mWeight1 = mWeight2 = mWeight3 = 1; + + // + result = true; + + // + return result; + } + + // + // CalCulate Specific Value ... + double Calculate( + double value, + int i, + int bars) + { + // + double result = 0; + + // + if (mArraySize < bars) + { + // + mArraySize = ArrayResize(mData, bars + 500); + if (mArraySize < bars) + return result; + } + + // + mData[i].value = value; + if (i > mFullPeriod) + { + // + mData[i].wsum1 = mData[i - 1].wsum1 + value * mHalfPeriod - mData[i - 1].lsum1; + mData[i].lsum1 = mData[i - 1].lsum1 + value - mData[i - mHalfPeriod].value; + mData[i].wsum2 = mData[i - 1].wsum2 + value * mFullPeriod - mData[i - 1].lsum2; + mData[i].lsum2 = mData[i - 1].lsum2 + value - mData[i - mFullPeriod].value; + } + else + { + // + mData[i].wsum1 = mData[i].wsum2 = + mData[i].lsum1 = mData[i].lsum2 = mWeight1 = mWeight2 = 0; + for (int k = 0, w1 = mHalfPeriod, w2 = mFullPeriod; w2 > 0 && i >= k; k++, w1--, w2--) + { + // + if (w1 > 0) + { + // + mData[i].wsum1 += mData[i - k].value * w1; + mData[i].lsum1 += mData[i - k].value; + mWeight1 += w1; + } + + // + mData[i].wsum2 += mData[i - k].value * w2; + mData[i].lsum2 += mData[i - k].value; + mWeight2 += w2; + } + } + + // + mData[i].value3 = 2.0 * mData[i].wsum1 / mWeight1 - mData[i].wsum2 / mWeight2; + + // + if (i > mSqrtPeriod) + { + // + mData[i].wsum3 = mData[i - 1].wsum3 + mData[i].value3 * mSqrtPeriod - mData[i - 1].lsum3; + mData[i].lsum3 = mData[i - 1].lsum3 + mData[i].value3 - mData[i - mSqrtPeriod].value3; + } + else + { + // + mData[i].wsum3 = + mData[i].lsum3 = mWeight3 = 0; + + // + for (int k = 0, w3 = mSqrtPeriod; w3 > 0 && i >= k; k++, w3--) + { + // + mData[i].wsum3 += mData[i - k].value3 * w3; + mData[i].lsum3 += mData[i - k].value3; + mWeight3 += w3; + } + } + + // + result = mData[i].wsum3 / mWeight3; + + // + return result; + } + + // + // Protected ... +protected: + // + // Private ... +private: + // + int mFullPeriod; + int mHalfPeriod; + int mSqrtPeriod; + int mArraySize; + double mWeight1; + double mWeight2; + double mWeight3; + + // + XHullData mData[]; +}; + +// +// END Constants ... +// + +// +// START Inputs ... +// + +// +input group "Chart Style"; +input color upColor = clrLime; // Up Color +input color downColor = clrRed; // Down Color +input color lineColor = clrLime; // Line mode and Doji candlestick Color +input color bearishColor = clrRed; // Bullish Color +input color bullishColor = clrLime; // Bearish Color +input color volumesColor = clrGreen; // Volumes Color + +// +input group "Makret Cycles"; + +// +input group "Level 1"; +input ENUM_X_PERIOD_METHOD l1Method = X_PERIOD_AUTO; // How to Find Period +input ENUM_TIMEFRAMES l1Period = NULL; // Time Period + +// +input group "Level 2"; +input ENUM_X_PERIOD_METHOD l2Method = X_PERIOD_AUTO; // How to Find Period +input ENUM_TIMEFRAMES l2Period = NULL; // Time Period + +// +input group "Level 3"; +input ENUM_X_PERIOD_METHOD l3Method = X_PERIOD_AUTO; // How to Find Period +input ENUM_TIMEFRAMES l3Period = NULL; // Time Period + +// +input group "Level 4"; +input ENUM_X_PERIOD_METHOD l4Method = X_PERIOD_AUTO; // How to Find Period +input ENUM_TIMEFRAMES l4Period = NULL; // Time Period + +// +input group "Fibonacci"; +input double fiboLevel1 = 0.382; // Fibio 1st Level +input double fiboLevel2 = 0.5; // Fibio 2st Level +input double fiboLevel3 = 0.618; // Fibio 3rd Level + +// +input group "Boundary Detection Modes"; +input ENUM_SERIESMODE hhMode = MODE_HIGH; // Highest High Calculation Method +input ENUM_SERIESMODE llMode = MODE_LOW; // Lowest Low Calculation Method + +// +input group "Trend Detection"; +input double trendMultiplier = 3; // Multiplier +input ENUM_APPLIED_PRICE trendPriceAppliedTo = PRICE_MEDIAN; // Applied To + +// +input group "Ribbon Detection"; +input ENUM_X_MA_METHOD ribbonMode = X_MA_AMA; // How to Calculate + +// +input group "Hull Trend"; +input double hullDivisor = 2.0; // Divisor (Speed) +input ENUM_APPLIED_PRICE hullUpAppliedTo = PRICE_HIGH; // Up Zone Applied to +input ENUM_APPLIED_PRICE hullDownAppliedTo = PRICE_LOW; // Down Zone Applied to + +// +input group "SSL Channel Detection"; +input ENUM_X_MA_METHOD sslcMode = X_MA_SMA; // How to Calculate +input ENUM_APPLIED_PRICE sslcUpAppliedTo = PRICE_HIGH; // Up Applied To +input ENUM_APPLIED_PRICE sslcDownAppliedTo = PRICE_LOW; // Down Applied To + +// +input group "Presentation"; +input bool showCandles = true; // Show Candles +input bool showHKCandles = true; // Draw Hiken Ashi Candle +input bool showPeaksAndVales = true; // Show Peaks and Vales +input bool showTrends = true; // Show Trends +input bool fillTrends = false; // Fill Trends +input bool showLevels = false; // Show Levels +input bool showConsolidations = false; // Show Consolidations +input bool showRibbons = false; // Show Ribbons +input bool showHull = false; // Show Hull +input bool showSSLChannel = false; // Show SSL Channel +input bool showFibo1Levels = true; // Show Fibo 1st Level +input bool showFibo2Levels = true; // Show Fibo 2nd Level +input bool showFibo3Levels = true; // Show Fibo 3rd Level + +// +// END Inputs ... +// + +// +// START Includes and Imports ... +// + +// +// Includes Draw Library ... +#include "../Libraries/x-saherelm.draw.lib.mq5" + +// +// Includes Common Library ... +#include "../Libraries/x-saherelm.common.lib.mq5" + +// +// END Includes and Imports ... +// + +// +// START Buffers ... +// +#property indicator_chart_window + +// +#property indicator_buffers 84 +#property indicator_plots 41 + +// +// PEKSANDVALES ... + +// +// PEAKS ... + +// +#define peaksBufferIndex 0 +double peaksBuffer[]; + +// +#property indicator_label1 "X121_XMAN PEAKS" +#property indicator_type1 DRAW_ARROW +#property indicator_color1 clrAqua +#property indicator_width1 1 + +// +// VALES ... + +// +#define valesBufferIndex 1 +double valesBuffer[]; + +// +#property indicator_label2 "X121_XMAN VALES" +#property indicator_type2 DRAW_ARROW +#property indicator_color2 clrMagenta +#property indicator_width2 1 + +// +#define rBufferIndex 2 +double rBuffer[]; + +// +#define rColorBufferIndex 3 +double rColorBuffer[]; + +// +#property indicator_label3 "X121_XMAN R" +#property indicator_type3 DRAW_COLOR_LINE +#property indicator_color3 CLR_NONE, clrAqua +#property indicator_style3 STYLE_DOT +#property indicator_width3 1 + +// +#define sBufferIndex 4 +#define sBufferPlotIndex 3 +double sBuffer[]; + +// +#define sColorBufferIndex 5 +double sColorBuffer[]; + +// +#property indicator_label4 "X121_XMAN S" +#property indicator_type4 DRAW_COLOR_LINE +#property indicator_color4 CLR_NONE, clrMagenta +#property indicator_style4 STYLE_DOT +#property indicator_width4 1 + +// +// FIBBO Level 1 ... + +// +#define fl1BufferIndex 6 +#define fl1BufferPlotIndex 4 +double fl1Buffer[]; + +// +#define fl1ColorBufferIndex 7 +double fl1ColorBuffer[]; + +// +#property indicator_label5 "X121_XMAN FL1" +#property indicator_type5 DRAW_COLOR_LINE +#property indicator_color5 CLR_NONE, clrGold +#property indicator_style5 STYLE_DASHDOTDOT +#property indicator_width5 1 + +// +// FIBBO Level 2 ... + +// +#define fl2BufferIndex 8 +#define fl2BufferPlotIndex 5 +double fl2Buffer[]; + +// +#define fl2ColorBufferIndex 9 +double fl2ColorBuffer[]; + +// +#property indicator_label6 "X121_XMAN FL2" +#property indicator_type6 DRAW_COLOR_LINE +#property indicator_color6 CLR_NONE, clrGold +#property indicator_style6 STYLE_DASHDOTDOT +#property indicator_width6 1 + +// +// FIBBO Level 3 ... + +// +#define fl3BufferIndex 10 +#define fl3BufferPlotIndex 6 +double fl3Buffer[]; + +// +#define fl3ColorBufferIndex 11 +double fl3ColorBuffer[]; + +// +#property indicator_label7 "X121_XMAN FL3" +#property indicator_type7 DRAW_COLOR_LINE +#property indicator_color7 CLR_NONE, clrGold +#property indicator_style7 STYLE_DASHDOTDOT +#property indicator_width7 1 + +// +// LEVELS ... + +// +#define sHHBufferIndex 12 +#define sHHBufferPlotIndex 7 +double sHHBuffer[]; + +// +#define sHHColorBufferIndex 13 +double sHHColorBuffer[]; + +// +#property indicator_label8 "X121_XMAN SHH" +#property indicator_type8 DRAW_COLOR_LINE +#property indicator_color8 CLR_NONE, clrLightGray, clrAqua, clrMagenta +#property indicator_style8 STYLE_DOT +#property indicator_width8 1 + +#define sLLBufferIndex 14 +#define sLLBufferPlotIndex 8 +double sLLBuffer[]; + +// +#define sLLColorBufferIndex 15 +double sLLColorBuffer[]; + +// +#property indicator_label9 "X121_XMAN SLL" +#property indicator_type9 DRAW_COLOR_LINE +#property indicator_color9 CLR_NONE, clrLightGray, clrAqua, clrMagenta +#property indicator_style9 STYLE_DOT +#property indicator_width9 1 + +// +#define mHHBufferIndex 16 +#define mHHBufferPlotIndex 9 +double mHHBuffer[]; + +// +#define mHHColorBufferIndex 17 +double mHHColorBuffer[]; + +// +#property indicator_label10 "X121_XMAN MHH" +#property indicator_type10 DRAW_COLOR_LINE +#property indicator_color10 CLR_NONE, clrLightGray, clrAqua, clrMagenta +#property indicator_style10 STYLE_DOT +#property indicator_width10 1 + +// +#define mLLBufferIndex 18 +#define mLLBufferPlotIndex 10 +double mLLBuffer[]; + +// +#define mLLColorBufferIndex 19 +double mLLColorBuffer[]; + +// +#property indicator_label11 "X121_XMAN MLL" +#property indicator_type11 DRAW_COLOR_LINE +#property indicator_color11 CLR_NONE, clrLightGray, clrAqua, clrMagenta +#property indicator_style11 STYLE_DOT +#property indicator_width11 1 + +// +#define lHHBufferIndex 20 +#define lHHBufferPlotIndex 11 +double lHHBuffer[]; + +// +#define lHHColorBufferIndex 21 +double lHHColorBuffer[]; + +// +#property indicator_label12 "X121_XMAN LHH" +#property indicator_type12 DRAW_COLOR_LINE +#property indicator_color12 CLR_NONE, clrLightGray, clrAqua, clrMagenta +#property indicator_style12 STYLE_DOT +#property indicator_width12 1 + +// +#define lLLBufferIndex 22 +#define lLLBufferPlotIndex 12 +double lLLBuffer[]; + +// +#define lLLColorBufferIndex 23 +double lLLColorBuffer[]; + +// +#property indicator_label13 "X121_XMAN LLL" +#property indicator_type13 DRAW_COLOR_LINE +#property indicator_color13 CLR_NONE, clrLightGray, clrAqua, clrMagenta +#property indicator_style13 STYLE_DOT +#property indicator_width13 1 + +// +#define hHHBufferIndex 24 +#define hHHBufferPlotIndex 13 +double hHHBuffer[]; + +// +#define hHHColorBufferIndex 25 +double hHHColorBuffer[]; + +// +#property indicator_label14 "X121_XMAN HHH" +#property indicator_type14 DRAW_COLOR_LINE +#property indicator_color14 CLR_NONE, clrLightGray, clrAqua, clrMagenta +#property indicator_style14 STYLE_DOT +#property indicator_width14 1 + +// +#define hLLBufferIndex 26 +#define hLLBufferPlotIndex 14 +double hLLBuffer[]; + +// +#define hLLColorBufferIndex 27 +double hLLColorBuffer[]; + +// +#property indicator_label15 "X121_XMAN HLL" +#property indicator_type15 DRAW_COLOR_LINE +#property indicator_color15 CLR_NONE, clrLightGray, clrAqua, clrMagenta +#property indicator_style15 STYLE_DOT +#property indicator_width15 1 + +// +// XSTR Buffers ... + +// +#define fillUpBufferIndex 28 +double fillUpBuffer[]; + +#define fillDownBufferIndex 29 +double fillDownBuffer[]; + +// +#define fillingBufferPlotIndex 15 + +// +#property indicator_label16 "X121_XMAN TRND Filling" +#property indicator_type16 DRAW_FILLING +#property indicator_color16 clrBisque, clrPaleGreen + +// +#define trendBufferIndex 30 +#define trendBufferPlotIndex 16 +double trendBuffer[]; + +// +#define trendColorBufferIndex 31 +double trendColorBuffer[]; + +// +#property indicator_label17 "X121_XMAN TRND" +#property indicator_type17 DRAW_COLOR_LINE +#property indicator_color17 CLR_NONE, clrGreen, clrDarkRed +#property indicator_style17 STYLE_DOT +#property indicator_width17 1 + +// +// XMRB ... + +// +// RIBBON 1 ... +// High ... + +// +#define ribbon1BufferIndex 32 +#define ribbon1BufferPlotIndex 17 +double ribbon1Buffer[]; + +// +#define ribbon1ColorBufferIndex 33 +double ribbon1ColorBuffer[]; + +// +#property indicator_label18 "X121_XMAN RB 1" +#property indicator_type18 DRAW_COLOR_LINE +#property indicator_color18 CLR_NONE, clrGray, clrGreen, clrDarkRed +#property indicator_style18 STYLE_DASH +#property indicator_width18 1 + +// +// RIBBON 2 ... +// Open ... + +// +#define ribbon2BufferIndex 34 +#define ribbon2BufferPlotIndex 18 +double ribbon2Buffer[]; + +// +#define ribbon2ColorBufferIndex 35 +double ribbon2ColorBuffer[]; + +// +#property indicator_label19 "X121_XMAN RB 2" +#property indicator_type19 DRAW_COLOR_LINE +#property indicator_color19 CLR_NONE, clrGray, clrGreen, clrDarkRed +#property indicator_style19 STYLE_DASH +#property indicator_width19 1 + +// +// RIBBON 3 ... +// Close ... + +// +#define ribbon3BufferIndex 36 +#define ribbon3BufferPlotIndex 19 +double ribbon3Buffer[]; + +// +#define ribbon3ColorBufferIndex 37 +double ribbon3ColorBuffer[]; + +// +#property indicator_label20 "X121_XMAN RB 3" +#property indicator_type20 DRAW_COLOR_LINE +#property indicator_color20 CLR_NONE, clrGray, clrGreen, clrDarkRed +#property indicator_style20 STYLE_DASH +#property indicator_width20 1 + +// +// RIBBON 4 ... +// Median ... + +// +#define ribbon4BufferIndex 38 +#define ribbon4BufferPlotIndex 20 +double ribbon4Buffer[]; + +// +#define ribbon4ColorBufferIndex 39 +double ribbon4ColorBuffer[]; + +// +#property indicator_label21 "X121_XMAN RB 4" +#property indicator_type21 DRAW_COLOR_LINE +#property indicator_color21 CLR_NONE, clrGray, clrGreen, clrDarkRed +#property indicator_style21 STYLE_DASH +#property indicator_width21 1 + +// +// RIBBON 5 ... +// Typical ... + +// +#define ribbon5BufferIndex 40 +#define ribbon5BufferPlotIndex 21 +double ribbon5Buffer[]; + +// +#define ribbon5ColorBufferIndex 41 +double ribbon5ColorBuffer[]; + +// +#property indicator_label22 "X121_XMAN RB 5" +#property indicator_type22 DRAW_COLOR_LINE +#property indicator_color22 CLR_NONE, clrGray, clrGreen, clrDarkRed +#property indicator_style22 STYLE_DASH +#property indicator_width22 1 + +// +// RIBBON 6 ... +// Low ... + +// +#define ribbon6BufferIndex 42 +#define ribbon6BufferPlotIndex 22 +double ribbon6Buffer[]; + +// +#define ribbon6ColorBufferIndex 43 +double ribbon6ColorBuffer[]; + +// +#property indicator_label23 "X121_XMAN RB 6" +#property indicator_type23 DRAW_COLOR_LINE +#property indicator_color23 CLR_NONE, clrGray, clrGreen, clrDarkRed +#property indicator_style23 STYLE_DASH +#property indicator_width23 1 + +// +// XSSLC ... + +// +#define sslcUpBufferIndex 44 +#define sslcUpBufferPlotIndex 23 +double sslcUpBuffer[]; + +// +#define sslcUpColorBufferIndex 45 +double sslcUpColorBuffer[]; + +// +#property indicator_label24 "X121_XMAN SSLC Up" +#property indicator_type24 DRAW_COLOR_LINE +#property indicator_color24 CLR_NONE, clrLime +#property indicator_style24 STYLE_SOLID +#property indicator_width24 1 + +// +#define sslcDownBufferIndex 46 +#define sslcDownBufferPlotIndex 24 +double sslcDownBuffer[]; + +// +#define sslcDownColorBufferIndex 47 +double sslcDownColorBuffer[]; + +// +#property indicator_label25 "X121_XMAN SSLC Down" +#property indicator_type25 DRAW_COLOR_LINE +#property indicator_color25 CLR_NONE, clrRed +#property indicator_style25 STYLE_SOLID +#property indicator_width25 1 + +// +// XHULL ... + +// +// UP Zone ... + +// +#define hullUpZoneBufferIndex 48 +#define hullUpZoneBufferPlotIndex 25 +#define hullUpZoneColorBufferIndex 49 + +// +double hullUpZoneBuffer[]; +double hullUpZoneColorBuffer[]; + +// +#property indicator_label26 "X121_XMAN HULL Up" +#property indicator_type26 DRAW_COLOR_LINE +#property indicator_color26 CLR_NONE, clrGray, clrAqua, clrMagenta +#property indicator_width26 1 + +// +// DOWN Zone ... + +// +#define hullDownZoneBufferIndex 50 +#define hullDownZoneBufferPlotIndex 26 +#define hullDownZoneColorBufferIndex 51 + +// +double hullDownZoneBuffer[]; +double hullDownZoneColorBuffer[]; + +// +#property indicator_label27 "X121_XMAN HULL Down" +#property indicator_type27 DRAW_COLOR_LINE +#property indicator_color27 CLR_NONE, clrGray, clrAqua, clrMagenta +#property indicator_width27 1 + +// +// Open ... +#define hkOpenBufferIndex 52 +double hkOpenBuffer[]; + +// +// High ... +#define hkHighBufferIndex 53 +double hkHighBuffer[]; + +// +// Low ... +#define hkLowBufferIndex 54 +double hkLowBuffer[]; + +// +// Close ... +#define hkCloseBufferIndex 55 +double hkCloseBuffer[]; + +// +// Candle Color ... +#define hkCandleColorBufferIndex 56 +double hkCandleColorBuffer[]; + +// +#define hkCandlesBufferIndex 27 + +// +#property indicator_label28 "X121_XMAN HK Open;X121_XMAN HK High;X121_XMAN HK Low;X121_XMAN HK Close" +#property indicator_type28 DRAW_COLOR_CANDLES +#property indicator_color28 CLR_NONE, clrAqua, clrMagenta + +// +// DATA Buffers ... + +#define lastBufferIndex 56 + +// +#define atrBufferIndex lastBufferIndex + 1 +double atrBuffer[]; + +// +#define trendStateBufferIndex lastBufferIndex + 2 +double trendStateBuffer[]; + +// +#define upBufferIndex lastBufferIndex + 3 +double upBuffer[]; + +// +#define downBufferIndex lastBufferIndex + 4 +double downBuffer[]; + +// +#define priceBufferIndex lastBufferIndex + 5 +double priceBuffer[]; + +// +#define sslcUpMaBufferIndex lastBufferIndex + 6 +double sslcUpMaBuffer[]; + +// +#define sslcDownMaBufferIndex lastBufferIndex + 7 +double sslcDownMaBuffer[]; + +// +#define sslcKpiBufferIndex lastBufferIndex + 8 +double sslcKpiBuffer[]; + +// +// STATE Buffers ... + +// +// When new Peaks Happens it's Valued otherwise EMPTY_VALUE ... +#define peaksStateBufferIndex lastBufferIndex + 9 +double peaksStateBuffer[]; + +// +// When new Vales Happens it's Valued otherwise EMPTY_VALUE ... +#define valesStateBufferIndex lastBufferIndex + 10 +double valesStateBuffer[]; + +// +// SHORT Cycle ... + +// +#define sHHStateBufferIndex lastBufferIndex + 11 +double sHHStateBuffer[]; + +// +#define sLLStateBufferIndex lastBufferIndex + 12 +double sLLStateBuffer[]; + +// +// MEDIUM Cycle ... + +// +#define mHHStateBufferIndex lastBufferIndex + 13 +double mHHStateBuffer[]; + +// +#define mLLStateBufferIndex lastBufferIndex + 14 +double mLLStateBuffer[]; + +// +// LONG Cycle ... + +// +#define lHHStateBufferIndex lastBufferIndex + 15 +double lHHStateBuffer[]; + +// +#define lLLStateBufferIndex lastBufferIndex + 16 +double lLLStateBuffer[]; + +// +// HIND Cycle ... + +// +#define hHHStateBufferIndex lastBufferIndex + 17 +double hHHStateBuffer[]; + +// +#define hLLStateBufferIndex lastBufferIndex + 18 +double hLLStateBuffer[]; + +// +// XSTR ... +#define strTrendStateBufferIndex lastBufferIndex + 19 +double strTrendStateBuffer[]; + +// +// XMRB ... + +// +// RIBBON 1 (High) ... +#define rb1StateBufferIndex lastBufferIndex + 20 +double rb1StateBuffer[]; + +// +// RIBBON 2 (Open) ... +#define rb2StateBufferIndex lastBufferIndex + 21 +double rb2StateBuffer[]; + +// +// RIBBON 3 (Close) ... +#define rb3StateBufferIndex lastBufferIndex + 22 +double rb3StateBuffer[]; + +// +// RIBBON 4 (Median) ... +#define rb4StateBufferIndex lastBufferIndex + 23 +double rb4StateBuffer[]; + +// +// RIBBON 5 (Typical) ... +#define rb5StateBufferIndex lastBufferIndex + 24 +double rb5StateBuffer[]; + +// +// RIBBON 6 (Low) ... +#define rb6StateBufferIndex lastBufferIndex + 25 +double rb6StateBuffer[]; + +// +// XHULL ... + +// +#define hullUpStateBufferIndex lastBufferIndex + 26 +double hullUpStateBuffer[]; + +// +#define hullDownStateBufferIndex lastBufferIndex + 27 +double hullDownStateBuffer[]; + +// +// END Buffers ... +// + +// +// START Global Definitions: Variables, Properties and etc ... +// + +// +int maxLength; + +// +double lastPeak; +double lastVale; + +// +double mLastSHH = 0; +double mLastSLL = 0; + +// +double mLastMHH = 0; +double mLastMLL = 0; + +// +double mLastLHH = 0; +double mLastLLL = 0; + +// +double mLastHHH = 0; +double mLastHLL = 0; + +// +double mHideColorIDX = 0; + +// +int currentPeriodSecconds = 0; + +// +// CYCLE 1 ... +int mL1Candles; +int mL1PeriodSecconds = 0; +int mLastL1StartBarIndex = 0; +datetime mLastL1StartTime = NULL; +ENUM_TIMEFRAMES mL1Period = NULL; + +// +// CYCLE 2 ... +int mL2Candles; +int mL2PeriodSecconds = 0; +int mLastL2StartBarIndex = 0; +datetime mLastL2StartTime = NULL; +ENUM_TIMEFRAMES mL2Period = NULL; + +// +// CYCLE 3 ... +int mL3Candles; +int mL3PeriodSecconds = 0; +int mLastL3StartBarIndex = 0; +datetime mLastL3StartTime = NULL; +ENUM_TIMEFRAMES mL3Period = NULL; + +// +// CYCLE 4 ... +int mL4Candles; +int mL4PeriodSecconds = 0; +int mLastL4StartBarIndex = 0; +datetime mLastL4StartTime = NULL; +ENUM_TIMEFRAMES mL4Period = NULL; + +// +// XSTR ... + +// +int atrHandler = INVALID_HANDLE; + +// +int changeOfTrend; +int startBearishTrend; +int startBullishTrend; + +// +int mStrLength; + +// +// XMRB ... + +int mMRBLength; +int mMRBAMAFast = 2; +int mMRBAMASlow = 30; + +// +int rb1Handler = INVALID_HANDLE; +int rb2Handler = INVALID_HANDLE; +int rb3Handler = INVALID_HANDLE; +int rb4Handler = INVALID_HANDLE; +int rb5Handler = INVALID_HANDLE; +int rb6Handler = INVALID_HANDLE; + +// +// XSSLC ... + +// +int mSSLCLength; + +// +int sslcUpHandler = INVALID_HANDLE; +int sslcDownHandler = INVALID_HANDLE; + +// +// XHULL ... + +// +int mHULLLength; + +// +XSCHull *mUpZHull; +XSCHull *mDownZHull; + +// +double mLastHullUpValue; +double mLastHullUpColorValue = 1; +double mLastHullDownValue; +double mLastHullDownColorValue = 1; + +// +// XCC ... + +// +XChartStyle chartStyle; +XChartStyle clearStyle; + +// +// END Global Definitions: Variables, Properties and etc ... +// + +// +// START Event Handlers ... +// + +// +// Initialization ... +int OnInit() +{ + // + // Validate Inputs ... + if (!ValidateInputs()) + { + return INIT_PARAMETERS_INCORRECT; + } + + // + // Initial Periods ... + InitialCycles(); + + // + drawPrefix = ShortName; + + // + // 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(); + + // + // We Can Choose ATR Length based on Other Cycles ... + mStrLength = mL4Candles; + atrHandler = iATR( + _Symbol, + _Period, + mStrLength); + if (atrHandler == INVALID_HANDLE) + { + return INIT_FAILED; + } + + // + mMRBLength = mL4Candles; + if (!InitRibbons()) + { + return INIT_FAILED; + } + + // + mSSLCLength = mL4Candles; + if (!InitSSLChannel()) + { + return INIT_FAILED; + } + + // + mHULLLength = mL4Candles; + if (!InitHullTrend()) + { + return INIT_FAILED; + } + + // + // Define Index Buffers ... + DefineBuffers(); + + // + // Set Indicator ShortName ... + SetIndicatorName(); + + // + // Apply Chart Style ... + ApplyCustomChartStyle(); + + // + // Init Succeed ... + 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 + + // + // Here we can handle De Initialization Reasons ... + IndicatorRelease(atrHandler); + + // + // XMRB ... + IndicatorRelease(rb1Handler); + IndicatorRelease(rb2Handler); + IndicatorRelease(rb3Handler); + IndicatorRelease(rb4Handler); + IndicatorRelease(rb5Handler); + IndicatorRelease(rb6Handler); + + // + // XSSLC ... + IndicatorRelease(sslcUpHandler); + IndicatorRelease(sslcDownHandler); + + // + // XHULL ... + delete mUpZHull; + delete mDownZHull; + + // + Comment(""); +} + +// +// Calculating what we want ... +int OnCalculate( + // + // total Candles on chart ... + const int rates_total, + // + // total calculated Candles on charts ... + const int prev_calculated, + // + // history of Candles Open Time ... + const datetime &time[], + // + // history of Candles Open Price ... + const double &open[], + // + // history of Candles High Price ... + const double &high[], + // + // history of Candles Low Price ... + const double &low[], + // + // history of Candles Close Price ... + const double &close[], + // + // history of Tick Volumes on Candle ... + const long &tick_volume[], + // + // history of Trade Volumes ... + const long &volume[], + // + // history of Candles Spread Price ... + const int &spread[]) +{ + // + // this counts Available Bars ... + int limit; + + // + limit = prev_calculated - 1; + if (limit < 0) + { + limit = 0; + } + + // + // Main Loop ... + for (int i = limit; i < rates_total && !IsStopped(); i++) + { + // + double upPrice = GetAppliedPrice( + hullUpAppliedTo, + open, high, low, close, i); + + // + double downPrice = GetAppliedPrice( + hullDownAppliedTo, + open, high, low, close, i); + + // + CalculateHull(i, rates_total, upPrice, downPrice); + } + + // + bool isXSTRCalculated = CalculateXSTR( + rates_total, + prev_calculated, + open, + high, + low, + close); + if (!isXSTRCalculated) + { + return prev_calculated; + } + + // + // 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); + + // + // Checking Handlers Calculated Bars ... + + // + // XMRB ... + int rb1CalculatedBars = BarsCalculated(rb1Handler); + int rb2CalculatedBars = BarsCalculated(rb2Handler); + int rb3CalculatedBars = BarsCalculated(rb3Handler); + int rb4CalculatedBars = BarsCalculated(rb4Handler); + int rb5CalculatedBars = BarsCalculated(rb5Handler); + int rb6CalculatedBars = BarsCalculated(rb6Handler); + + // + // XSSLC ... + int sslcUpCalculatedBars = BarsCalculated(sslcUpHandler); + int sslcDownCalculatedBars = BarsCalculated(sslcDownHandler); + + // + bool isCalculatedBarsNotPassed = + // + // XMRB ... + rb1CalculatedBars < maxLength || + rb2CalculatedBars < maxLength || + rb3CalculatedBars < maxLength || + rb4CalculatedBars < maxLength || + rb5CalculatedBars < maxLength || + rb6CalculatedBars < maxLength || + // + // XSSLC ... + sslcUpCalculatedBars < maxLength || + sslcDownCalculatedBars < maxLength + // + ; + + // + if (isCalculatedBarsNotPassed) + { + return prev_calculated; + } + + // + limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1; + + // + // Check Handlers Copied Bars ... + + // + // XMRB ... + int rb1CopiedBars = CopyBuffer(rb1Handler, 0, 0, limit, ribbon1Buffer); + int rb2CopiedBars = CopyBuffer(rb2Handler, 0, 0, limit, ribbon2Buffer); + int rb3CopiedBars = CopyBuffer(rb3Handler, 0, 0, limit, ribbon3Buffer); + int rb4CopiedBars = CopyBuffer(rb4Handler, 0, 0, limit, ribbon4Buffer); + int rb5CopiedBars = CopyBuffer(rb5Handler, 0, 0, limit, ribbon5Buffer); + int rb6CopiedBars = CopyBuffer(rb6Handler, 0, 0, limit, ribbon6Buffer); + + // + // XSSLC ... + int sslcUpCopiedBars = CopyBuffer(sslcUpHandler, 0, 0, limit, sslcUpMaBuffer); + int sslcDownCopiedBars = CopyBuffer(sslcDownHandler, 0, 0, limit, sslcDownMaBuffer); + + // + bool isCopiedBarsNotPassed = + // + // XMRB ... + rb1CopiedBars < 0 || + rb2CopiedBars < 0 || + rb3CopiedBars < 0 || + rb4CopiedBars < 0 || + rb5CopiedBars < 0 || + rb6CopiedBars < 0 || + // + // XSSLC ... + sslcUpCopiedBars < 0 || + sslcDownCopiedBars < 0 + // + ; + + // + if (isCopiedBarsNotPassed) + { + return prev_calculated; + } + + // + // Main Loop ... + for (int i = limit - 1; i >= 0 && !IsStopped(); i--) + { + // + CalculateBuffers(i); + + // + CalculateRibbonsColors(i, low, high); + + // + CalculateHikenAshi(i, prev_calculated, rates_total, open, high, close, low); + + // + CalculateSSLC(i, limit, rates_total, prev_calculated, close); + } + + // + return rates_total; +} + +// +// END Event Handlers ... +// + +// +// START Functions ... +// + +// +// Validate Input Args for Initialization ... +bool ValidateInputs() +{ + // + bool result = true; + + // + // Validate User Inputs ... + result = + // + // L1 ... + // Short Cycle ... + ( + // + l1Method == X_PERIOD_AUTO + ? l1Period == NULL + : l1Period != NULL && l1Method != X_PERIOD_NOTHING + // + ) + // + && + // + // L2 ... + // Medium Cycle ... + ( + // + l2Method == X_PERIOD_AUTO + ? l2Period == NULL + : l2Period != NULL && l2Method != X_PERIOD_NOTHING + // + ) + // + && + // + // L3 ... + // Long Cycle ... + ( + // + l3Method == X_PERIOD_AUTO + ? l3Period == NULL + : l3Period != NULL && l3Method != X_PERIOD_NOTHING + // + ) + // + && + // + // L4 ... + // Hind Cycle ... + ( + // + l4Method == X_PERIOD_AUTO + ? l4Period == NULL + : l4Period != NULL && l4Method != X_PERIOD_NOTHING + // + ) + // + && + // + // Validate Ribbon ... + ( + // + ribbonMode != X_MA_NOTHING + // + ) + // + ; + + // + return result; +} + +// +// Retrieve all Exists Input Max Length ... +// use for Start Of Drawing ... +int ExtractMaxLengthOfInputs() +{ + // + int result = 1; + + // + result = MathMax(result, mL1Candles); + result = MathMax(result, mL2Candles); + result = MathMax(result, mL3Candles); + result = MathMax(result, mL4Candles); + + // + return result; +} + +// +// Initial Multi Time Frame Cycles Periods ... +void InitialCycles() +{ + // + // Calculate Current Period Secconds ... + currentPeriodSecconds = PeriodSeconds(_Period); + + // + // Nearest ... + // Calculate Cycle 1 Requirements ... + if (mL1Period == NULL) + { + // + if (l1Method == X_PERIOD_AUTO) + { + mL1Period = GetNearestTimeFrame(_Period); + } + else + { + mL1Period = l1Period; + } + + // + mL1PeriodSecconds = PeriodSeconds(mL1Period); + + // + mL1Candles = mL1PeriodSecconds / currentPeriodSecconds; + } + + // + // Mediest ... + // Calculate Cycle 2 Requirements ... + if (mL2Period == NULL) + { + // + if (l2Method == X_PERIOD_AUTO) + { + mL2Period = GetMediestTimeFrame(_Period); + } + else + { + mL2Period = l2Period; + } + + // + mL2PeriodSecconds = PeriodSeconds(mL2Period); + + // + mL2Candles = mL2PeriodSecconds / currentPeriodSecconds; + } + + // + // Farest ... + // Calculate Cycle 3 Requirements ... + if (mL3Period == NULL) + { + // + if (l3Method == X_PERIOD_AUTO) + { + mL3Period = GetFarestTimeFrame(_Period); + } + else + { + mL3Period = l3Period; + } + + // + mL3PeriodSecconds = PeriodSeconds(mL3Period); + + // + mL3Candles = mL3PeriodSecconds / currentPeriodSecconds; + } + + // + // HindMost ... + // Calculate Cycle 4 Requirements ... + if (mL4Period == NULL) + { + // + if (l4Method == X_PERIOD_AUTO) + { + mL4Period = GetHindmostTimeFrame(_Period); + } + else + { + mL4Period = l4Period; + } + + // + mL4PeriodSecconds = PeriodSeconds(mL4Period); + + // + mL4Candles = mL4PeriodSecconds / currentPeriodSecconds; + } + + // + string comment = GenerateCyclesRepresentation(); + Comment(comment); +} + +// +bool InitRibbons() +{ + // + bool result = false; + + // + if (mMRBLength <= 0) + { + return result; + } + + // + // RIBBON 1 ... + // High ... + result = InitMaHandler( + rb1Handler, + mMRBLength, + ribbonMode, + PRICE_HIGH); + if (!result) + { + return result; + } + + // + // RIBBON 2 ... + // Open ... + result = InitMaHandler( + rb2Handler, + mMRBLength, + ribbonMode, + PRICE_OPEN); + if (!result) + { + return result; + } + + // + // RIBBON 3 ... + // Close ... + result = InitMaHandler( + rb3Handler, + mMRBLength, + ribbonMode, + PRICE_CLOSE); + if (!result) + { + return result; + } + + // + // RIBBON 4 ... + // Median ... + result = InitMaHandler( + rb4Handler, + mMRBLength, + ribbonMode, + PRICE_MEDIAN); + if (!result) + { + return result; + } + + // + // RIBBON 5 ... + // Typical ... + result = InitMaHandler( + rb5Handler, + mMRBLength, + ribbonMode, + PRICE_TYPICAL); + if (!result) + { + return result; + } + + // + // RIBBON 6 ... + // Low ... + result = InitMaHandler( + rb6Handler, + mMRBLength, + ribbonMode, + PRICE_LOW); + + // + return result; +} + +// +bool InitSSLChannel() +{ + // + bool result = false; + + // + if (mSSLCLength <= 0) + { + return result; + } + + // + // SSLUP ... + result = InitMaHandler( + sslcUpHandler, + mSSLCLength, + sslcMode, + sslcUpAppliedTo); + if (!result) + { + return result; + } + + // + // SSLDOWN ... + result = InitMaHandler( + sslcDownHandler, + mSSLCLength, + sslcMode, + sslcDownAppliedTo); + + // + return result; +} + +// +bool InitHullTrend() +{ + // + bool result = false; + + // + if (mHULLLength <= 0) + { + return result; + } + + // + mUpZHull = new XSCHull(); + mUpZHull.Init( + mHULLLength, + hullDivisor); + + // + mDownZHull = new XSCHull(); + mDownZHull.Init( + mHULLLength, + hullDivisor); + + // + result = true; + + // + return result; +} + +// +// Define Indexes and Styles ... +void DefineBuffers() +{ + // + // RANGE ... + + // + // PEAKS and VALES ... + ENUM_DRAW_TYPE pvDrawType = showPeaksAndVales ? DRAW_ARROW : DRAW_NONE; + + // + // PEAKS ... + ArraySetAsSeries(peaksBuffer, true); + SetIndexBuffer(peaksBufferIndex, peaksBuffer, INDICATOR_DATA); + PlotIndexSetInteger(peaksBufferIndex, PLOT_ARROW, 225); + PlotIndexSetDouble(peaksBufferIndex, PLOT_EMPTY_VALUE, 0); + + // + PlotIndexSetInteger(peaksBufferIndex, PLOT_SHOW_DATA, showPeaksAndVales); + PlotIndexSetInteger(peaksBufferIndex, PLOT_DRAW_TYPE, pvDrawType); + + // + // VALES ... + ArraySetAsSeries(valesBuffer, true); + SetIndexBuffer(valesBufferIndex, valesBuffer, INDICATOR_DATA); + PlotIndexSetInteger(valesBufferIndex, PLOT_ARROW, 225); + PlotIndexSetDouble(valesBufferIndex, PLOT_EMPTY_VALUE, 0); + + // + PlotIndexSetInteger(valesBufferIndex, PLOT_SHOW_DATA, showPeaksAndVales); + PlotIndexSetInteger(valesBufferIndex, PLOT_DRAW_TYPE, pvDrawType); + + // + // SUPPORT and RESISTANCE ... + // + + // + // RESISTANCE ... + ArraySetAsSeries(rBuffer, true); + SetIndexBuffer(rBufferIndex, rBuffer, INDICATOR_DATA); + PlotIndexSetInteger(rBufferIndex, PLOT_SHOW_DATA, false); + PlotIndexSetInteger(rBufferIndex, PLOT_DRAW_BEGIN, maxLength); + + // + // RESISTANCE Color ... + ArraySetAsSeries(rColorBuffer, true); + SetIndexBuffer(rColorBufferIndex, rColorBuffer, INDICATOR_COLOR_INDEX); + + // + // SUPPORT ... + ArraySetAsSeries(sBuffer, true); + SetIndexBuffer(sBufferIndex, sBuffer, INDICATOR_DATA); + PlotIndexSetInteger(sBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(sBufferPlotIndex, PLOT_SHOW_DATA, false); + + // + // SUPPORT Color ... + ArraySetAsSeries(sColorBuffer, true); + SetIndexBuffer(sColorBufferIndex, sColorBuffer, INDICATOR_COLOR_INDEX); + + // + // FIBBO Levels ... + + // + // LEVEL 1 ... + + // + // Buffer ... + ArraySetAsSeries(fl1Buffer, true); + SetIndexBuffer(fl1BufferIndex, fl1Buffer, INDICATOR_DATA); + PlotIndexSetInteger(fl1BufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(fl1BufferPlotIndex, PLOT_SHOW_DATA, showFibo1Levels); + + // + // Color ... + ArraySetAsSeries(fl1ColorBuffer, true); + SetIndexBuffer(fl1ColorBufferIndex, fl1ColorBuffer, INDICATOR_COLOR_INDEX); + + // + // LEVEL 2 ... + + // + // BULLISH ... + ArraySetAsSeries(fl2Buffer, true); + SetIndexBuffer(fl2BufferIndex, fl2Buffer, INDICATOR_DATA); + PlotIndexSetInteger(fl2BufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(fl2BufferPlotIndex, PLOT_SHOW_DATA, showFibo2Levels); + + // + // BULLISH Color ... + ArraySetAsSeries(fl2ColorBuffer, true); + SetIndexBuffer(fl2ColorBufferIndex, fl2ColorBuffer, INDICATOR_COLOR_INDEX); + + // + // LEVEL 3 ... + + // + // BULLISH ... + ArraySetAsSeries(fl3Buffer, true); + SetIndexBuffer(fl3BufferIndex, fl3Buffer, INDICATOR_DATA); + PlotIndexSetInteger(fl3BufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(fl3BufferPlotIndex, PLOT_SHOW_DATA, showFibo3Levels); + + // + // BULLISH Color ... + ArraySetAsSeries(fl3ColorBuffer, true); + SetIndexBuffer(fl3ColorBufferIndex, fl3ColorBuffer, INDICATOR_COLOR_INDEX); + + // + // SHORT Buffers ... + + // + // HIGH ... + ArraySetAsSeries(sHHBuffer, true); + SetIndexBuffer(sHHBufferIndex, sHHBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(sHHBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(sHHBufferPlotIndex, PLOT_SHOW_DATA, showLevels); + + // + ArraySetAsSeries(sHHColorBuffer, true); + SetIndexBuffer(sHHColorBufferIndex, sHHColorBuffer, INDICATOR_COLOR_INDEX); + + // + // LOW ... + ArraySetAsSeries(sLLBuffer, true); + SetIndexBuffer(sLLBufferIndex, sLLBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(sLLBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(sLLBufferPlotIndex, PLOT_SHOW_DATA, showLevels); + + // + ArraySetAsSeries(sLLColorBuffer, true); + SetIndexBuffer(sLLColorBufferIndex, sLLColorBuffer, INDICATOR_COLOR_INDEX); + + // + // MEDIUM Buffer ... + + // + // HIGH ... + ArraySetAsSeries(mHHBuffer, true); + SetIndexBuffer(mHHBufferIndex, mHHBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(mHHBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(mHHBufferPlotIndex, PLOT_SHOW_DATA, showLevels); + + // + ArraySetAsSeries(mHHColorBuffer, true); + SetIndexBuffer(mHHColorBufferIndex, mHHColorBuffer, INDICATOR_COLOR_INDEX); + + // + // LOW ... + ArraySetAsSeries(mLLBuffer, true); + SetIndexBuffer(mLLBufferIndex, mLLBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(mLLBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(mLLBufferPlotIndex, PLOT_SHOW_DATA, showLevels); + + // + ArraySetAsSeries(mLLColorBuffer, true); + SetIndexBuffer(mLLColorBufferIndex, mLLColorBuffer, INDICATOR_COLOR_INDEX); + + // + // LONG Buffer ... + + // + // HIGH ... + ArraySetAsSeries(lHHBuffer, true); + SetIndexBuffer(lHHBufferIndex, lHHBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(lHHBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(lHHBufferPlotIndex, PLOT_SHOW_DATA, showLevels); + + // + ArraySetAsSeries(lHHColorBuffer, true); + SetIndexBuffer(lHHColorBufferIndex, lHHColorBuffer, INDICATOR_COLOR_INDEX); + + // + // LOW ... + ArraySetAsSeries(lLLBuffer, true); + SetIndexBuffer(lLLBufferIndex, lLLBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(lLLBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(lLLBufferPlotIndex, PLOT_SHOW_DATA, showLevels); + + // + ArraySetAsSeries(lLLColorBuffer, true); + SetIndexBuffer(lLLColorBufferIndex, lLLColorBuffer, INDICATOR_COLOR_INDEX); + + // + // HIND Buffer ... + + // + // HIGH ... + ArraySetAsSeries(hHHBuffer, true); + SetIndexBuffer(hHHBufferIndex, hHHBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(hHHBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(hHHBufferPlotIndex, PLOT_SHOW_DATA, showLevels); + + // + ArraySetAsSeries(hHHColorBuffer, true); + SetIndexBuffer(hHHColorBufferIndex, hHHColorBuffer, INDICATOR_COLOR_INDEX); + + // + // LOW ... + ArraySetAsSeries(hLLBuffer, true); + SetIndexBuffer(hLLBufferIndex, hLLBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(hLLBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(hLLBufferPlotIndex, PLOT_SHOW_DATA, showLevels); + + // + ArraySetAsSeries(hLLColorBuffer, true); + SetIndexBuffer(hLLColorBufferIndex, hLLColorBuffer, INDICATOR_COLOR_INDEX); + + // + // XSTR ... + + // + // FILLINGS ... + SetIndexBuffer(fillUpBufferIndex, fillUpBuffer, INDICATOR_DATA); + SetIndexBuffer(fillDownBufferIndex, fillDownBuffer, INDICATOR_DATA); + PlotIndexSetInteger(fillingBufferPlotIndex, PLOT_SHOW_DATA, false); + + // + // MAIN ... + SetIndexBuffer(trendBufferIndex, trendBuffer, INDICATOR_DATA); + PlotIndexSetInteger(trendBufferPlotIndex, PLOT_SHOW_DATA, showTrends); + SetIndexBuffer(trendColorBufferIndex, trendColorBuffer, INDICATOR_COLOR_INDEX); + + // + // RIBBON 1 ... + + // + ArraySetAsSeries(ribbon1Buffer, true); + SetIndexBuffer(ribbon1BufferIndex, ribbon1Buffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(ribbon1BufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(ribbon1BufferPlotIndex, PLOT_SHOW_DATA, showRibbons); + + // + ArraySetAsSeries(ribbon1ColorBuffer, true); + SetIndexBuffer(ribbon1ColorBufferIndex, ribbon1ColorBuffer, INDICATOR_COLOR_INDEX); + + // + // RIBBON 2 ... + + // + ArraySetAsSeries(ribbon2Buffer, true); + SetIndexBuffer(ribbon2BufferIndex, ribbon2Buffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(ribbon2BufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(ribbon2BufferPlotIndex, PLOT_SHOW_DATA, showRibbons); + + // + ArraySetAsSeries(ribbon2ColorBuffer, true); + SetIndexBuffer(ribbon2ColorBufferIndex, ribbon2ColorBuffer, INDICATOR_COLOR_INDEX); + + // + // RIBBON 3 ... + + // + ArraySetAsSeries(ribbon3Buffer, true); + SetIndexBuffer(ribbon3BufferIndex, ribbon3Buffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(ribbon3BufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(ribbon3BufferPlotIndex, PLOT_SHOW_DATA, showRibbons); + + // + ArraySetAsSeries(ribbon3ColorBuffer, true); + SetIndexBuffer(ribbon3ColorBufferIndex, ribbon3ColorBuffer, INDICATOR_COLOR_INDEX); + + // + // RIBBON 4 ... + + // + ArraySetAsSeries(ribbon4Buffer, true); + SetIndexBuffer(ribbon4BufferIndex, ribbon4Buffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(ribbon4BufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(ribbon4BufferPlotIndex, PLOT_SHOW_DATA, showRibbons); + + // + ArraySetAsSeries(ribbon4ColorBuffer, true); + SetIndexBuffer(ribbon4ColorBufferIndex, ribbon4ColorBuffer, INDICATOR_COLOR_INDEX); + + // + // RIBBON 5 ... + + // + ArraySetAsSeries(ribbon5Buffer, true); + SetIndexBuffer(ribbon5BufferIndex, ribbon5Buffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(ribbon5BufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(ribbon5BufferPlotIndex, PLOT_SHOW_DATA, showRibbons); + + // + ArraySetAsSeries(ribbon5ColorBuffer, true); + SetIndexBuffer(ribbon5ColorBufferIndex, ribbon5ColorBuffer, INDICATOR_COLOR_INDEX); + + // + // RIBBON 6 ... + + // + ArraySetAsSeries(ribbon6Buffer, true); + SetIndexBuffer(ribbon6BufferIndex, ribbon6Buffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(ribbon6BufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(ribbon6BufferPlotIndex, PLOT_SHOW_DATA, showRibbons); + + // + ArraySetAsSeries(ribbon6ColorBuffer, true); + SetIndexBuffer(ribbon6ColorBufferIndex, ribbon6ColorBuffer, INDICATOR_COLOR_INDEX); + + // + // XSSLC ... + + // + // UP ... + + // + ArraySetAsSeries(sslcUpBuffer, true); + SetIndexBuffer(sslcUpBufferIndex, sslcUpBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(sslcUpBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(sslcUpBufferPlotIndex, PLOT_SHOW_DATA, showSSLChannel); + + // + ArraySetAsSeries(sslcUpColorBuffer, true); + SetIndexBuffer(sslcUpColorBufferIndex, sslcUpColorBuffer, INDICATOR_COLOR_INDEX); + + // + // DOWN ... + + // + ArraySetAsSeries(sslcDownBuffer, true); + SetIndexBuffer(sslcDownBufferIndex, sslcDownBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(sslcDownBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(sslcDownBufferPlotIndex, PLOT_SHOW_DATA, showSSLChannel); + + // + ArraySetAsSeries(sslcDownColorBuffer, true); + SetIndexBuffer(sslcDownColorBufferIndex, sslcDownColorBuffer, INDICATOR_COLOR_INDEX); + + // + // XHULL ... + + // + // UP ... + + // + SetIndexBuffer(hullUpZoneBufferIndex, hullUpZoneBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(hullUpZoneBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(hullUpZoneBufferPlotIndex, PLOT_SHOW_DATA, showHull); + + // + SetIndexBuffer(hullUpZoneColorBufferIndex, hullUpZoneColorBuffer, INDICATOR_COLOR_INDEX); + + // + // DOWN ... + + // + SetIndexBuffer(hullDownZoneBufferIndex, hullDownZoneBuffer, INDICATOR_DATA); + + // + PlotIndexSetInteger(hullDownZoneBufferPlotIndex, PLOT_DRAW_BEGIN, maxLength); + PlotIndexSetInteger(hullDownZoneBufferPlotIndex, PLOT_SHOW_DATA, showHull); + + // + SetIndexBuffer(hullDownZoneColorBufferIndex, hullDownZoneColorBuffer, INDICATOR_COLOR_INDEX); + + // + // XHK ... + + // + // Candles Color ... + ArraySetAsSeries(hkCandleColorBuffer, true); + SetIndexBuffer(hkCandleColorBufferIndex, hkCandleColorBuffer, INDICATOR_COLOR_INDEX); + + // + // Set EMPTY_VALUE on Candles Buffer ... + PlotIndexSetDouble(hkCandlesBufferIndex, PLOT_EMPTY_VALUE, 0.0); + + // + PlotIndexSetInteger(hkCandlesBufferIndex, PLOT_SHOW_DATA, false); + PlotIndexSetInteger(hkCandleColorBufferIndex, PLOT_SHOW_DATA, false); + + // + // Open ... + ArraySetAsSeries(hkOpenBuffer, true); + PlotIndexSetInteger(hkOpenBufferIndex, PLOT_SHOW_DATA, false); + SetIndexBuffer(hkOpenBufferIndex, hkOpenBuffer, INDICATOR_DATA); + + // + // High ... + ArraySetAsSeries(hkHighBuffer, true); + SetIndexBuffer(hkHighBufferIndex, hkHighBuffer, INDICATOR_DATA); + PlotIndexSetInteger(hkHighBufferIndex, PLOT_SHOW_DATA, false); + + // + // Close ... + ArraySetAsSeries(hkCloseBuffer, true); + SetIndexBuffer(hkCloseBufferIndex, hkCloseBuffer, INDICATOR_DATA); + PlotIndexSetInteger(hkCloseBufferIndex, PLOT_SHOW_DATA, false); + + // + // Low ... + ArraySetAsSeries(hkLowBuffer, true); + SetIndexBuffer(hkLowBufferIndex, hkLowBuffer, INDICATOR_DATA); + PlotIndexSetInteger(hkLowBufferIndex, PLOT_SHOW_DATA, false); + + // + // DATA Buffers ... + + // + // ATR ... + SetIndexBuffer(atrBufferIndex, atrBuffer, INDICATOR_CALCULATIONS); + + // + // TREND ... + SetIndexBuffer(trendStateBufferIndex, trendStateBuffer, INDICATOR_CALCULATIONS); + + // + // UP ... + SetIndexBuffer(upBufferIndex, upBuffer, INDICATOR_CALCULATIONS); + + // + // DOWN ... + SetIndexBuffer(downBufferIndex, downBuffer, INDICATOR_CALCULATIONS); + + // + // PRICE ... + SetIndexBuffer(priceBufferIndex, priceBuffer, INDICATOR_CALCULATIONS); + + // + // SSLCDOWNMA ... + ArraySetAsSeries(sslcUpMaBuffer, true); + SetIndexBuffer(sslcUpMaBufferIndex, sslcUpMaBuffer, INDICATOR_CALCULATIONS); + + // + // SSLCUPMA ... + ArraySetAsSeries(sslcDownMaBuffer, true); + SetIndexBuffer(sslcDownMaBufferIndex, sslcDownMaBuffer, INDICATOR_CALCULATIONS); + + // + // SSLCKPI ... + ArraySetAsSeries(sslcKpiBuffer, true); + SetIndexBuffer(sslcKpiBufferIndex, sslcKpiBuffer, INDICATOR_CALCULATIONS); + + // + // STATE Buffers ... + + // + // PEAKS ... + ArraySetAsSeries(peaksStateBuffer, true); + SetIndexBuffer(peaksStateBufferIndex, peaksStateBuffer, INDICATOR_CALCULATIONS); + + // + // VALES ... + ArraySetAsSeries(valesStateBuffer, true); + SetIndexBuffer(valesStateBufferIndex, valesStateBuffer, INDICATOR_CALCULATIONS); + + // + // CYCLES ... + + // + // SHORT ... + + // + ArraySetAsSeries(sHHStateBuffer, true); + SetIndexBuffer(sHHStateBufferIndex, sHHStateBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(sLLStateBuffer, true); + SetIndexBuffer(sLLStateBufferIndex, sLLStateBuffer, INDICATOR_CALCULATIONS); + + // + // MEDIUM ... + + // + ArraySetAsSeries(mHHStateBuffer, true); + SetIndexBuffer(mHHStateBufferIndex, mHHStateBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(mLLStateBuffer, true); + SetIndexBuffer(mLLStateBufferIndex, mLLStateBuffer, INDICATOR_CALCULATIONS); + + // + // LONG ... + + // + ArraySetAsSeries(lHHStateBuffer, true); + SetIndexBuffer(lHHStateBufferIndex, lHHStateBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(lLLStateBuffer, true); + SetIndexBuffer(lLLStateBufferIndex, lLLStateBuffer, INDICATOR_CALCULATIONS); + + // + // HIND ... + + // + ArraySetAsSeries(hHHStateBuffer, true); + SetIndexBuffer(hHHStateBufferIndex, hHHStateBuffer, INDICATOR_CALCULATIONS); + + // + ArraySetAsSeries(hLLStateBuffer, true); + SetIndexBuffer(hLLStateBufferIndex, hLLStateBuffer, INDICATOR_CALCULATIONS); + + // + // XSTR ... + SetIndexBuffer(strTrendStateBufferIndex, strTrendStateBuffer, INDICATOR_CALCULATIONS); + + // + // XMBR ... + + // + // RIBBON 1 _ (High) ... + ArraySetAsSeries(rb1StateBuffer, true); + SetIndexBuffer(rb1StateBufferIndex, rb1StateBuffer, INDICATOR_CALCULATIONS); + + // + // RIBBON 2 _ (Open) ... + ArraySetAsSeries(rb2StateBuffer, true); + SetIndexBuffer(rb2StateBufferIndex, rb2StateBuffer, INDICATOR_CALCULATIONS); + + // + // RIBBON 3 _ (Close) ... + ArraySetAsSeries(rb3StateBuffer, true); + SetIndexBuffer(rb3StateBufferIndex, rb3StateBuffer, INDICATOR_CALCULATIONS); + + // + // RIBBON 4 _ (Median) ... + ArraySetAsSeries(rb4StateBuffer, true); + SetIndexBuffer(rb4StateBufferIndex, rb4StateBuffer, INDICATOR_CALCULATIONS); + + // + // RIBBON 5 _ (Typical) ... + ArraySetAsSeries(rb5StateBuffer, true); + SetIndexBuffer(rb5StateBufferIndex, rb5StateBuffer, INDICATOR_CALCULATIONS); + + // + // RIBBON 6 _ (Low) ... + ArraySetAsSeries(rb6StateBuffer, true); + SetIndexBuffer(rb6StateBufferIndex, rb6StateBuffer, INDICATOR_CALCULATIONS); + + // + // XHULL ... + + // + // UP Zone ... + SetIndexBuffer(hullUpStateBufferIndex, hullUpStateBuffer, INDICATOR_CALCULATIONS); + + // + // DOWN Zone ... + SetIndexBuffer(hullDownStateBufferIndex, hullDownStateBuffer, INDICATOR_CALCULATIONS); +} + +// +// Set Indicator Short Name and also we can define Buffers Labels ... +void SetIndicatorName() +{ + IndicatorSetString(INDICATOR_SHORTNAME, ShortName); +} + +// +// Calculate Buffers ... +void CalculateBuffers( + int bar_index // Selected Bar Index +) +{ + // + // Calculate ... + + // + // Calculate Short Cycle ... + CalculateShortCycle(bar_index); + + // + // Calculate Medium Cycle ... + CalculateMediumCycle(bar_index); + + // + // Calculate Long Cycle ... + CalculateLongCycle(bar_index); + + // + // Calculate Hind Cycle ... + CalculateHindCycle(bar_index); + + // + // Calculate Peaks and Vales ... + CalculatePeaksAndVales(bar_index); + + // + // Calculate Fibonnaci ... + CalculateFibonacci(bar_index); +} + +// +// START Calculation Parts ... +// + +// +// SHORT Cycle ... +void CalculateShortCycle( + int bar_index // Selected Bar Index +) +{ + // + ENUM_TIMEFRAMES mPeriod = mL1Period; + + // + double hhValue = GetCycleHHC( + bar_index, + mPeriod); + + // + double llValue = GetCycleLLC( + bar_index, + mPeriod); + + // + double lastHH = mLastSHH; + double lastLL = mLastSLL; + + // + double mHHState = EMPTY_VALUE; + double mhhColorIDX = mHideColorIDX; + if (showLevels) + { + // + if (hhValue == lastHH) + { + mhhColorIDX = showConsolidations ? 1 : mHideColorIDX; + } + else if (hhValue > lastHH) + { + mhhColorIDX = 2; + } + else if (hhValue < lastHH) + { + mhhColorIDX = 3; + } + + // + mHHState = mhhColorIDX; + } + else + { + mhhColorIDX = mHideColorIDX; + } + + // + double mLLState = EMPTY_VALUE; + double mllColorIDX = mHideColorIDX; + if (showLevels) + { + // + if (llValue == lastLL) + { + mllColorIDX = showConsolidations ? 1 : mHideColorIDX; + } + else if (llValue > lastLL) + { + mllColorIDX = 2; + } + else if (llValue < lastLL) + { + mllColorIDX = 3; + } + + // + mLLState = mllColorIDX; + } + else + { + mllColorIDX = mHideColorIDX; + } + + // + mLastSHH = hhValue; + mLastSLL = llValue; + + // + sHHBuffer[bar_index] = hhValue; + sLLBuffer[bar_index] = llValue; + sHHStateBuffer[bar_index] = mHHState; + sLLStateBuffer[bar_index] = mLLState; + sHHColorBuffer[bar_index] = mhhColorIDX; + sLLColorBuffer[bar_index] = mllColorIDX; +} + +// +// MEDIUM Cycle ... +void CalculateMediumCycle( + int bar_index // Selected Bar Index +) +{ + // + ENUM_TIMEFRAMES mPeriod = mL2Period; + + // + double hhValue = GetCycleHHC( + bar_index, + mPeriod); + + // + double llValue = GetCycleLLC( + bar_index, + mPeriod); + + // + double lastHH = mLastMHH; + double lastLL = mLastMLL; + + // + double mHHState = EMPTY_VALUE; + double mhhColorIDX = mHideColorIDX; + if (showLevels) + { + // + if (hhValue == lastHH) + { + mhhColorIDX = showConsolidations ? 1 : mHideColorIDX; + } + else if (hhValue > lastHH) + { + mhhColorIDX = 2; + } + else if (hhValue < lastHH) + { + mhhColorIDX = 3; + } + + // + mHHState = mhhColorIDX; + } + else + { + mhhColorIDX = mHideColorIDX; + } + + // + double mLLState = EMPTY_VALUE; + double mllColorIDX = mHideColorIDX; + if (showLevels) + { + // + if (llValue == lastLL) + { + mllColorIDX = showConsolidations ? 1 : mHideColorIDX; + } + else if (llValue > lastLL) + { + mllColorIDX = 2; + } + else if (llValue < lastLL) + { + mllColorIDX = 3; + } + + // + mLLState = mllColorIDX; + } + else + { + mllColorIDX = mHideColorIDX; + } + + // + mLastMHH = hhValue; + mLastMLL = llValue; + + // + mHHBuffer[bar_index] = hhValue; + mLLBuffer[bar_index] = llValue; + mHHStateBuffer[bar_index] = mHHState; + mLLStateBuffer[bar_index] = mLLState; + mHHColorBuffer[bar_index] = mhhColorIDX; + mLLColorBuffer[bar_index] = mllColorIDX; +} + +// +// LONG Cycle ... +void CalculateLongCycle( + int bar_index // Selected Bar Index +) +{ + // + ENUM_TIMEFRAMES mPeriod = mL3Period; + + // + double hhValue = GetCycleHHC( + bar_index, + mPeriod); + + // + double llValue = GetCycleLLC( + bar_index, + mPeriod); + + // + double lastHH = mLastLHH; + double lastLL = mLastLLL; + + // + double mHHState = EMPTY_VALUE; + double mhhColorIDX = mHideColorIDX; + if (showLevels) + { + // + if (hhValue == lastHH) + { + mhhColorIDX = showConsolidations ? 1 : mHideColorIDX; + } + else if (hhValue > lastHH) + { + mhhColorIDX = 2; + } + else if (hhValue < lastHH) + { + mhhColorIDX = 3; + } + + // + mHHState = mhhColorIDX; + } + else + { + mhhColorIDX = mHideColorIDX; + } + + // + double mLLState = EMPTY_VALUE; + double mllColorIDX = mHideColorIDX; + if (showLevels) + { + // + if (llValue == lastLL) + { + mllColorIDX = showConsolidations ? 1 : mHideColorIDX; + } + else if (llValue > lastLL) + { + mllColorIDX = 2; + } + else if (llValue < lastLL) + { + mllColorIDX = 3; + } + + // + mLLState = mllColorIDX; + } + else + { + mllColorIDX = mHideColorIDX; + } + + // + mLastLHH = hhValue; + mLastLLL = llValue; + + // + lHHBuffer[bar_index] = hhValue; + lLLBuffer[bar_index] = llValue; + lHHStateBuffer[bar_index] = mHHState; + lLLStateBuffer[bar_index] = mLLState; + lHHColorBuffer[bar_index] = mhhColorIDX; + lLLColorBuffer[bar_index] = mllColorIDX; +} + +// +// HIND Cycle ... +void CalculateHindCycle( + int bar_index // Selected Bar Index +) +{ + // + ENUM_TIMEFRAMES mPeriod = mL4Period; + + // + double hhValue = GetCycleHHC( + bar_index, + mPeriod); + + // + double llValue = GetCycleLLC( + bar_index, + mPeriod); + + // + double lastHH = mLastHHH; + double lastLL = mLastHLL; + + // + double mHHState = EMPTY_VALUE; + double mhhColorIDX = mHideColorIDX; + if (showLevels) + { + // + if (hhValue == lastHH) + { + mhhColorIDX = showConsolidations ? 1 : mHideColorIDX; + } + else if (hhValue > lastHH) + { + mhhColorIDX = 2; + } + else if (hhValue < lastHH) + { + mhhColorIDX = 3; + } + + // + mHHState = mhhColorIDX; + } + else + { + mhhColorIDX = mHideColorIDX; + } + + // + double mLLState = EMPTY_VALUE; + double mllColorIDX = mHideColorIDX; + if (showLevels) + { + // + if (llValue == lastLL) + { + mllColorIDX = showConsolidations ? 1 : mHideColorIDX; + } + else if (llValue > lastLL) + { + mllColorIDX = 2; + } + else if (llValue < lastLL) + { + mllColorIDX = 3; + } + + // + mLLState = mllColorIDX; + } + else + { + mllColorIDX = mHideColorIDX; + } + + // + mLastHHH = hhValue; + mLastHLL = llValue; + + // + hHHBuffer[bar_index] = hhValue; + hLLBuffer[bar_index] = llValue; + hHHStateBuffer[bar_index] = mHHState; + hLLStateBuffer[bar_index] = mLLState; + hHHColorBuffer[bar_index] = mhhColorIDX; + hLLColorBuffer[bar_index] = mllColorIDX; +} + +// +// Calculate Peaks and Values ... +void CalculatePeaksAndVales( + int bar_index // Bar Index +) +{ + // + // Retrieve Requirements ... + + // + // Short ... + double sHHValue = sHHBuffer[bar_index]; + double sLLValue = sLLBuffer[bar_index]; + + // + // Medium ... + double mHHValue = mHHBuffer[bar_index]; + double mLLValue = mLLBuffer[bar_index]; + + // + // Long ... + double lHHValue = lHHBuffer[bar_index]; + double lLLValue = lLLBuffer[bar_index]; + + // + // Hind ... + double hHHValue = hHHBuffer[bar_index]; + double hLLValue = hLLBuffer[bar_index]; + + // + double rColorIDX = mHideColorIDX; + double sColorIDX = mHideColorIDX; + + // + // RESISTANCE ... + double rValue = (sHHValue + mHHValue + lHHValue + hHHValue) / 4; + + // + // PEAKS ... + bool isPeak = rValue == hHHValue && + hHHValue == lHHValue && + lHHValue == mHHValue && + mHHValue == sHHValue; + + // + if (isPeak && lastPeak != rValue) + { + // + rColorIDX = 1; + lastPeak = rValue; + } + + // + // SUPPORT ... + double sValue = (sLLValue + mLLValue + lLLValue + hLLValue) / 4; + + // + // VALES ... + bool isVale = sValue == hLLValue && + hLLValue == lLLValue && + lLLValue == mLLValue && + mLLValue == sLLValue; + + // + if (isVale && lastVale != sValue) + { + // + sColorIDX = 1; + lastVale = sValue; + } + + // + rBuffer[bar_index] = rValue; + sBuffer[bar_index] = sValue; + peaksBuffer[bar_index] = lastPeak; + valesBuffer[bar_index] = lastVale; + + // + if (showPeaksAndVales) + { + // + rColorBuffer[bar_index] = rColorIDX; + sColorBuffer[bar_index] = sColorIDX; + } + else + { + // + rColorBuffer[bar_index] = mHideColorIDX; + sColorBuffer[bar_index] = mHideColorIDX; + } +} + +// +// Calculate Fibonacci Level 1 ... +void CalculateFibonacci( + int bar_index // Bar Index +) +{ + // + // Select Requirements ... + double upPrice = peaksBuffer[bar_index]; + double downPrice = valesBuffer[bar_index]; + + // + // Level 1 ... + double fibLevel1Value = GetFibonacciLevel( + upPrice, + downPrice, + fiboLevel1, + 1); + // + // Level 2 ... + double fibLevel2Value = GetFibonacciLevel( + upPrice, + downPrice, + fiboLevel2, + 1); + + // + // Level 3 ... + double fibLevel3Value = GetFibonacciLevel( + upPrice, + downPrice, + fiboLevel3, + 1); + + // + fl1Buffer[bar_index] = fibLevel1Value; + fl2Buffer[bar_index] = fibLevel2Value; + fl3Buffer[bar_index] = fibLevel3Value; + + // + double fl1ColorIdx = showFibo1Levels ? 1 : mHideColorIDX; + double fl2ColorIdx = showFibo2Levels ? 1 : mHideColorIDX; + double fl3ColorIdx = showFibo3Levels ? 1 : mHideColorIDX; + + // + fl1ColorBuffer[bar_index] = fl1ColorIdx; + fl2ColorBuffer[bar_index] = fl2ColorIdx; + fl3ColorBuffer[bar_index] = fl3ColorIdx; +} + +// +// XSTR ... +bool CalculateXSTR( + const int rates_total, + const int prev_calculated, + const double &open[], + const double &high[], + const double &low[], + const double &close[] // +) +{ + // + bool result = false; + + // + int numOfRequiredAtrs; + if (prev_calculated > rates_total || prev_calculated < 0) + { + numOfRequiredAtrs = rates_total; + } + else + { + // + numOfRequiredAtrs = rates_total - prev_calculated; + if (prev_calculated > 0) + { + numOfRequiredAtrs++; + } + } + + // + // Checking for stop ... + if (IsStopped()) + { + return result; + } + + // + // Check Number of items Copy or not ... + int copiedATRs = CopyBuffer(atrHandler, 0, 0, numOfRequiredAtrs, atrBuffer); + if (copiedATRs <= 0) + { + return result; + } + + // + // + int limit; + + // + // checking for the limit start of calculation of an indicator ... + if (prev_calculated > rates_total || prev_calculated <= 0) + { + // + // starting index for calculation of all bars ... + limit = maxLength; + } + else + { + // + // starting number for calculation of new bars + limit = prev_calculated - 1; + } + + // + // Main Loop ... + for (int i = limit; i < rates_total && !IsStopped(); i++) + { + // + // Calculated Price ... + double price = GetAppliedPrice( + trendPriceAppliedTo, + open, + high, + low, + close, + i); + // price = (high[i] + low[i]) / 2; + priceBuffer[i] = price; + + // + double atr = atrBuffer[i]; + + // + // Up ... + upBuffer[i] = price + (trendMultiplier * atr); + + // + // Down ... + downBuffer[i] = price - (trendMultiplier * atr); + + // + if (close[i] > upBuffer[i - 1]) + { + // + trendStateBuffer[i] = 1; + if (trendStateBuffer[i - 1] == -1) + { + changeOfTrend = 1; + } + } + else if (close[i] < downBuffer[i - 1]) + { + // + trendStateBuffer[i] = -1; + if (trendStateBuffer[i - 1] == 1) + { + changeOfTrend = 1; + } + } + else if (trendStateBuffer[i - 1] == 1) + { + // + trendStateBuffer[i] = 1; + changeOfTrend = 0; + } + else if (trendStateBuffer[i - 1] == -1) + { + // + trendStateBuffer[i] = -1; + changeOfTrend = 0; + } + + // + // Down Trend Starting ... + if (trendStateBuffer[i] < 0 && trendStateBuffer[i - 1] > 0) + { + startBearishTrend = 1; + } + else + { + startBearishTrend = 0; + } + + // + // Up Trend Starting ... + if (trendStateBuffer[i] > 0 && trendStateBuffer[i - 1] < 0) + { + startBullishTrend = 1; + } + else + { + startBullishTrend = 0; + } + + // + if (trendStateBuffer[i] > 0 && downBuffer[i] < downBuffer[i - 1]) + { + downBuffer[i] = downBuffer[i - 1]; + } + + // + if (trendStateBuffer[i] < 0 && upBuffer[i] > upBuffer[i - 1]) + { + upBuffer[i] = upBuffer[i - 1]; + } + + // + if (startBearishTrend == 1) + { + upBuffer[i] = priceBuffer[i] + (trendMultiplier * atr); + } + + // + if (startBullishTrend == 1) + { + downBuffer[i] = priceBuffer[i] - (trendMultiplier * atr); + } + + // + // Draw the indicator ... + + // + double colorIDX = 0; + double state = EMPTY_VALUE; + trendColorBuffer[i] = colorIDX; + + // + if (trendStateBuffer[i] == 1) + { + // + trendBuffer[i] = downBuffer[i]; + if (changeOfTrend == 1) + { + // + trendBuffer[i - 1] = trendBuffer[i - 2]; + changeOfTrend = 0; + + // + state = 1; + } + + // + colorIDX = 1; + } + else if (trendStateBuffer[i] == -1) + { + // + trendBuffer[i] = upBuffer[i]; + if (changeOfTrend == 1) + { + // + trendBuffer[i - 1] = trendBuffer[i - 2]; + changeOfTrend = 0; + + // + state = 2; + } + + // + colorIDX = 2; + } + + // + if (showTrends) + { + trendColorBuffer[i] = colorIDX; + } + strTrendStateBuffer[i] = state; + + // + // Filling ... + if (fillTrends) + { + // + fillUpBuffer[i] = trendBuffer[i]; + fillDownBuffer[i] = close[i]; + } + else + { + // + fillUpBuffer[i] = EMPTY_VALUE; + fillDownBuffer[i] = EMPTY_VALUE; + } + } + + // + result = true; + + // + return true; +} + +// +XMRBColorInfo GetRibbonColorIndex( + double value, + const double h, + const double l // +) +{ + // + XMRBColorInfo result; + + // + result.state = EMPTY_VALUE; + result.clr = mHideColorIDX; + + // + // Color Indexes ... + // 0 => HIDE + // 1 => NEUTURAL + // 2 => BULLISH + // 3 => BEARISH + + // + result.clr = 1; + + // + if (value < l && value < h) + { + result.clr = 2; + } + else if (value > h && value > l) + { + result.clr = 3; + } + else if (value < h && value > l) + { + result.clr = 1; + } + + // + result.state = result.clr; + + // + if (!showRibbons) + { + result.clr = mHideColorIDX; + } + + // + return result; +} + +// +// Calculate Ribbons Color ... +void CalculateRibbonsColors( + int bar_index, // Bar Index + const double &high[], + const double &low[] // +) +{ + // + double tmpVal; + XMRBColorInfo tmpColorIDX; + + // + double h = high[bar_index]; + double l = low[bar_index]; + + // + // RIBBON 1 ... + tmpVal = ribbon1Buffer[bar_index]; + tmpColorIDX = GetRibbonColorIndex( + tmpVal, + h, + l); + rb1StateBuffer[bar_index] = tmpColorIDX.state; + ribbon1ColorBuffer[bar_index] = tmpColorIDX.clr; + + // + // RIBBON 2 ... + tmpVal = ribbon2Buffer[bar_index]; + tmpColorIDX = GetRibbonColorIndex( + tmpVal, + h, + l); + rb2StateBuffer[bar_index] = tmpColorIDX.state; + ribbon2ColorBuffer[bar_index] = tmpColorIDX.clr; + + // + // RIBBON 3 ... + tmpVal = ribbon3Buffer[bar_index]; + tmpColorIDX = GetRibbonColorIndex( + tmpVal, + h, + l); + rb3StateBuffer[bar_index] = tmpColorIDX.state; + ribbon3ColorBuffer[bar_index] = tmpColorIDX.clr; + + // + // RIBBON 4 ... + tmpVal = ribbon4Buffer[bar_index]; + tmpColorIDX = GetRibbonColorIndex( + tmpVal, + h, + l); + rb4StateBuffer[bar_index] = tmpColorIDX.state; + ribbon4ColorBuffer[bar_index] = tmpColorIDX.clr; + + // + // RIBBON 5 ... + tmpVal = ribbon5Buffer[bar_index]; + tmpColorIDX = GetRibbonColorIndex( + tmpVal, + h, + l); + rb5StateBuffer[bar_index] = tmpColorIDX.state; + ribbon5ColorBuffer[bar_index] = tmpColorIDX.clr; + + // + // RIBBON 6 ... + tmpVal = ribbon6Buffer[bar_index]; + tmpColorIDX = GetRibbonColorIndex( + tmpVal, + h, + l); + rb6StateBuffer[bar_index] = tmpColorIDX.state; + ribbon6ColorBuffer[bar_index] = tmpColorIDX.clr; +} + +// +// Calculate SSL Channel ... +void CalculateSSLC( + int bar_index, // Selected Bar Index + int limit, + int ratesTotal, + int prevCalculated, + const double &close[]) +{ + // + double upMaValue = sslcUpMaBuffer[bar_index]; + double downMaValue = sslcDownMaBuffer[bar_index]; + + // + double closeValue = close[bar_index]; + + // + double kpiValue; + if (closeValue > upMaValue) + { + kpiValue = 1; + } + else if (closeValue < downMaValue) + { + kpiValue = -1; + } + else + { + kpiValue = sslcKpiBuffer[bar_index + 1]; + } + + // + sslcKpiBuffer[bar_index] = kpiValue; + + // + double upValue = kpiValue < 0 ? downMaValue : upMaValue; + sslcUpBuffer[bar_index] = upValue; + + // + double downValue = kpiValue < 0 ? upMaValue : downMaValue; + sslcDownBuffer[bar_index] = downValue; + + // + if (showSSLChannel) + { + // + sslcUpColorBuffer[bar_index] = 1; + sslcDownColorBuffer[bar_index] = 1; + } + else + { + // + sslcUpColorBuffer[bar_index] = mHideColorIDX; + sslcDownColorBuffer[bar_index] = mHideColorIDX; + } +} + +// +// Calculate XHULL ... +void CalculateHull( + int bar_index, // Selected Bar Index + int ratesTotal, // Total Rates + double upPrice, // Up Price ... + double downPrice // Down Price ... +) +{ + // + double upValue = mUpZHull.Calculate( + upPrice, + bar_index, + ratesTotal); + hullUpZoneBuffer[bar_index] = upValue; + double upColorIDX = (bar_index > 0) + ? (hullUpZoneBuffer[bar_index] > hullUpZoneBuffer[bar_index - 1]) + ? 2 + : (hullUpZoneBuffer[bar_index] < hullUpZoneBuffer[bar_index - 1]) + ? 3 + : hullUpZoneColorBuffer[bar_index - 1] + : 1; + + // + double downValue = mDownZHull.Calculate( + downPrice, + bar_index, + ratesTotal); + hullDownZoneBuffer[bar_index] = downValue; + double downColorIDX = (bar_index > 0) + ? (hullDownZoneBuffer[bar_index] > hullDownZoneBuffer[bar_index - 1]) + ? 2 + : (hullDownZoneBuffer[bar_index] < hullDownZoneBuffer[bar_index - 1]) + ? 3 + : hullDownZoneColorBuffer[bar_index - 1] + : 1; + + // + if (showHull) + { + // + hullUpZoneColorBuffer[bar_index] = upColorIDX; + hullDownZoneColorBuffer[bar_index] = downColorIDX; + } + else + { + // + hullUpZoneColorBuffer[bar_index] = mHideColorIDX; + hullDownZoneColorBuffer[bar_index] = mHideColorIDX; + } +} + +// +// Calculate HikenAshi Buffers ... +void CalculateHikenAshi( + int bar_index, // Selected Bar Index + const int prevCalculated, + const int ratesTotal, + const double &open[], + const double &high[], + const double &close[], + const double &low[]) +{ + // + double mPrevHKOpenValue; + double mPrevHKCloseValue; + + // + if (ArraySize(open) <= bar_index + 1) + { + // + mPrevHKOpenValue = 0; + mPrevHKCloseValue = 0; + } + else + { + // + mPrevHKOpenValue = hkOpenBuffer[bar_index + 1]; + mPrevHKCloseValue = hkCloseBuffer[bar_index + 1]; + } + + // + double mHKOpenValue = (mPrevHKOpenValue + mPrevHKCloseValue) / 2; + double mHKCloseValue = (open[bar_index] + high[bar_index] + close[bar_index] + low[bar_index]) / 4; + double mHKHighValue = MathMax(high[bar_index], MathMax(mHKOpenValue, mHKCloseValue)); + double mHKLowValue = MathMin(low[bar_index], MathMin(mHKOpenValue, mHKCloseValue)); + + // + hkOpenBuffer[bar_index] = mHKOpenValue; + hkHighBuffer[bar_index] = mHKHighValue; + hkLowBuffer[bar_index] = mHKLowValue; + hkCloseBuffer[bar_index] = mHKCloseValue; + + // + double candleColorValue = + mHKOpenValue < mHKCloseValue ? 1 : 2; + + // + hkCandleColorBuffer[bar_index] = showHKCandles ? candleColorValue : 0; +} + +// +// END Calculation Parts ... +// + +// +// START Utilities ... +// + +// +bool InitMaHandler( + int &handler, + int length, + ENUM_X_MA_METHOD mode, + ENUM_APPLIED_PRICE appliedTo) +{ + // + bool result = false; + + // + if (length <= 0) + { + return result; + } + + // + bool genericMethod = false; + ENUM_MA_METHOD method = NULL; + if (mode == X_MA_AMA) + { + // + handler = iAMA( + _Symbol, + _Period, + length, + mMRBAMAFast, + mMRBAMASlow, + 0, + appliedTo); + } + else if (mode == X_MA_EMA) + { + // + method = MODE_EMA; + genericMethod = true; + } + else if (mode == X_MA_LWMA) + { + // + method = MODE_LWMA; + genericMethod = true; + } + else if (mode == X_MA_SMA) + { + // + method = MODE_SMA; + genericMethod = true; + } + else if (mode == X_MA_SMMA) + { + // + method = MODE_SMMA; + genericMethod = true; + } + + // + if (genericMethod && handler == INVALID_HANDLE) + { + // + handler = iMA( + _Symbol, + _Period, + length, + 0, + method, + appliedTo); + } + + // + result = handler != INVALID_HANDLE; + + // + return result; +} + +// +// Retrieve Cycles Highest High ... +double GetCycleHH( + int bar_index, // Bar Index + ENUM_TIMEFRAMES period // Period +) +{ + // + datetime mCycleStartAt = GetPeriodStartTime( + _Symbol, + period); + + // + int mStartCycleBarIndex = iBarShift( + _Symbol, + _Period, + mCycleStartAt, + false); + + // + int mCycleCount = MathAbs(mStartCycleBarIndex - bar_index); + if (mCycleCount < 1) + { + mCycleCount = 1; + } + + // + // HIGH ... + int hhIndex = iHighest( + _Symbol, + _Period, + hhMode, + mCycleCount, + bar_index); + double result = GetAppliedPrice( + hhIndex, + hhMode); + + // + return result; +} + +// +// Retrieve Cycles Lowest Low ... +double GetCycleLL( + int bar_index, // Bar Index + ENUM_TIMEFRAMES period // Period +) +{ + // + datetime mCycleStartAt = GetPeriodStartTime( + _Symbol, + period); + + // + int mStartCycleBarIndex = iBarShift( + _Symbol, + _Period, + mCycleStartAt, + false); + + // + int mCycleCount = MathAbs(mStartCycleBarIndex - bar_index); + if (mCycleCount < 1) + { + mCycleCount = 1; + } + + // + // LOW ... + int llIndex = iLowest( + _Symbol, + _Period, + llMode, + mCycleCount, + bar_index); + double result = GetAppliedPrice( + llIndex, + llMode); + + // + return result; +} + +// +// Retrieve Cycles Highest High ... +double GetCycleHHC( + int bar_index, // Bar Index + ENUM_TIMEFRAMES period // Period +) +{ + // + int mCycleCount = 0; + if (period == mL1Period) + { + mCycleCount = mL1Candles; + } + else if (period == mL2Period) + { + mCycleCount = mL2Candles; + } + else if (period == mL3Period) + { + mCycleCount = mL3Candles; + } + else if (period == mL4Period) + { + mCycleCount = mL4Candles; + } + + // + // HIGH ... + int hhIndex = iHighest( + _Symbol, + _Period, + hhMode, + mCycleCount, + bar_index); + double result = GetAppliedPrice( + hhIndex, + hhMode); + + // + return result; +} + +// +// Retrieve Cycles Lowest Low ... +double GetCycleLLC( + int bar_index, // Bar Index + ENUM_TIMEFRAMES period // Period +) +{ + // + int mCycleCount = 0; + if (period == mL1Period) + { + mCycleCount = mL1Candles; + } + else if (period == mL2Period) + { + mCycleCount = mL2Candles; + } + else if (period == mL3Period) + { + mCycleCount = mL3Candles; + } + else if (period == mL4Period) + { + mCycleCount = mL4Candles; + } + + // + // LOW ... + int llIndex = iLowest( + _Symbol, + _Period, + llMode, + mCycleCount, + bar_index); + double result = GetAppliedPrice( + llIndex, + llMode); + + // + return result; +} + +// +string GenerateCyclesRepresentation() +{ + // + string result = ""; + + // + result += "C1: " + ToString(mL1Period) + "\n"; + result += "C2: " + ToString(mL2Period) + "\n"; + result += "C3: " + ToString(mL3Period) + "\n"; + result += "C4: " + ToString(mL4Period); + + // + return result; +} + +// +// Apply Custom Chart Style ... +void ApplyCustomChartStyle() +{ + // + // Read Current Chart Config and Store it ... + ReadChartStyle(); + + // + // After Reading Current Chart Style ... + // we have to Save Configs and Change Styles ... + clearStyle = chartStyle; + + // + clearStyle.upColor = CLR_NONE; + clearStyle.downColor = CLR_NONE; + clearStyle.lineColor = CLR_NONE; + clearStyle.bullishColor = CLR_NONE; + clearStyle.bearishColor = CLR_NONE; + + // + // Decide to Show or not Candles based on User Input ... + if (showCandles) + { + SetChartStyle(chartStyle); + } + else + { + SetChartStyle(clearStyle); + } +} + +// +// Read Previous Chart Style ... +void ReadChartStyle() +{ + // + // Retrieve Current Chart ID ... + long chartId = ChartID(); + chartStyle.chartId = chartId; + + // + // Retrieve Chart Mode ... + chartStyle.mode = (ENUM_CHART_MODE)ChartGetInteger(chartId, CHART_MODE); + + // + chartStyle.showBidLine = (bool)ChartGetInteger(chartId, CHART_SHOW_BID_LINE); + chartStyle.showAskLine = (bool)ChartGetInteger(chartId, CHART_SHOW_ASK_LINE); + chartStyle.showGrid = (bool)ChartGetInteger(chartId, CHART_SHOW_GRID); + chartStyle.showVolumes = (bool)ChartGetInteger(chartId, CHART_SHOW_VOLUMES); + chartStyle.showTradeLevels = (bool)ChartGetInteger(chartId, CHART_SHOW_TRADE_LEVELS); + chartStyle.autoScroll = (bool)ChartGetInteger(chartId, CHART_AUTOSCROLL); + chartStyle.quickNavigation = (bool)ChartGetInteger(chartId, CHART_QUICK_NAVIGATION); + + // + chartStyle.foreGroundColor = (color)ChartGetInteger(chartId, CHART_COLOR_FOREGROUND); + chartStyle.backGroundColor = (color)ChartGetInteger(chartId, CHART_COLOR_BACKGROUND); + chartStyle.upColor = (color)ChartGetInteger(chartId, CHART_COLOR_CHART_UP); + chartStyle.downColor = (color)ChartGetInteger(chartId, CHART_COLOR_CHART_DOWN); + chartStyle.bullishColor = (color)ChartGetInteger(chartId, CHART_COLOR_CANDLE_BULL); + chartStyle.bearishColor = (color)ChartGetInteger(chartId, CHART_COLOR_CANDLE_BEAR); + chartStyle.gridColor = (color)ChartGetInteger(chartId, CHART_COLOR_GRID); + chartStyle.bidLineColor = (color)ChartGetInteger(chartId, CHART_COLOR_BID); + chartStyle.askLineColor = (color)ChartGetInteger(chartId, CHART_COLOR_ASK); + chartStyle.stopColor = (color)ChartGetInteger(chartId, CHART_COLOR_STOP_LEVEL); + chartStyle.lineColor = (color)ChartGetInteger(chartId, CHART_COLOR_CHART_LINE); + chartStyle.volumesColor = (color)ChartGetInteger(chartId, CHART_COLOR_VOLUME); + + // + chartStyle.upColor = upColor; + chartStyle.downColor = downColor; + chartStyle.lineColor = lineColor; + chartStyle.bearishColor = bearishColor; + chartStyle.bullishColor = bullishColor; + chartStyle.volumesColor = volumesColor; +} + +// +// Set Chart Style ... +void SetChartStyle( + XChartStyle &mChartStyle // Chart Style to Apply +) +{ + // + ApplyChartStyle( + mChartStyle.chartId, + mChartStyle.mode, + mChartStyle.showBidLine, + mChartStyle.showAskLine, + mChartStyle.showGrid, + mChartStyle.showVolumes, + mChartStyle.showTradeLevels, + mChartStyle.autoScroll, + mChartStyle.quickNavigation, + mChartStyle.foreGroundColor, + mChartStyle.backGroundColor, + mChartStyle.upColor, + mChartStyle.downColor, + mChartStyle.bullishColor, + mChartStyle.bearishColor, + mChartStyle.gridColor, + mChartStyle.bidLineColor, + mChartStyle.askLineColor, + mChartStyle.lineColor, + mChartStyle.stopColor, + mChartStyle.volumesColor); +} + +// +// END Utilities ... +// + +// +// END Functions ... +//