Hull_HAMA_4TFBars_AD1_001

Download script
Author: Copyright � 2006, Eli hayun
Hull_HAMA_4TFBars_AD1_001

This script is designed to act as a multi-timeframe visual dashboard on your trading chart. Its primary purpose is to track market trends across four different timeframes simultaneously, allowing you to see the "big picture" without switching back and forth between different charts.

Core Functionality

The logic operates by analyzing price data from four specific historical periods (the exact periods change automatically depending on which timeframe you are currently viewing). It uses a specialized calculation method—specifically based on the Hull Moving Average (HAMA)—to determine whether the market is trending upwards or downwards on each of those timeframes.

How it Works for the User

  • Dynamic Timeframe Detection: The script is "smart." It detects your current chart timeframe (e.g., 15-minute, 1-hour, or 4-hour) and automatically selects the most logical set of higher timeframes to display. For example, if you are on a small timeframe, it will show you slightly larger ones; if you are on a large timeframe, it will adjust accordingly to ensure the data remains relevant.
  • Visual Trend Representation: Instead of showing complex lines or numbers, the script translates this technical data into colored symbols (arrows) in a separate window at the bottom of your screen.
    • One set of colors represents an upward trend.
    • The other set of colors represents a downward trend.
  • Stacked Layout: To keep the information organized, the script stacks these four different timeframes vertically. It applies a "Gap" logic to ensure that the signals for each timeframe do not overlap, making it easy to read at a glance.
  • Automatic Labeling: The script automatically labels each row with the corresponding timeframe text (like "M15", "H1", etc.), so you always know exactly which trend belongs to which period.

Summary of Behavior

Essentially, this tool acts as a "Trend Scanner." It looks at four different slices of time simultaneously, processes the mathematical trend for each using the Hull Moving Average logic, and paints a clear, color-coded visual map on your screen. This helps traders identify when multiple timeframes are aligning in the same direction, which is often a sign of a stronger market move.

Miscellaneous
Implements a curve of type %1
11 Views
0 Downloads
0 Favorites
Hull_HAMA_4TFBars_AD1_001 
//+------------------------------------------------------------------+
//|                                     lee_yan_cn  N4 4TF HASBar.mq4|
//|                         Modified by Matsu, #MTF SupertrendBar.mq4|
//|                                       Copyright © 2006, Eli hayun|
//|                                           http://www.elihayun.com|
//+------------------------------------------------------------------+
//|                                                Hull_O_H_L_C.mq4  |
//|Hull_HAMAm_4TF_Bar                         Copyright © 2007, None |
//| (TFswch autodisplay)                 Planet.Earth.Redistribution |
//+------------------------------------------------------------------+
//mod 2008 fxtsd  ki 
#property copyright "Copyright © 2006, Eli hayun"
#property link      "http://www.elihayun.com"

#property indicator_separate_window
#property indicator_minimum 0
#property indicator_maximum 6.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 MaMethod =3;  //0-3
extern int MaPeriod  =14;
extern int DrawType =2;  //0-2
extern int OpCl_Width= 2;
extern int ShowBars  =1200;
extern string  notes_ =  "Hull_HAMA param: MaMethod: SMA0 EMA1 SMMA2 LWMA3; DrawType: 0line 1section 2Histo";


//--- Bar param
extern int   BarWidth = 0;
extern color BarColorUp = C'0,103,206';//DodgerBlue;
extern color BarColorDown = OrangeRed;
extern color TextColor = OliveDrab;
extern int MaxBars=500;

double Gap = 1; // Gap between the lines of bars
//---- buffers

double buf1_up[];
double buf1_down[];
double buf2_up[];
double buf2_down[];
double buf3_up[];
double buf3_down[];
double buf4_up[];
double buf4_down[];
double haOpen;
double haClose;

/*
extern int Period_1 = 15;
extern int Period_2 = 30;
extern int Period_3 = 60;
extern int Period_4 = 240;

extern bool AutoDisplay      = false;
*/
string shortname = "";
bool firstTime = true;

int ArrSize = 110;//159;
//extern int UniqueNum = 2284;
string UniqueNum;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
  
  
   //SetAutoDisplay();
   
  
   
   firstTime = true;
   
   //IndicatorShortName(shortname);
