MFCS 4TF MACD SLOPE #2_001

Download script
Author: Copyright � 2009, MFCS
MFCS 4TF MACD SLOPE #2_001

This script is a specialized technical analysis tool designed for the MetaTrader platform. Its primary purpose is to visualize the "momentum" or "slope" of the MACD (Moving Average Convergence Divergence) indicator across multiple different timeframes simultaneously on a single chart.

Core Functionality

The logic works by looking at four different timeframes at once. Instead of just showing you the price movement, it analyzes whether the MACD line is currently trending upward or downward for each of these periods.

To make this data easy to read, the script translates these trends into visual symbols:

  • Upward Trends: Represented by specific colors (Dodger Blue) and arrows.
  • Downward Trends: Represented by contrasting colors (Orange Red) and arrows.

How the Logic Flows

  1. Timeframe Detection: The script automatically identifies which timeframe you are currently viewing (e.g., a 5-minute chart vs. a Daily chart).
  2. Multi-Timeframe Mapping: Based on your current view, it selects a "set" of four related timeframes. It uses two different modes:
    • Mode 0: Used for shorter, faster timeframes (e.g., if you are on an M1 chart, it might look at M1, M5, M15, and M30).
    • Mode 1: Used for larger, slower timeframes (e.g., if you are on an H4 chart, it looks at much larger intervals like Daily or Weekly).
  3. Slope Analysis: For each of those four timeframes, the script calculates the MACD value for the current bar and compares it to the previous bar.
    • If the current value is higher than the previous one, the trend is considered "Up."
    • If the current value is lower, the trend is considered "Down."
  4. Visual Mapping: The script then plots these results in a separate window. It organizes them into distinct rows or levels so you can see the status of all four timeframes at a single glance.

User Experience Summary

Instead of having to open four different charts to see if the market is trending well on the M15, H1, H4, and Daily scales, this script consolidates that information into one view. It allows traders to quickly identify "confluence"—situations where multiple timeframes are moving in the same direction simultaneously—providing a more comprehensive picture of market sentiment.

Indicators Used
MACD Histogram
Miscellaneous
Implements a curve of type %1
11 Views
0 Downloads
0 Favorites
MFCS 4TF MACD SLOPE #2_001 
//+------------------------------------------------------------------+
//|                                          MFCS 4TF MACD SLOPE.mq4 |
//|                                           Copyright © 2009, MFCS |
//|                                     http://www.mpatidar.com/mfcs |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, MFCS"
#property link      "http://www.mpatidar.com/mfcs"


#property indicator_separate_window
#property indicator_minimum 0
#property indicator_maximum 5
#property indicator_buffers 8

/*
#property indicator_color1 OrangeRed
#property indicator_color2 DodgerBlue
#property indicator_color3 OrangeRed
#property indicator_color4 DodgerBlue
#property indicator_color5 OrangeRed
#property indicator_color6 DodgerBlue
#property indicator_color7 OrangeRed
#property indicator_color8 DodgerBlue
*/

//---- parameters
extern int price = PRICE_CLOSE;
extern int MaFastPeriod  = 12;
extern int MaSlowPeriod  = 26;

/*
Mode 0: Default, lower timeframes
Mode 1: Higher TimeFrames
*/
extern int mode = 0;

extern int BarWidth = 0;

extern color BarColorUp = DodgerBlue;
extern color BarColorDown = OrangeRed;
extern color TextColor = White;
extern int MaxBars=500;

double Gap = 1; // Gap between the lines of bars
//---- buffers
double buf4_up[];
double buf4_down[];
double buf3_up[];
double buf3_down[];
double buf2_up[];
double buf2_down[];
double buf1_up[];
double buf1_down[];

double macd0;
double macd1;

string shortname = "";


