_2523MTF Triggerlines Bars

Download script
Author: Copyright � 2006, Eli hayun.
_2523MTF Triggerlines Bars

This tool is designed to help traders visualize market signals by monitoring multiple timeframes simultaneously. Instead of forcing you to switch back and forth between different charts (like 5-minute, 15-minute, 30-minute, and Hourly), this script consolidates the data from all those periods into a single view.

How it Works

The logic operates on a "Multi-Timeframe" (MTF) scanning system. Here is the breakdown of the process:

1. Multi-Timeframe Monitoring The script looks at four specific timeframes at once: 5M, 15M, 30M, and H1. It scans these different durations to see what the price action is doing on each independently.

2. Signal Detection For every one of those timeframes, the tool references an external secondary indicator (specifically looking for "Triggerlines"). It checks for a specific condition: whether the "high" signal is lower than the "low" signal. In trading terms, it is identifying a specific crossover or confirmation point provided by that auxiliary logic.

3. Visual Mapping Once the script identifies a valid signal on any of the four timeframes, it places a visual marker (an arrow) on your current chart.

  • If the condition is met on one timeframe, a specific arrow appears.
  • If the condition is met on a different timeframe, a different set of arrows appears.

4. Real-Time Synchronization The script automatically handles the "time shifting." Because a 1-hour candle covers many 5-minute candles, the code calculates exactly where the signal occurred on the larger timeframe and maps it perfectly onto your current smaller timeframe's chart.

Summary for the User

Essentially, this tool acts as a signal aggregator. It does the heavy lifting of watching four different charts at once. When a specific technical condition is met on any of those higher timeframes, it "pings" your current screen with a visual arrow, allowing you to see high-level market trends without ever leaving your primary chart.

Miscellaneous
Implements a curve of type %1
8 Views
0 Downloads
0 Favorites
_2523MTF Triggerlines Bars 
/*-----------------------------+
|			       |
| Shared by www.Aptrafx.com    |
|			       |
+------------------------------*/

//+------------------------------------------------------------------+
//|                                         #MTF Triggerlines Bars.mq4 |
//|                      Copyright © 2006, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, Eli hayun."
#property link      "http://www.elihayun.com"

#property indicator_separate_window
#property indicator_minimum 0
#property indicator_maximum 5
#property indicator_buffers 8
#property indicator_color1 Red
#property indicator_color2 Red
#property indicator_color3 Red
#property indicator_color4 Red
#property indicator_color5 Blue
#property indicator_color6 Blue
#property indicator_color7 Blue
#property indicator_color8 Blue
//---- buffers
double ExtMapBuffer1[];
double ExtMapBuffer2[];
double ExtMapBuffer3[];
double ExtMapBuffer4[];
double ExtMapBuffer5[];
double ExtMapBuffer6[];
double ExtMapBuffer7[];
double ExtMapBuffer8[];


extern string  CustomIndicator = "Triggerlines";

extern int Maxbars   = 1000;

extern int TimeFrame=0;



extern int Rperiod = 15;
extern int LSMA_Period = 5;

extern int    TF1  = PERIOD_M5;
extern int    TF2  = PERIOD_M15;
extern int    TF3  = PERIOD_M30;
extern int    TF4  = PERIOD_H1;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0,117);
   SetIndexBuffer(0,ExtMapBuffer1);
   SetIndexEmptyValue(0,0.0);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,117);
   SetIndexBuffer(1,ExtMapBuffer2);
   SetIndexEmptyValue(1,0.0);
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexArrow(2,117);
   SetIndexBuffer(2,ExtMapBuffer3);
   SetIndexEmptyValue(2,0.0);
   SetIndexStyle(3,DRAW_ARROW);
   SetIndexArrow(3,117);
   SetIndexBuffer(3,ExtMapBuffer4);
   SetIndexEmptyValue(3,0.0);
   SetIndexStyle(4,DRAW_ARROW);
   SetIndexArrow(4,117);
   SetIndexBuffer(4,ExtMapBuffer5);
   SetIndexEmptyValue(4,0.0);
   SetIndexStyle(5,DRAW_ARROW);
   SetIndexArrow(5,117);
   SetIndexBuffer(5,ExtMapBuffer6);
   SetIndexEmptyValue(5,0.0);
   SetIndexStyle(6,DRAW_ARROW);
   SetIndexArrow(6,117);
   SetIndexBuffer(6,ExtMapBuffer7);
   SetIndexEmptyValue(6,0.0);
   SetIndexStyle(7,DRAW_ARROW);
   SetIndexArrow(7,117);
   SetIndexBuffer(7,ExtMapBuffer8);
   SetIndexEmptyValue(7,0.0);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