//---- indicators
   SetIndexStyle(0,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(0,ArrSize);
   SetIndexBuffer(0,buf4_up);
   SetIndexEmptyValue(0,0.0);
   SetIndexStyle(1,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(1,ArrSize);
   SetIndexBuffer(1,buf4_down);
   SetIndexEmptyValue(1,0.0);
   SetIndexStyle(2,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(2,ArrSize);
   SetIndexBuffer(2,buf3_up);
   SetIndexEmptyValue(2,0.0);
   SetIndexStyle(3,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(3,ArrSize);
   SetIndexBuffer(3,buf3_down);
   SetIndexEmptyValue(3,0.0);
   SetIndexStyle(4,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(4,ArrSize);
   SetIndexBuffer(4,buf2_up);
   SetIndexEmptyValue(4,0.0);
   SetIndexStyle(5,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(5,ArrSize);
   SetIndexBuffer(5,buf2_down);
   SetIndexEmptyValue(5,0.0);
   SetIndexStyle(6,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(6,ArrSize);
   SetIndexBuffer(6,buf1_up);
   SetIndexEmptyValue(6,0.0);
   SetIndexStyle(7,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(7,ArrSize);
   SetIndexBuffer(7,buf1_down);
   SetIndexEmptyValue(7,0.0);
///**/   
   SetIndexLabel(0,NULL);
   SetIndexLabel(1,NULL);
   SetIndexLabel(2,NULL);
   SetIndexLabel(3,NULL);
   SetIndexLabel(4,NULL);
   SetIndexLabel(5,NULL);
   SetIndexLabel(6,NULL);
   SetIndexLabel(7,NULL);
   
   IndicatorDigits(0);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   //SetAutoDisplay();
UniqueNum = ""+ MaMethod+", "+ MaPeriod+"";
      for (int ii=ObjectsTotal()-1; ii>-1; ii--)
      {
         if (StringFind(ObjectName(ii),"FFbar_"+UniqueNum+"_") >= 0)
            ObjectDelete(ObjectName(ii));
    //     else 
    //        ii=-1;
      }
   
//   shortname = "# Forex Freedom("+Period_1+","+Period_2+","+Period_3+","+Period_4+")";
   firstTime = true;
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
   int i=0, y15m=0,y30m=0,y1h=0,y4h=0, yy;
  
    int Period_1, Period_2, Period_3, Period_4;
 
   int limit=Bars-counted_bars;
   limit=MathMax(limit,Period_1/Period());
   limit=MathMax(limit,Period_2/Period());
   limit=MathMax(limit,Period_3/Period());
   limit=MathMax(limit,Period_4/Period());
   limit=MathMin(limit,MaxBars);


   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;
         
      }
      
      
   shortname = "Hull_HAMA_Bar ("+MaMethod+", "+MaPeriod+") ["+Period_1+","+Period_2+","+Period_3+","+Period_4+"]";
   IndicatorShortName(shortname);

   datetime TimeArray_4H[], TimeArray_1H[], TimeArray_30M[], TimeArray_15M[];
//----

   if (firstTime || NewBar())
   {
      firstTime = false;
//      int win = UniqueNum; // WindowFind(shortname);
UniqueNum = ""+ MaMethod+", "+ MaPeriod+"";
      double dif = Time[0] - Time[1];
      for (int ii=ObjectsTotal()-1; ii>-1; ii--)
      {
         if (StringFind(ObjectName(ii),"FFbar_"+UniqueNum+"_") >= 0)
            ObjectDelete(ObjectName(ii));
         else 
            ii=-1;
      }
      
      double shift = 0.5;
      for ( ii=0; ii<4; ii++)
      {  
         string txt = "??";
         double gp;
         switch (ii)
         {
            case 0: txt = tf2txt(Period_4);  gp = 1 + shift;         
break;
            case 1: txt = tf2txt(Period_3);  gp = 1 + Gap + shift;   
break;
            case 2: txt = tf2txt(Period_2);  gp = 1 + Gap*2 + shift; 
break;
            case 3: txt = tf2txt(Period_1);  gp = 1 + Gap*3 + shift; 
break;
         }
         string name = "FFbar_"+UniqueNum+"_"+ii+"_"+txt;
         ObjectCreate(name, OBJ_TEXT, WindowFind(shortname), iTime(NULL,0,0)+dif*8, gp);
         ObjectSetText(name, txt,6,"Arial", TextColor);
      }
   }
 
   ArrayCopySeries(TimeArray_15M,MODE_TIME,Symbol(),Period_1); 
   ArrayCopySeries(TimeArray_30M,MODE_TIME,Symbol(),Period_2);
   ArrayCopySeries(TimeArray_1H,MODE_TIME,Symbol(),Period_3); 
   ArrayCopySeries(TimeArray_4H,MODE_TIME,Symbol(),Period_4); 
   
   
   for(i=0, y15m=0,  y4h=0,  y1h=0,  y30m=0;i<limit;i++)
 //  for(i=0, y15m=0,  y4h=0,  y1h=0,  y30m=0;i<MaxBars;i++)
   {
      if (Time[i]<TimeArray_15M [y15m])  y15m++;
      if (Time[i]<TimeArray_30M [y30m])  y30m++;
      if (Time[i]<TimeArray_1H  [y1h])   y1h++;
      if (Time[i]<TimeArray_4H  [y4h])   y4h++;

      for (int tf = 0; tf < 4; tf++)
      {
         int prd;
         switch (tf)
         {
            case 3: prd = Period_1; yy = y15m;  break;
            case 2: prd = Period_2; yy = y30m;  break;
            case 1: prd = Period_3;  yy = y1h;   break;
            case 0: prd = Period_4;  yy = y4h;   break;
         }
         
        
         haOpen = iCustom(NULL,prd,"Hull_HAMA_m",MaMethod,MaPeriod,2,2,ShowBars,2,yy) ;
         haClose = iCustom(NULL,prd,"Hull_HAMA_m",MaMethod,MaPeriod,2,2,ShowBars,3,yy) ;
 

 
 
     
         double dUp = EMPTY_VALUE; //   iCustom(NULL, prd, "SuperTrend", false, 1, yy);
         double dDn = EMPTY_VALUE; //iCustom(NULL, prd, "SuperTrend", false, 0, yy);
         
         if (haOpen<haClose) dDn = 1; else dUp = 1;
         
         switch (tf)
         {
            case 0: if (dUp == EMPTY_VALUE)  buf1_down[i] = 1;           
else buf1_up[i] = 1; break;
            case 1: if (dUp == EMPTY_VALUE)  buf2_down[i] = 1 + Gap * 
1; else buf2_up[i] = 1 + Gap * 1; break;
            case 2: if (dUp == EMPTY_VALUE)  buf3_down[i]  = 1 + Gap * 
2; else buf3_up[i]  = 1 + Gap * 2; break;
            case 3: if (dUp == EMPTY_VALUE)  buf4_down[i]  = 1  + Gap * 
3; else buf4_up[i]  = 1 + Gap * 3; break;
         }
         
         
      }


   }

   return(0);
  }
//+------------------------------------------------------------------+

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("??");
}

/*void SetValues(int p1, int p2, int p3, int p4)
{
   Period_1 = p1;   Period_2 = p2; Period_3 = p3; Period_4 = p4; 
}


void SetAutoDisplay()
{
   if (AutoDisplay)
   {
      switch (Period())
      {
         case PERIOD_M1  :  SetValues(PERIOD_M1,  PERIOD_M5, 
PERIOD_M15,PERIOD_M30); break;
         case PERIOD_M5  :  SetValues(PERIOD_M5,  
PERIOD_M15,PERIOD_M30,PERIOD_H1); break;
         case PERIOD_M15 :  SetValues(PERIOD_M5,  
PERIOD_M15,PERIOD_M30,PERIOD_H1); break;
         case PERIOD_M30 :  SetValues(PERIOD_M5, PERIOD_M15,PERIOD_M30, 
PERIOD_H1); break;
         case PERIOD_H1  :  SetValues(PERIOD_M15, PERIOD_M30,PERIOD_H1, 
PERIOD_H4);  break;
         case PERIOD_H4  :  SetValues(PERIOD_M30, PERIOD_H1, PERIOD_H4, 
PERIOD_D1);  break;
         case PERIOD_D1  :  SetValues(PERIOD_H1,  PERIOD_H4, PERIOD_D1, 
PERIOD_W1); break;
         case PERIOD_W1  :  SetValues(PERIOD_H4,  PERIOD_D1, 
PERIOD_W1,PERIOD_MN1); break;
         case PERIOD_MN1 :  SetValues(PERIOD_H4,  PERIOD_D1, 
PERIOD_W1,PERIOD_MN1);  break;
      }
   }
   
}
*/
bool NewBar()
{
   static datetime dt = 0;
   
   if (Time[0] != dt)
   {
      dt = Time[0];
      return(true);
   }
   return(false);
}

Dependencies

Hull_HAMA_m

This indicator synthesizes Hull Moving Average smoothing with Heikin-Ashi price action logic to filter market noise and visualize trend momentum.

Similar scripts

Hull_HAMA_4TFBars_AD1

This indicator synchronizes directional momentum from four nested timeframes using the Hull Moving Average and Heikin Ashi logic to visualize concurrent trend alignment.

ForexFreedomBarsNRP

This indicator identifies high-probability trend directions by synchronizing Commodity Channel Index (CCI) signals across four distinct timeframes simultaneously.

ForexFreedomBars

This indicator synchronizes Commodity Channel Index values across four distinct timeframes to identify high-probability trend alignment through unanimous directional signals.

#MTF Forex freedom Bar v2

This indicator identifies synchronized trend directions by aggregating Commodity Channel Index (CCI) signals across four concurrent timeframes to trigger alerts on total momentum alignment.

4 TF HAS Bar

This indicator visualizes real-time trend bias across four concurrent timeframes by aggregating smoothed Heiken Ashi price action into a synchronized, multi-layered signal window.

4 TF HAS Bar2

This indicator visualizes concurrent bullish and bearish sentiment across four distinct timeframes by plotting smoothed Heiken Ashi price actions into a multi-layered graphical display.

#MTF Forex freedom Bar v2_60m_Hercs

This indicator synchronizes Commodity Channel Index (CCI) signals across four distinct multi-timeframe intervals to identify high-probability trend alignments.

#MTF_Heiken Ashi Freedom Bar

This indicator synchronizes bullish and bearish signals across four distinct temporalities to identify high-probability trend alignment using Heiken Ashi data.

4TF_ADX

This indicator synchronizes the Plus Directional Index (PDI) and Minus Directional Index (MDI) across four distinct timeframes to identify high-probability directional alignment.

Hull_HAMA_4TFBars_AD

This indicator synchronizes four nested timeframes to project directional trend shifts by comparing Hull Moving Average prices against Heikin Ashi open and close values.

_2523MTF Supertrend Bar

This indicator synchronizes and visualizes SuperTrend signal data across four distinct timeframes simultaneously to identify aligned trend directions.

Comments