extern int ArrSize = 110;//110;
int UniqueNum = 20565;
int Period_1, Period_2, Period_3, Period_4;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
  
  
   SetIndexStyle(0,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(0,ArrSize);
   SetIndexBuffer(0,buf1_up);
   SetIndexEmptyValue(0,0.0);
   SetIndexStyle(1,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(1,ArrSize);
   SetIndexBuffer(1,buf1_down);
   SetIndexEmptyValue(1,0.0);
   SetIndexStyle(2,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(2,ArrSize);
   SetIndexBuffer(2,buf2_up);
   SetIndexEmptyValue(2,0.0);
   SetIndexStyle(3,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(3,ArrSize);
   SetIndexBuffer(3,buf2_down);
   SetIndexEmptyValue(3,0.0);
   SetIndexStyle(4,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(4,ArrSize);
   SetIndexBuffer(4,buf3_up);
   SetIndexEmptyValue(4,0.0);
   SetIndexStyle(5,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(5,ArrSize);
   SetIndexBuffer(5,buf3_down);
   SetIndexEmptyValue(5,0.0);
   SetIndexStyle(6,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(6,ArrSize);
   SetIndexBuffer(6,buf4_up);
   SetIndexEmptyValue(6,0.0);
   SetIndexStyle(7,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(7,ArrSize);
   SetIndexBuffer(7,buf4_down);
   SetIndexEmptyValue(7,0.0);
   
   if(mode == 0)
   {
      SetIndexLabel(0, "T1");
      SetIndexLabel(1,"T1");
      SetIndexLabel(2,"T2");
      SetIndexLabel(3,"T2");
      SetIndexLabel(4,"T3");
      SetIndexLabel(5,"T3");
      SetIndexLabel(6,"T4");
      SetIndexLabel(7,"T4");
   }
   else
   {
      SetIndexLabel(0, "T5");
      SetIndexLabel(1,"T5");
      SetIndexLabel(2,"T6");
      SetIndexLabel(3,"T6");
      SetIndexLabel(4,"T7");
      SetIndexLabel(5,"T7");
      SetIndexLabel(6,"T8");
      SetIndexLabel(7,"T8");

   }
   IndicatorDigits(0);
   getPeriod();
   
   shortname = "MFCS 4TF/8TF-MACD Slope ("+ tf2txt(Period_1)+", "+tf2txt(Period_2)+", "+tf2txt(Period_3)+", "+tf2txt(Period_4)+")";
   IndicatorShortName(shortname);
   
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {

   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+




int start()
  {
   
   int counted_bars=IndicatorCounted();
   //---- check for possible errors
   if(counted_bars<0) return(-1);
   //---- the last counted bar will be recounted
   
   if(counted_bars>0) 
   {
      //counted_bars -= Period_4 / Period();      
      counted_bars--;
   }
   
   int limit=Bars-counted_bars;
   int i,tf;

   
   //-------------------------------1----------------------------------------   
   double dif = Time[0] - Time[1];
   for ( i=ObjectsTotal()-1; i>-1; i--)
      {
         if (StringFind(ObjectName(i),"FF2_"+UniqueNum + "_" + mode +"_") >= 0)  ObjectDelete(ObjectName(i));
      }
      
   for ( tf=1; tf<=4; tf++)
      {  
         string txt = "??";
         double gp;
         switch (tf)
         {
            case 1: txt = tf2txt(Period_1);  gp = 1 + mode * 4; break;
            case 2: txt = tf2txt(Period_2);  gp = 1 + Gap + mode * 4; break;
            case 3: txt = tf2txt(Period_3);  gp = 1 + Gap*2 + mode * 4; break;
            case 4: txt = tf2txt(Period_4);  gp = 1 + Gap*3 + mode * 4; break;
         }
         string name = "FF2_"+UniqueNum + "_" + mode +"_"+tf+"_"+txt;
         ObjectCreate(name, OBJ_TEXT, WindowOnDropped(), iTime(NULL,0,0)+dif*3, gp + 0.7);
         ObjectSetText(name, txt,8,"Verdana", TextColor);
      }
   
   
   
   //-------------------------------2----------------------------------------
   datetime TimeArray_4[], TimeArray_3[], TimeArray_2[], TimeArray_1[];
   ArrayCopySeries(TimeArray_1,MODE_TIME,Symbol(),Period_1);
   ArrayCopySeries(TimeArray_2,MODE_TIME,Symbol(),Period_2);
   ArrayCopySeries(TimeArray_3,MODE_TIME,Symbol(),Period_3); 
   ArrayCopySeries(TimeArray_4,MODE_TIME,Symbol(),Period_4);
   
   int  i1=0, i2=0, i3=0, i4=0, yy;

  // for(i=0, i1=0,  i2=0,  i3=0,  i4=0;i<MaxBars;i++)
   for(i=0, i1=0,  i2=0,  i3=0,  i4=0;i<limit;i++)
   {
      if (Time[i]<TimeArray_1[i1]) i1++;
      if (Time[i]<TimeArray_2[i2]) i2++;
      if (Time[i]<TimeArray_3[i3]) i3++;
      if (Time[i]<TimeArray_4[i4]) i4++;

      for ( tf = 1; tf <= 4; tf++)
      {
         int prd;
         switch (tf)
         {
            case 1: prd = Period_1; yy = i1;  break;
            case 2: prd = Period_2; yy = i2;  break;
            case 3: prd = Period_3; yy = i3;   break;
            case 4: prd = Period_4; yy = i4;   break;
         }
      
         macd0 = iMACD(NULL, prd, MaFastPeriod, MaSlowPeriod, 9, price, MODE_MAIN, yy);
         macd1 = iMACD(NULL, prd, MaFastPeriod, MaSlowPeriod, 9, price, MODE_MAIN, yy+1);
         RefreshRates();
        
         switch (tf)
         {  case 1:  if (macd1>macd0)  buf1_down[i] = 1 + mode * 4;           else buf1_up[i] = 1 + mode * 4;           break;
            case 2:  if (macd1>macd0)  buf2_down[i] = 1 + mode * 4 + Gap * 1; else buf2_up[i] = 1 + mode * 4 + Gap * 1; break;
            case 3:  if (macd1>macd0)  buf3_down[i] = 1 + mode * 4 + Gap * 2; else buf3_up[i] = 1 + mode * 4 + Gap * 2; break;
            case 4:  if (macd1>macd0)  buf4_down[i] = 1 + mode * 4 + Gap * 3; else buf4_up[i] = 1 + mode * 4 + Gap * 3; break;
         }
      }
   }
   RefreshRates();
   return(0);
  }
  
  
  
//+------------------------------------------------------------------+
void getPeriod()
{
   if(mode == 1)
   {
      switch(Period()) 
         {
            case 1: 
               Period_1=60; Period_2=240; Period_3=1440; Period_4=10080;
               break;
            case 5: 
               Period_1=240; Period_2=1440; Period_3=10080; Period_4=43200;
               break;
            case 15: 
               Period_1=1440; Period_2=10080; Period_3=43200; Period_4=43200;
               break;
            case 30: 
               Period_1=10080; Period_2=43200; Period_3=43200; Period_4=43200;
               break;
            case 60: 
               Period_1=43200; Period_2=43200; Period_3=43200; Period_4=43200;
               break;
            case 240: 
               Period_1=43200; Period_2=43200; Period_3=43200; Period_4=43200;
               break;
            case 1440: 
               Period_1=43200; Period_2=43200; Period_3=43200; Period_4=43200;
               break;
            case 10080: 
               Period_1=43200; Period_2=43200; Period_3=43200; Period_4=43200;
               break;
            case 43200: 
               Period_1=43200; Period_2=43200; Period_3=43200; Period_4=43200;
               break;
         RefreshRates();
         }
   }
   else
   {
      switch(Period()) 
      {
         case 1: 
            Period_1=1; Period_2=5; Period_3=15; Period_4=30;
            break;
         case 5: 
            Period_1=5; Period_2=15; Period_3=30; Period_4=60;
            break;
         case 15: 
            Period_1=15; Period_2=30; Period_3=60; Period_4=240;
            break;
         case 30: 
            Period_1=30; Period_2=60; Period_3=240; Period_4=1440;
            break;
         case 60: 
            Period_1=60; Period_2=240; Period_3=1440; Period_4=10080;
            break;
         case 240: 
            Period_1=240; Period_2=1440; Period_3=10080; Period_4=43200;
            break;
         case 1440: 
            Period_1=1440; Period_2=10080; Period_3=43200; Period_4=43200;
            break;
         case 10080: 
            Period_1=10080; Period_2=43200; Period_3=43200; Period_4=43200;
            break;
         case 43200: 
            Period_1=43200; Period_2=43200; Period_3=43200; Period_4=43200;
            break;
      RefreshRates();   
      }
   }
}

string tf2txt(int tf)
{
   if (tf == PERIOD_M1)    return("M1");
   if (tf == PERIOD_M5)    return("M5");
   if (tf == PERIOD_M15)   return("M15");
   if (tf == PERIOD_M30)   return("M30");
   if (tf == PERIOD_H1)    return("H1");
   if (tf == PERIOD_H4)    return("H4");
   if (tf == PERIOD_D1)    return("D1");
   if (tf == PERIOD_W1)    return("W1");
   if (tf == PERIOD_MN1)   return("MN");
   
  //----  Refresh buffers ++++++++++++++++++++ upgrade by Raff  
   int TimeFrame,TimeArray[],i;
   if (TimeFrame>Period()) {
     int PerINT=TimeFrame/Period()+1;
     datetime TimeArr[]; ArrayResize(TimeArr,PerINT);
     ArrayCopySeries(TimeArr,MODE_TIME,Symbol(),Period()); 
     for(i=0;i<PerINT+1;i++) {if (TimeArr[i]>=TimeArray[0]) {
 /********************************************************  
    Refresh buffers:         buffer[i] = buffer[0];
 ********************************************************/  
buf4_up[i]  = buf4_up[0];
buf4_down[i]= buf4_down[0];
buf3_up[i]  = buf3_up[0];
buf3_down[i]= buf3_down[0];
buf2_up[i]  = buf2_up[0];
buf2_down[i]= buf2_down[0];
buf1_up[i]  = buf1_up[0];
buf1_down[i]= buf1_down[0];

//----
   } } }
//+++++++++++++++++++++++++++++++++++++++++++++++ Raff  
 
//+-------------
  
   return("??");
}


/*bool NewBar()
{
   static datetime dt = 0;
   
   if (Time[0] != dt)
   {
      dt = Time[0];
      
      return(true);
   }
   return(false);
}
*/

Similar scripts

MFCS 4TF MACD SLOPE #2b

This indicator visualizes the directional momentum of MACD values across four distinct timeframes simultaneously, using arrow markers to identify bullish and bearish slope transitions.

CCI_Cross0_x3WarnSigAlertEli_MTF

This indicator detects directional shifts by identifying zero-line crossovers across three distinct CCI time horizons with dynamic ATR-based signal spacing.

MFCS 4TF MACD SLOPE #2_002

This indicator visualizes the directional trajectory of the MACD main line across four distinct temporal horizons simultaneously to identify multi-layered trend confluence.

WisemanAO

Identifies trend reversal points by detecting specific directional pivot patterns in the Awesome Oscillator's momentum curve.

N4_TF_HAS_Bar

This indicator visualizes synchronized trend direction across four distinct timeframes by comparing smoothed Heiken Ashi open and close values.

N4 TF HAS Bar

This indicator visually aggregates smoothed Heiken Ashi momentum signals across four concurrent timeframes to identify aligned trend directions.

MTF_MegaTrend_Bar_4TFNextM2

This indicator aggregates and visualizes simultaneous trend signals from four distinct timeframes to provide a multi-dimensional perspective on market direction.

MTF_4TF_Supertrend_BarM

This indicator synchronizes and visualizes Supertrend trend directions across four concurrent higher-timeframes to identify multi-layer bullish or bearish alignment.

MFCS 4TF MACD SLOPE #2

This indicator visualizes the instantaneous direction of the MACD main line across four distinct timeframes simultaneously to identify concurrent trend momentum.

CCI_Cross_New-2 only 25-40

This indicator identifies multi-layered bullish and bearish trends by detecting consecutive threshold breaches across three distinct timeframes of the Commodity Channel Index (CCI).

Rads stoch Bar A

This indicator visualizes the relative momentum alignment across four distinct timeframes by plotting stochastic signal crossovers in a unified separate window.

Comments