//----
   int limit;
   int TF[] = {0,0,0,0};
   
   TF[0] = TF1;
   TF[1] = TF2;
   TF[2] = TF3;
   TF[3] = TF4;
   
   limit = MathMin(counted_bars,Maxbars);
   if (limit ==0)
      //limit = Maxbars;
      limit=Bars-counted_bars+TimeFrame/Period();
   
   for (int ii=0; ii<limit; ii++)
   {
      ExtMapBuffer1[ii] = 0;
      ExtMapBuffer2[ii] = 0;
      ExtMapBuffer3[ii] = 0;
      ExtMapBuffer4[ii] = 0;
      ExtMapBuffer5[ii] = 0;
      ExtMapBuffer6[ii] = 0;
      ExtMapBuffer7[ii] = 0;
      ExtMapBuffer8[ii] = 0;
      for (int jj=0; jj<4; jj++)
      {
         int y = iBarShift(NULL, TF[jj], Time[ii]);
         SetIndicator(GetCustomBars(TF[jj], y), jj, ii);
      }
   } 
//----
   return(0);
  }
//+------------------------------------------------------------------+

bool GetCustomBars(int TF, int shift)
{

   double h = iCustom(Symbol(), TF, CustomIndicator, Rperiod, LSMA_Period, 5, shift);
   double l = iCustom(Symbol(), TF, CustomIndicator, Rperiod, LSMA_Period, 6, shift);
   
   
   return(h<l);
}

void SetIndicator(bool isUP, int ind, int shift)
{
   if (isUP)
   {
      switch (ind) 
      {
         case 3:  ExtMapBuffer1[shift] = ind+1; break;
         case 2:  ExtMapBuffer2[shift] = ind+1; break;
         case 1:  ExtMapBuffer3[shift] = ind+1; break;
         case 0:  ExtMapBuffer4[shift] = ind+1; break;
      }
   } else {
         switch (ind)
         { 
            case 3:  ExtMapBuffer5[shift] = ind+1; break;
            case 2:  ExtMapBuffer6[shift] = ind+1; break;
            case 1:  ExtMapBuffer7[shift] = ind+1; break;
            case 0:  ExtMapBuffer8[shift] = ind+1; break;
         }
   }
}

Similar scripts

#MTF Triggerlines Bars

This indicator detects synchronized trend reversals by identifying simultaneous cross-over conditions across four distinct timeframes using a nested custom signal logic.

#MTF Triggerlines Bars_001

This indicator identifies synchronized reversal signals by monitoring nested crossover conditions across four distinct timeframes simultaneously.

#MTF Triggerlines Bars_002

This indicator identifies trend reversals by detecting divergent price action across four distinct timeframes using a synchronized Hull Moving Average crossover logic.

MTF_Supertrand2_BarsM_M5H1

This indicator synchronizes Supertrend signals across four distinct timeframes to identify synchronized momentum shifts and directional alignment.

MTF_Supertrand2_BarsM6

This indicator synthesizes directional bias from four distinct higher timeframes by plotting bullish and bearish trend signals simultaneously on a single chart.

Z1

This algorithm identifies significant market swing points by filtering local price extrema through a recursive depth-based volatility threshold and pruning redundant peaks.

Z-Z1_001

The algorithm identifies local extrema by filtering price fluctuations through a depth-based deviation threshold and recursively pruning overlapping peaks to establish structural swing points.

ZigZag1

The algorithm identifies significant price reversals by detecting local peaks and troughs that exceed specific depth, deviation, and backstep thresholds while pruning subordinate oscillations to isolate primary trend structural points.

ZigZagFirst_v1

This indicator identifies structural market extremes by filtering local highs and lows through a recursive backtracking algorithm to highlight non-overlapping price peaks.

ZigZag2

This indicator identifies structural price extremes by filtering out minor fluctuations and dynamically re-calculating local highs and lows based on predefined depth and deviation thresholds.

ICWR_v2

This indicator identifies significant structural price swings by filtering extreme price points to automatically plot active trend waves and dynamic Fibonacci retracement levels.

Comments