ADR Bottom-Right TABLE DashboardTitle: ADR Bottom-Right Dashboard
Version: 1.0
Author:
Description:
The ADR Bottom-Right Dashboard displays the Average Daily Range (ADR) and related metrics directly on your chart in a compact, easy-to-read table. It helps traders quickly see how much a stock has moved today relative to its normal daily range and identify potential overextended or trending moves.
This tool is ideal for swing traders, day traders, and scalpers who want a real-time, visual indication of volatility and intraday movement.
Features
ADR (Average Daily Range): Shows the average high-to-low movement over a customizable period (default 20 days).
ADR%: ADR as a percentage of the stock price, showing relative volatility.
Today: The current intraday range (high–low).
%ADR: How much of the ADR has already been reached today. Color-coded to indicate low, medium, or high extension.
Color coding: %ADR highlights:
Green: <50% (early-day / low volatility)
Yellow: 50–100% (normal movement)
Red: >100% (extended move / potential exhaustion)
Inputs
Input Description Default
ADR Period Number of days to calculate the ADR 20
Low %ADR Color Color for %ADR <50% Green
Medium %ADR Color Color for %ADR 50–100% Yellow
High %ADR Color Color for %ADR >100% Red
Multitimeframe
SMC Pre-Trade Checklist (Mozzys)Here is a **clean, professional description** you can use when publishing your TradingView script.
It clearly explains what the indicator does and why traders use it—perfect for the public library.
---
# **📌 Script Description (for Publishing)**
**SMC Pre-Trade Checklist (Compact Edition)**
This indicator provides a **smart, compact on-chart checklist** designed for traders who use **Smart Money Concepts (SMC)**.
Instead of guessing or rushing entries, the checklist helps you confirm the essential SMC conditions *before* taking a trade.
The checklist displays as a **small 3-column panel** in the corner of your chart, making it easy to scan without covering price action.
All items are controlled through indicator settings, where you can tick each condition as you validate it in your analysis.
---
## **🔥 What This Tool Helps You Do**
This script helps you stay disciplined by verifying the core components of an SMC setup:
### **1. Higher-Timeframe (HTF) Bias**
* Market direction clarity
* Premium vs. discount zones
* HTF POIs and liquidity targets
### **2. Liquidity Conditions**
* Liquidity sweeps
* Liquidity-based take-profit targets
### **3. Market Structure**
* BOS/CHOCH confirmation
* Displacement
* Clean pullback into POI
### **4. Entry Validation**
* Quality POI
* LTF confirmation
* Logical SL/TP and RR
### **5. Risk Management**
* Correct position sizing
* Avoiding high-impact news
* Spread/volatility conditions
### **6. Trader Discipline**
* Trade matches your model
* No revenge or emotional trading
---
## **🎯 Why Traders Love This**
Most losses come from **breaking rules**, not market randomness.
This checklist forces consistency, clarity, and patience—especially in fast environments like FX, indices, and crypto.
* Prevents emotional entries
* Reduces impulsive trades
* Keeps you aligned with your SMC plan
* Works with any strategy or SMC style
* Clean, minimal, non-intrusive layout
---
## **📌 Features**
* Compact 3-column layout
* Customizable from the indicator settings
* Works on all timeframes and assets
* Zero chart clutter
* Perfect for rule-based traders
---
## **🚀 Who This Indicator Is For**
* SMC traders
* ICT-style traders
* Liquidity-based traders
* Anyone who wants more discipline & consistency
* Backtesters who want structured trade evaluation
--
Dual SMT - Standard & Hidden [Pogiest]General
Smart Money Technique (SMT) involves identifying divergences in a correlated asset triad to predict new phases of price, a shift in market sentiment, and also potential trend reversals. An SMT divergence occurs when one or two assets makes a new high or low, but the other asset or assets does not, signaling a potential shift in market direction. A Hidden SMT Divergence occurs when one or two assets’ closing price closes higher or lower than the other one or two assets’ closing price. However, with potential gaps in price, an opening price can also be the extreme when comparing assets for divergences. Hidden SMT divergence compares the candle bodies while a Standard SMT divergence compares the highs and lows. Both types of SMTs are considered to be cracks in correlation and can be used to identify potential new phases of price whether it be a reversal, retracement, consolidation, and continuation.
Note: Credit of concepts/ideas goes to ICT and TraderDaye.
What Makes This Indicator Unique
The indicator has the ability to display Standard SMTs, Hidden SMTs, or both simultaneously in real-time, tick by tick in the time period selected in a correlated asset triad. Toggle modes for each type of SMT will run independently (runs when enabled) and therefore, optimizes performance. Option to select three different tickers in settings instead of limiting analysis to pairs makes this indicator more versatile. In addition, the indicator has “Invert” toggle options to track both Standard and Hidden SMTs for assets with negative correlations.
Instead of confirming SMT by selecting the number of pivots to look back for detection and confirmation, lines will be plotted on the chart on the first tick it detects a divergence. This can help traders anticipate SMTs in advance and give early warnings instead of waiting for a pivot confirmation. Active lines are displayed on the chart when the indicator identifies a divergence from the current time range to the previous time range in a correlated asset triad. These lines will move dynamically tick by tick on the chart and are anchored to the exact high/lows (Standard SMT) or bodies extremes (Hidden SMT). For inverted symbols, the lines will plot at the inverted anchor points. If new extremes are being made, the lines will move dynamically with the current forming candle for visual precision. During the current time period, the indicator continues to scan for new highs/lows as well as scanning the body high/lows while making line adjustments automatically. Lines will get deleted once the SMT becomes invalid.
The indicator is also designed for consecutive time ranges or cycles. Users are able to select the timeframe to monitor divergences which the indicator has multiple options to choose from including the most used timeframes (i.e. Monthly, Weekly, Daily, 6HR, 4HR, 90M, 1HR, 30M, 15M, etc). For example, if the 90m timeframe is selected, then the indicator will scan for divergences at the extremes in the current 90m cycle and compare the extremes to the previous 90m cycle. The indicator is designed to work when viewing lower timeframes while selecting higher timeframe cycles in settings.
There are four separate alert systems included in this indicator consisting of Standard bull/bear and Hidden bull/bear. Indicator is mode-aware and only triggers when alerts are enabled.
Dynamic Capabilities
Active (Real-Time):
For Standard SMT (High/Low), the indicator scans for divergences using the absolute highs and lows of each candle:
• Bull SMT: Compares the lowest points (wicks included).
• Bear SMT: Compares the highest points (wicks included).
In addition to SMT lines being plotted immediately after detection and lines moving dynamically at new high/low extremes, the indicator will remove the SMT automatically at the first tick it detects the divergence becoming invalid (i.e. all assets made a higher high or lower low in two consecutive time periods). Standard SMT labels are displayed as "SMT - TF" and are anchored to the center of the SMT line.
For Hidden SMT (Bodies), the indicator scans for divergences using only the candle body extremes (open/close, ignoring wicks):
• Bull SMT: Compares the lowest body prices (min of open/close) - divergence based on where bodies close, not wicks.
• Bear SMT: Compares the highest body prices (max of open/close) - divergence based on where bodies close, not wicks.
In addition to SMT lines being plotted immediately after detection and lines moving dynamically following the body high/low extremes, the indicator will remove the SMT automatically once the divergence becomes invalid (i.e. all assets made a higher high or lower low with the body extremes in two consecutive time periods). Hidden SMT labels are displayed as "SMT - TF" and are anchored to the center of the SMT line.
Historical (Fixed Plotting):
Once an SMT divergence (Standard or Hidden) was active and the current time range completes, the SMT line will be plotted and fixed on the chart as a historical line as the new time range starts. When the new time range starts, the cycle resets and the indicator scans for a new active SMT line in the current time range compared to the previous time range. Historical lines are stored for Standard SMT (up to 5) and Hidden SMT (up to 5) for the most recent lines.
Inverse SMT lines (Negative Correlation):
Assets with a negative correlation can be selected in settings with the Invert toggle option selected in settings. SMT divergences for both Standard and Hidden SMTs will be plotted on the chart at their respective anchor points from the previous time cycle to the current time cycle. Lines will behave normally as how it functions when the invert toggle is deselected. However, the lines are inverted on the chart with bullish SMT lines at the highs or bearish SMT lines at the lows.
Usage
Traders can use both types of SMT divergences to anticipate potential reversals in points of interest such as higher timeframe swing points, supply/demand zones, higher timeframe imbalances, key levels, etc. This indicator can also be beneficial in identifying cracks in correlation via Hidden SMT when there are no divergences off the highs and lows. SMT divergences (standard and hidden) can be used as a confirmation tool with other confluences to identify trend direction with respect to points of interest, higher timeframe order-flow, lower timeframe order-flow, etc. In addition, having both a Standard SMT and Hidden SMT divergence display could potentially signal a reversal. It is up to the trader to gauge the price action at the time.
Settings
1. Choose up to three different assets to monitor.
Note: If only two are selected, the indicator will only display the two selected and compare the two assets for divergences.
2. Choose up to one timeframe to monitor.
3. Enable/disable Invert mode.
4. For Standard and Hidden SMT: Enable/disable SMT-Active lines, option to change line style, line width, bull SMT line color, bear SMT line color, and bull/bear label text color.
5. For Standard and Hidden SMT: Enable/disable Historical SMT lines, adjust max historical SMT signals to be displayed (up to 5), option to change line style, line width, bull SMT line color, bear SMT line color, and bull/bear label text color.
6. For Standard and Hidden SMT: Show/hide SMT Labels and adjustable label offset.
7. Shared Label Settings: Adjust label size.
8. Enable/disable SMT Active alerts for Standard and Hidden SMT.
Risk Disclaimer
This indicator is for educational and informational purposes only and does not constitute financial advice. All trading and investment decisions remain solely the responsibility of the user.
Trading involves a high degree of risk, and past performance is not indicative of future results.
Always conduct your own research and consult with a qualified financial professional before making any trading decisions.
By using this indicator, users acknowledge they understand these risks and accept full responsibility for their trading decisions and outcomes.
Ichimoku Multi-Timeframe Heatmap 12/5/2025
Multi-Timeframe Ichimoku Heatmap - Scan Your Watchlist in Seconds
This indicator displays all 5 critical Ichimoku signals (Cloud Angle, Lagging Line, Price vs Cloud, Kijun Slope, and Tenkan/Kijun Cross) across 10 timeframes (15s, 1m, 3m, 5m, 15m, 30m, 1h, 4h, Daily, Weekly) in one compact heatmap table. Instantly spot multi-timeframe trend alignment with color-coded cells: green for bullish, red for bearish, and gray for neutral. Perfect for quickly scanning through your entire watchlist to identify the strongest setups with confluent signals across all timeframes.
VCP Trendline breakoutThe Signal:
Green Triangles indicate the price is approaching the trendline (Watchlist candidate).
Yellow Triangles indicate the price is very tight against the line (Execution imminent).
The Trigger: When price closes above the Grey Dotted Line, the line stops extending. This is your breakout signal.
Indicator Overview
The The VCP Trendline breakout indicator is a sophisticated technical indicator designed for trend followers and breakout traders (O'Neil, Minervini, Wyckoff styles). This script employs a State Machine logic to identify structural Volatility Contraction Patterns (VCP) in real-time.
It automatically detects valid Bases, tracks the "Right Side" construction, identifies nested handles (contractions), and draws precise supply trendlines—while strictly enforcing structural integrity rules (Higher Lows).
Core Logic & Features
1. Smart Base Detection
Trend Filter: The pattern recognition engine only activates when the price is above the 200 SMA, ensuring you are trading with the primary trend.
Base Validation: It identifies a "Base High" (H1) based on a configurable lookback period. It tracks the depth of the base and automatically invalidates the pattern if the drawdown exceeds the user-defined threshold (default 30%).
2. Recursive Nested Trendlines (VCP)
The indicator is capable of drawing Nested Trendlines (recursive resistance). It doesn't just draw a line from the peak; it identifies internal contractions within the base.
H1 (Primary): The main supply line from the top of the base.
H2, H3 (Internal): Trendlines connecting subsequent lower highs (handles) as volatility contracts.
Smart Fan: Includes a "Clean Fan" mode to show only the most relevant, latest trendline per anchor point.
3. Structural Integrity Enforcement (The "Higher Low" Rule)
This is the standout feature of this script. It performs an Anchor Integrity Check on every bar.
In a valid VCP, every contraction must form a Higher Low.
If the price creates a new pivot (H3) but then crashes lower than the previous contraction's floor (H2), the script identifies this as a Structural Failure.
Auto-Deletion: It immediately retroactively deletes the invalid trendlines associated with that failed contraction, keeping your chart clean and free of "ghost" signals.
4. "Right-Side" Logic
Collision Detection: Trendlines are calculated using "Right-Side Clearance." A line is only drawn if the path from the anchor to the new pivot is unobstructed by price action.
Signal Protection: "Watch" and "Near" signals are suppressed during the decline phase (Left Side). They only appear once the "Bottom" (L1) has been confirmed and price is recovering on the Right Side.
5. Proximity Alerts & Breakouts
Watch Zone (Green Triangle): Appears when the Low of the bar is within 8% (configurable) of a valid trendline.
Near Zone (Yellow Triangle): Appears when the Low of the bar is within 4% (configurable) of a valid trendline.
Breakout Stop: Trendlines are dynamic. The moment a bar closes above a trendline, the line stops extending immediately, marking the exact breakout point.
How to Use This Indicator
The Setup: Look for a stock in an uptrend (Price > 200 SMA).
The Construction: Wait for the script to identify the Base High (H1). As the price corrects and begins to recover, you will see Grey Dotted Lines appear, connecting the highs.
The Contraction: Watch for Nested Trendlines. If you see a second or third line form from a lower high (H2, H3), it indicates a tightening of price action (VCP).
Settings Configuration
Moving Averages
21 EMA, 50 SMA, 200 SMA: Built-in reference averages.
Base Settings
H1 Lookback: How many bars back the script looks to find the "Start" of the base (Default: 21). Increase this for longer-term bases.
Sub-High Pivot Bars: Controls the sensitivity of identifying internal highs (handles).
Max Base Depth: If the base drops more than this % (Default: 30%), the structure is considered failed and lines are removed.
Enable Nested Trendlines: Toggle ON to see internal VCP lines (H2, H3). Toggle OFF to see only the main H1 trendline.
Show Only Latest Line: Keeps the chart clean by removing older lines from the same anchor point.
Visuals & Signals
Near/Watch Zone %: Adjust the sensitivity of the Green/Yellow triangles.
Signal Size: Change the size of the triangle markers.
DISCLAIMER
This is an indicator, not a trading system. Apply good risk management and do your own due diligence before putting your hard earned money into anything.
This script is for educational and analytical purposes only. It does not constitute financial advice. Automated pattern recognition has limitations and should always be verified visually.
Key Levels//@version=5
//@sbtnc thank you for doing the base code
//Added additional levels for convienience sake.
indicator('Key Levels SpacemanBTC IDWM', shorttitle='SpacemanBTC Key Level V13.1', overlay=true, max_lines_count=100)
//35 works
displayStyle = input.string(defval='Standard', title='Display Style', options= , inline='Display')
mergebool = input.bool(defval=true, title='Merge Levels?', inline='Display')
distanceright = input.int(defval=30, title='Distance', minval=5, maxval=500, inline='Dist')
radistance = input.int(defval=250, title='Anchor Distance', minval=5, maxval=500, inline='Dist')
labelsize = input.string(defval='Medium', title='Text Size', options= )
linesize = input.string(defval='Small', title='Line Width', options= , inline='Line')
linestyle = input.string(defval='Solid', title='Line Style', options= , inline='Line')
GlobalTextType = input.bool(defval=false, title='Global Text ShortHand', tooltip='Enable for shorthand text on all text')
var globalcoloring = input.bool(defval=false, title='Global Coloring', tooltip='Enable for all color controls via one color', inline='GC')
GlobalColor = input.color(title='', defval=color.white, inline='GC')
//var show_tails = input(defval = false, title = "Always Show", type = input.bool)
= request.security(syminfo.tickerid, 'D', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'D', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'D', [time , low ], lookahead=barmerge.lookahead_on)
cdailyh_open = request.security(syminfo.tickerid, 'D', high, lookahead=barmerge.lookahead_on)
cdailyl_open = request.security(syminfo.tickerid, 'D', low, lookahead=barmerge.lookahead_on)
var monday_time = time
var monday_high = high
var monday_low = low
= request.security(syminfo.tickerid, 'W', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'W', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'W', [time , low ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'M', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, 'M', [time , low ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '3M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '3M', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '3M', [time , low ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '12M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '12M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '12M', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '240', , lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '240', [time , high ], lookahead=barmerge.lookahead_on)
= request.security(syminfo.tickerid, '240', [time , low ], lookahead=barmerge.lookahead_on)
//------------------------------ Inputs -------------------------------
var is_intra_enabled = input.bool(defval=false, title='Open', group='4H', inline='4H')
var is_intrarange_enabled = input.bool(defval=false, title='Prev H/L', group='4H', inline='4H')
var is_intram_enabled = input.bool(defval=false, title='Prev Mid', group='4H', inline='4H')
IntraTextType = input.bool(defval=false, title='ShortHand', group='4H', inline='4Hsh')
var is_daily_enabled = input.bool(defval=true, title='Open', group='Daily', inline='Daily')
var is_dailyrange_enabled = input.bool(defval=false, title='Prev H/L', group='Daily', inline='Daily')
var is_dailym_enabled = input.bool(defval=false, title='Prev Mid', group='Daily', inline='Daily')
DailyTextType = input.bool(defval=false, title='ShortHand', group='Daily', inline='Dailysh')
var is_monday_enabled = input.bool(defval=true, title='Range', group='Monday Range', inline='Monday')
var is_monday_mid = input.bool(defval=true, title='Mid', group='Monday Range', inline='Monday')
var untested_monday = false
MondayTextType = input.bool(defval=false, title='ShortHand', group='Monday Range', inline='Mondaysh')
var is_weekly_enabled = input.bool(defval=true, title='Open', group='Weekly', inline='Weekly')
var is_weeklyrange_enabled = input.bool(defval=true, title='Prev H/L', group='Weekly', inline='Weekly')
var is_weekly_mid = input.bool(defval=true, title='Prev Mid', group='Weekly', inline='Weekly')
WeeklyTextType = input.bool(defval=false, title='ShortHand', group='Weekly', inline='Weeklysh')
var is_monthly_enabled = input.bool(defval=true, title='Open', group='Monthly', inline='Monthly')
var is_monthlyrange_enabled = input.bool(defval=true, title='Prev H/L', group='Monthly', inline='Monthly')
var is_monthly_mid = input.bool(defval=true, title='Prev Mid', group='Monthly', inline='Monthly')
MonthlyTextType = input.bool(defval=false, title='ShortHand', group='Monthly', inline='Monthlysh')
var is_quarterly_enabled = input.bool(defval=true, title='Open', group='Quarterly', inline='Quarterly')
var is_quarterlyrange_enabled = input.bool(defval=false, title='Prev H/L', group='Quarterly', inline='Quarterly')
var is_quarterly_mid = input.bool(defval=true, title='Prev Mid', group='Quarterly', inline='Quarterly')
QuarterlyTextType = input.bool(defval=false, title='ShortHand', group='Quarterly', inline='Quarterlysh')
var is_yearly_enabled = input.bool(defval=true, title='Open', group='Yearly', inline='Yearly')
var is_yearlyrange_enabled = input.bool(defval=false, title='Current H/L', group='Yearly', inline='Yearly')
var is_yearly_mid = input.bool(defval=true, title='Mid', group='Yearly', inline='Yearly')
YearlyTextType = input.bool(defval=false, title='ShortHand', group='Yearly', inline='Yearlysh')
var is_londonrange_enabled = input.bool(defval=false, title='London Range', group='FX Sessions', inline='FX')
var is_usrange_enabled = input.bool(defval=false, title='New York Range', group='FX Sessions', inline='FX')
var is_asiarange_enabled = input.bool(defval=false, title='Asia Range', group='FX Sessions', inline='FX')
SessionTextType = input.bool(defval=false, title='ShortHand', group='FX Sessions', inline='FXColor')
Londont = input.session("0800-1600", "London Session")
USt = input.session("1400-2100", "New York Session")
Asiat = input.session("0000-0900", "Tokyo Session")
DailyColor = input.color(title='', defval=#08bcd4, group='Daily', inline='Dailysh')
MondayColor = input.color(title='', defval=color.white, group='Monday Range', inline='Mondaysh')
WeeklyColor = input.color(title='', defval=#fffcbc, group='Weekly', inline='Weeklysh')
MonthlyColor = input.color(title='', defval=#08d48c, group='Monthly', inline='Monthlysh')
YearlyColor = input.color(title='', defval=color.red, group='Yearly', inline='Yearlysh')
quarterlyColor = input.color(title='', defval=color.red, group='Quarterly', inline='Quarterlysh')
IntraColor = input.color(title='', defval=color.orange, group='4H', inline='4Hsh')
LondonColor = input.color(title='', defval=color.white, group='FX Sessions', inline='FXColor')
USColor = input.color(title='', defval=color.white, group='FX Sessions', inline='FXColor')
AsiaColor = input.color(title='', defval=color.white, group='FX Sessions', inline='FXColor')
var pdhtext = GlobalTextType or DailyTextType ? 'PDH' : 'Prev Day High'
var pdltext = GlobalTextType or DailyTextType ? 'PDL' : 'Prev Day Low'
var dotext = GlobalTextType or DailyTextType ? 'DO' : 'Daily Open'
var pdmtext = GlobalTextType or DailyTextType ? 'PDM' : 'Prev Day Mid'
var pwhtext = GlobalTextType or WeeklyTextType ? 'PWH' : 'Prev Week High'
var pwltext = GlobalTextType or WeeklyTextType ? 'PWL' : 'Prev Week Low'
var wotext = GlobalTextType or WeeklyTextType ? 'WO' : 'Weekly Open'
var pwmtext = GlobalTextType or WeeklyTextType ? 'PWM' : 'Prev Week Mid'
var pmhtext = GlobalTextType or MonthlyTextType ? 'PMH' : 'Prev Month High'
var pmltext = GlobalTextType or MonthlyTextType ? 'PML' : 'Prev Month Low'
var motext = GlobalTextType or MonthlyTextType ? 'MO' : 'Monthly Open'
var pmmtext = GlobalTextType or MonthlyTextType ? 'PMM' : 'Prev Month Mid'
var pqhtext = GlobalTextType or QuarterlyTextType ? 'PQH' : 'Prev Quarter High'
var pqltext = GlobalTextType or QuarterlyTextType ? 'PQL' : 'Prev Quarter Low'
var qotext = GlobalTextType or QuarterlyTextType ? 'QO' : 'Quarterly Open'
var pqmtext = GlobalTextType or QuarterlyTextType ? 'PQM' : 'Prev Quarter Mid'
var cyhtext = GlobalTextType or YearlyTextType ? 'CYH' : 'Current Year High'
var cyltext = GlobalTextType or YearlyTextType ? 'CYL' : 'Current Year Low'
var yotext = GlobalTextType or YearlyTextType ? 'YO' : 'Yearly Open'
var cymtext = GlobalTextType or YearlyTextType ? 'CYM' : 'Current Year Mid'
var pihtext = GlobalTextType or IntraTextType ? 'P-4H-H' : 'Prev 4H High'
var piltext = GlobalTextType or IntraTextType ? 'P-4H-L' : 'Prev 4H Low'
var iotext = GlobalTextType or IntraTextType ? '4H-O' : '4H Open'
var pimtext = GlobalTextType or IntraTextType ? 'P-4H-M' : 'Prev 4H Mid'
var pmonhtext = GlobalTextType or MondayTextType ? 'MDAY-H' : 'Monday High'
var pmonltext = GlobalTextType or MondayTextType ? 'MDAY-L' : 'Monday Low'
var pmonmtext = GlobalTextType or MondayTextType ? 'MDAY-M' : 'Monday Mid'
var lhtext = GlobalTextType or SessionTextType ? 'Lon-H' : 'London High'
var lltext = GlobalTextType or SessionTextType ? 'Lon-L' : 'London Low'
var lotext = GlobalTextType or SessionTextType ? 'Lon-O' : 'London Open'
var ushtext = GlobalTextType or SessionTextType ? 'NY-H' : 'New York High'
var usltext = GlobalTextType or SessionTextType ? 'NY-L' : 'New York Low'
var usotext = GlobalTextType or SessionTextType ? 'NY-O' : 'New York Open'
var asiahtext = GlobalTextType or SessionTextType ? 'AS-H' : 'Asia High'
var asialtext = GlobalTextType or SessionTextType ? 'AS-L' : 'Asia Low'
var asiaotext = GlobalTextType or SessionTextType ? 'AS-O' : 'Asia Open'
if globalcoloring == true
DailyColor := GlobalColor
MondayColor := GlobalColor
WeeklyColor := GlobalColor
MonthlyColor := GlobalColor
YearlyColor := GlobalColor
quarterlyColor := GlobalColor
IntraColor := GlobalColor
IntraColor
if weekly_time != weekly_time
untested_monday := false
untested_monday
if is_monday_enabled == true and untested_monday == false
untested_monday := true
monday_time := daily_time
monday_high := cdailyh_open
monday_low := cdailyl_open
monday_low
linewidthint = 1
if linesize == 'Small'
linewidthint := 1
linewidthint
if linesize == 'Medium'
linewidthint := 2
linewidthint
if linesize == 'Large'
linewidthint := 3
linewidthint
var DEFAULT_LINE_WIDTH = linewidthint
var DEFAULT_TAIL_WIDTH = linewidthint
fontsize = size.small
if labelsize == 'Small'
fontsize := size.small
fontsize
if labelsize == 'Medium'
fontsize := size.normal
fontsize
if labelsize == 'Large'
fontsize := size.large
fontsize
linestyles = line.style_solid
if linestyle == 'Dashed'
linestyles := line.style_dashed
linestyles
if linestyle == 'Dotted'
linestyles := line.style_dotted
linestyles
var DEFAULT_LABEL_SIZE = fontsize
var DEFAULT_LABEL_STYLE = label.style_none
var DEFAULT_EXTEND_RIGHT = distanceright
London = time(timeframe.period, Londont)
US = time(timeframe.period, USt)
Asia = time(timeframe.period, Asiat)
var clondonhigh = 0.0
var clondonlow = close
var londontime = time
var flondonhigh = 0.0
var flondonlow = 0.0
var flondonopen = 0.0
var onelondonfalse = false
if London
if high > clondonhigh
clondonhigh := high
clondonhigh
if low < clondonlow
clondonlow := low
clondonlow
if onelondonfalse
londontime := time
flondonopen := open
flondonopen
flondonhigh := clondonhigh
flondonlow := clondonlow
onelondonfalse := false
onelondonfalse
else
if onelondonfalse == false
flondonhigh := clondonhigh
flondonlow := clondonlow
flondonlow
onelondonfalse := true
clondonhigh := 0.0
clondonlow := close
clondonlow
//////////////////////////////////
var cushigh = 0.0
var cuslow = close
var ustime = time
var fushigh = 0.0
var fuslow = 0.0
var fusopen = 0.0
var oneusfalse = false
if US
if high > cushigh
cushigh := high
cushigh
if low < cuslow
cuslow := low
cuslow
if oneusfalse
ustime := time
fusopen := open
fusopen
fushigh := cushigh
fuslow := cuslow
oneusfalse := false
oneusfalse
else
if oneusfalse == false
fushigh := cushigh
fuslow := cuslow
fuslow
oneusfalse := true
cushigh := 0.0
cuslow := close
cuslow
//////////////////////////////////
var casiahigh = 0.0
var casialow = close
var asiatime = time
var fasiahigh = 0.0
var fasialow = 0.0
var fasiaopen = 0.0
var oneasiafalse = false
if Asia
if high > casiahigh
casiahigh := high
casiahigh
if low < casialow
casialow := low
casialow
if oneasiafalse
asiatime := time
fasiaopen := open
fasiaopen
fasiahigh := casiahigh
fasialow := casialow
oneasiafalse := false
oneasiafalse
else
if oneasiafalse == false
fasiahigh := casiahigh
fasialow := casialow
fasialow
oneasiafalse := true
casiahigh := 0.0
casialow := close
casialow
//------------------------------ Plotting ------------------------------
var pricearray = array.new_float(0)
var labelarray = array.new_label(0)
f_LevelMerge(pricearray, labelarray, currentprice, currentlabel, currentcolor) =>
if array.includes(pricearray, currentprice)
whichindex = array.indexof(pricearray, currentprice)
labelhold = array.get(labelarray, whichindex)
whichtext = label.get_text(labelhold)
label.set_text(labelhold, label.get_text(currentlabel) + ' / ' + whichtext)
label.set_text(currentlabel, '')
label.set_textcolor(labelhold, currentcolor)
else
array.push(pricearray, currentprice)
array.push(labelarray, currentlabel)
var can_show_daily = is_daily_enabled and timeframe.isintraday
var can_show_weekly = is_weekly_enabled and not timeframe.isweekly and not timeframe.ismonthly
var can_show_monthly = is_monthly_enabled and not timeframe.ismonthly
get_limit_right(bars) =>
timenow + (time - time ) * bars
// the following code doesn't need to be processed on every candle
if barstate.islast
is_weekly_open = dayofweek == dayofweek.monday
is_monthly_open = dayofmonth == 1
can_draw_daily = (is_weekly_enabled ? not is_weekly_open : true) and (is_monthly_enabled ? not is_monthly_open : true)
can_draw_weekly = is_monthly_enabled ? not(is_monthly_open and is_weekly_open) : true
can_draw_intra = is_intra_enabled
can_draw_intrah = is_intrarange_enabled
can_draw_intral = is_intrarange_enabled
can_draw_intram = is_intram_enabled
pricearray := array.new_float(0)
labelarray := array.new_label(0)
/////////////////////////////////
if is_londonrange_enabled
//label.new(bar_index,high)
london_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
londontime := get_limit_right(radistance)
londontime
var londonh_line = line.new(x1=londontime, x2=london_limit_right, y1=flondonhigh, y2=flondonhigh, color=LondonColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var londonl_line = line.new(x1=londontime, x2=london_limit_right, y1=flondonlow, y2=flondonlow, color=LondonColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var londono_line = line.new(x1=londontime, x2=london_limit_right, y1=flondonopen, y2=flondonopen, color=LondonColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var londonh_label = label.new(x=london_limit_right, y=flondonhigh, text=lhtext, style=DEFAULT_LABEL_STYLE, textcolor=LondonColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var londonl_label = label.new(x=london_limit_right, y=flondonlow, text=lltext, style=DEFAULT_LABEL_STYLE, textcolor=LondonColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var londono_label = label.new(x=london_limit_right, y=flondonopen, text=lotext, style=DEFAULT_LABEL_STYLE, textcolor=LondonColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(londonh_line, londontime)
line.set_x2(londonh_line, london_limit_right)
line.set_y1(londonh_line, flondonhigh)
line.set_y2(londonh_line, flondonhigh)
line.set_x1(londonl_line, londontime)
line.set_x2(londonl_line, london_limit_right)
line.set_y1(londonl_line, flondonlow)
line.set_y2(londonl_line, flondonlow)
line.set_x1(londono_line, londontime)
line.set_x2(londono_line, london_limit_right)
line.set_y1(londono_line, flondonopen)
line.set_y2(londono_line, flondonopen)
label.set_x(londonh_label, london_limit_right)
label.set_y(londonh_label, flondonhigh)
label.set_text(londonh_label, lhtext)
label.set_x(londonl_label, london_limit_right)
label.set_y(londonl_label, flondonlow)
label.set_text(londonl_label, lltext)
label.set_x(londono_label, london_limit_right)
label.set_y(londono_label, flondonopen)
label.set_text(londono_label, lotext)
if mergebool
f_LevelMerge(pricearray, labelarray, flondonhigh, londonh_label, LondonColor)
f_LevelMerge(pricearray, labelarray, flondonlow, londonl_label, LondonColor)
f_LevelMerge(pricearray, labelarray, flondonopen, londono_label, LondonColor)
//////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////
if is_usrange_enabled
//label.new(bar_index,high)
us_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
ustime := get_limit_right(radistance)
ustime
var ush_line = line.new(x1=ustime, x2=us_limit_right, y1=fushigh, y2=fushigh, color=USColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var usl_line = line.new(x1=ustime, x2=us_limit_right, y1=fuslow, y2=fuslow, color=USColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var uso_line = line.new(x1=ustime, x2=us_limit_right, y1=fusopen, y2=fusopen, color=USColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var ush_label = label.new(x=us_limit_right, y=fushigh, text=lhtext, style=DEFAULT_LABEL_STYLE, textcolor=USColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var usl_label = label.new(x=us_limit_right, y=fuslow, text=lltext, style=DEFAULT_LABEL_STYLE, textcolor=USColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var uso_label = label.new(x=us_limit_right, y=fusopen, text=lotext, style=DEFAULT_LABEL_STYLE, textcolor=USColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(ush_line, ustime)
line.set_x2(ush_line, us_limit_right)
line.set_y1(ush_line, fushigh)
line.set_y2(ush_line, fushigh)
line.set_x1(usl_line, ustime)
line.set_x2(usl_line, us_limit_right)
line.set_y1(usl_line, fuslow)
line.set_y2(usl_line, fuslow)
line.set_x1(uso_line, ustime)
line.set_x2(uso_line, us_limit_right)
line.set_y1(uso_line, fusopen)
line.set_y2(uso_line, fusopen)
label.set_x(ush_label, us_limit_right)
label.set_y(ush_label, fushigh)
label.set_text(ush_label, ushtext)
label.set_x(usl_label, us_limit_right)
label.set_y(usl_label, fuslow)
label.set_text(usl_label, usltext)
label.set_x(uso_label, us_limit_right)
label.set_y(uso_label, fusopen)
label.set_text(uso_label, usotext)
if mergebool
f_LevelMerge(pricearray, labelarray, fushigh, ush_label, USColor)
f_LevelMerge(pricearray, labelarray, fuslow, usl_label, USColor)
f_LevelMerge(pricearray, labelarray, fusopen, uso_label, USColor)
/////////////////////////////////
if is_asiarange_enabled
//label.new(bar_index,high)
asia_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
asiatime := get_limit_right(radistance)
asiatime
var asiah_line = line.new(x1=asiatime, x2=asia_limit_right, y1=fasiahigh, y2=fasiahigh, color=AsiaColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var asial_line = line.new(x1=asiatime, x2=asia_limit_right, y1=fasialow, y2=fasialow, color=AsiaColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var asiao_line = line.new(x1=asiatime, x2=asia_limit_right, y1=fasiaopen, y2=fasiaopen, color=AsiaColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var asiah_label = label.new(x=asia_limit_right, y=fasiahigh, text=asiahtext, style=DEFAULT_LABEL_STYLE, textcolor=AsiaColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var asial_label = label.new(x=asia_limit_right, y=fasialow, text=asialtext, style=DEFAULT_LABEL_STYLE, textcolor=AsiaColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
var asiao_label = label.new(x=asia_limit_right, y=fasiaopen, text=asiaotext, style=DEFAULT_LABEL_STYLE, textcolor=AsiaColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(asiah_line, asiatime)
line.set_x2(asiah_line, asia_limit_right)
line.set_y1(asiah_line, fasiahigh)
line.set_y2(asiah_line, fasiahigh)
line.set_x1(asial_line, asiatime)
line.set_x2(asial_line, asia_limit_right)
line.set_y1(asial_line, fasialow)
line.set_y2(asial_line, fasialow)
line.set_x1(asiao_line, asiatime)
line.set_x2(asiao_line, asia_limit_right)
line.set_y1(asiao_line, fasiaopen)
line.set_y2(asiao_line, fasiaopen)
label.set_x(asiah_label, asia_limit_right)
label.set_y(asiah_label, fasiahigh)
label.set_text(asiah_label, asiahtext)
label.set_x(asial_label, asia_limit_right)
label.set_y(asial_label, fasialow)
label.set_text(asial_label, asialtext)
label.set_x(asiao_label, asia_limit_right)
label.set_y(asiao_label, fasiaopen)
label.set_text(asiao_label, asiaotext)
if mergebool
f_LevelMerge(pricearray, labelarray, fasiahigh, asiah_label, AsiaColor)
f_LevelMerge(pricearray, labelarray, fasialow, asial_label, AsiaColor)
f_LevelMerge(pricearray, labelarray, fasiaopen, asiao_label, AsiaColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////
if can_draw_intra
intra_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
intra_time := get_limit_right(radistance)
intra_time
var intra_line = line.new(x1=intra_time, x2=intra_limit_right, y1=intra_open, y2=intra_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intra_label = label.new(x=intra_limit_right, y=intra_open, text=iotext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intra_line, intra_time)
line.set_x2(intra_line, intra_limit_right)
line.set_y1(intra_line, intra_open)
line.set_y2(intra_line, intra_open)
label.set_x(intra_label, intra_limit_right)
label.set_y(intra_label, intra_open)
label.set_text(intra_label, iotext)
if mergebool
f_LevelMerge(pricearray, labelarray, intra_open, intra_label, IntraColor)
//////////////////////////////////////////////////////////////////////////////////
//HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH HIGH
if can_draw_intrah
intrah_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
intrah_time := get_limit_right(radistance)
intrah_time
var intrah_line = line.new(x1=intrah_time, x2=intrah_limit_right, y1=intrah_open, y2=intrah_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intrah_label = label.new(x=intrah_limit_right, y=intrah_open, text=pihtext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intrah_line, intrah_time)
line.set_x2(intrah_line, intrah_limit_right)
line.set_y1(intrah_line, intrah_open)
line.set_y2(intrah_line, intrah_open)
label.set_x(intrah_label, intrah_limit_right)
label.set_y(intrah_label, intrah_open)
label.set_text(intrah_label, pihtext)
if mergebool
f_LevelMerge(pricearray, labelarray, intrah_open, intrah_label, IntraColor)
//////////////////////////////////////////////////////////////////////////////////
//LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW LOW
if can_draw_intral
intral_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
intral_time := get_limit_right(radistance)
intral_time
var intral_line = line.new(x1=intral_time, x2=intral_limit_right, y1=intral_open, y2=intral_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intral_label = label.new(x=intral_limit_right, y=intral_open, text=piltext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intral_line, intral_time)
line.set_x2(intral_line, intral_limit_right)
line.set_y1(intral_line, intral_open)
line.set_y2(intral_line, intral_open)
label.set_x(intral_label, intral_limit_right)
label.set_y(intral_label, intral_open)
label.set_text(intral_label, piltext)
if mergebool
f_LevelMerge(pricearray, labelarray, intral_open, intral_label, IntraColor)
///////////////////////////////////////////////////////////////////////////////
if can_draw_intram
intram_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
intram_time = intrah_time
intram_open = (intral_open + intrah_open) / 2
if displayStyle == 'Right Anchored'
intram_time := get_limit_right(radistance)
intram_time
var intram_line = line.new(x1=intram_time, x2=intram_limit_right, y1=intram_open, y2=intram_open, color=IntraColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var intram_label = label.new(x=intram_limit_right, y=intram_open, text=pimtext, style=DEFAULT_LABEL_STYLE, textcolor=IntraColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(intram_line, intram_time)
line.set_x2(intram_line, intram_limit_right)
line.set_y1(intram_line, intram_open)
line.set_y2(intram_line, intram_open)
label.set_x(intram_label, intram_limit_right)
label.set_y(intram_label, intram_open)
label.set_text(intram_label, pimtext)
if mergebool
f_LevelMerge(pricearray, labelarray, intram_open, intram_label, IntraColor)
////////////////////////////////////////// MONDAY
if is_monday_enabled
monday_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monday_time := get_limit_right(radistance)
monday_time
var monday_line = line.new(x1=monday_time, x2=monday_limit_right, y1=monday_high, y2=monday_high, color=MondayColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monday_label = label.new(x=monday_limit_right, y=monday_high, text=pmonhtext, style=DEFAULT_LABEL_STYLE, textcolor=MondayColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monday_line, monday_time)
line.set_x2(monday_line, monday_limit_right)
line.set_y1(monday_line, monday_high)
line.set_y2(monday_line, monday_high)
label.set_x(monday_label, monday_limit_right)
label.set_y(monday_label, monday_high)
label.set_text(monday_label, pmonhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, monday_high, monday_label, MondayColor)
if is_monday_enabled
monday_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monday_time := get_limit_right(radistance)
monday_time
var monday_low_line = line.new(x1=monday_time, x2=monday_limit_right, y1=monday_low, y2=monday_low, color=MondayColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monday_low_label = label.new(x=monday_limit_right, y=monday_low, text=pmonltext, style=DEFAULT_LABEL_STYLE, textcolor=MondayColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monday_low_line, monday_time)
line.set_x2(monday_low_line, monday_limit_right)
line.set_y1(monday_low_line, monday_low)
line.set_y2(monday_low_line, monday_low)
label.set_x(monday_low_label, monday_limit_right)
label.set_y(monday_low_label, monday_low)
label.set_text(monday_low_label, pmonltext)
if mergebool
f_LevelMerge(pricearray, labelarray, monday_low, monday_low_label, MondayColor)
if is_monday_mid
mondaym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
mondaym_open = (monday_high + monday_low) / 2
if displayStyle == 'Right Anchored'
monday_time := get_limit_right(radistance)
monday_time
var mondaym_line = line.new(x1=monday_time, x2=mondaym_limit_right, y1=mondaym_open, y2=mondaym_open, color=MondayColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var mondaym_label = label.new(x=mondaym_limit_right, y=mondaym_open, text=pmonmtext, style=DEFAULT_LABEL_STYLE, textcolor=MondayColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(mondaym_line, monday_time)
line.set_x2(mondaym_line, mondaym_limit_right)
line.set_y1(mondaym_line, mondaym_open)
line.set_y2(mondaym_line, mondaym_open)
label.set_x(mondaym_label, mondaym_limit_right)
label.set_y(mondaym_label, mondaym_open)
label.set_text(mondaym_label, pmonmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, mondaym_open, mondaym_label, MondayColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN DAILY OPEN
if is_daily_enabled
daily_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
daily_time := get_limit_right(radistance)
daily_time
var daily_line = line.new(x1=daily_time, x2=daily_limit_right, y1=daily_open, y2=daily_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var daily_label = label.new(x=daily_limit_right, y=daily_open, text=dotext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(daily_line, daily_time)
line.set_x2(daily_line, daily_limit_right)
line.set_y1(daily_line, daily_open)
line.set_y2(daily_line, daily_open)
label.set_x(daily_label, daily_limit_right)
label.set_y(daily_label, daily_open)
label.set_text(daily_label, dotext)
if mergebool
f_LevelMerge(pricearray, labelarray, daily_open, daily_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH DAILY HIGH
if is_dailyrange_enabled
dailyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
dailyh_time := get_limit_right(radistance)
dailyh_time
// draw tails before lines for better visual
var dailyh_line = line.new(x1=dailyh_time, x2=dailyh_limit_right, y1=dailyh_open, y2=dailyh_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var dailyh_label = label.new(x=dailyh_limit_right, y=dailyh_open, text=pdhtext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(dailyh_line, dailyh_time)
line.set_x2(dailyh_line, dailyh_limit_right)
line.set_y1(dailyh_line, dailyh_open)
line.set_y2(dailyh_line, dailyh_open)
label.set_x(dailyh_label, dailyh_limit_right)
label.set_y(dailyh_label, dailyh_open)
label.set_text(dailyh_label, pdhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, dailyh_open, dailyh_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW DAILY LOW
if is_dailyrange_enabled
dailyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
dailyl_time := get_limit_right(radistance)
dailyl_time
var dailyl_line = line.new(x1=dailyl_time, x2=dailyl_limit_right, y1=dailyl_open, y2=dailyl_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var dailyl_label = label.new(x=dailyl_limit_right, y=dailyl_open, text=pdltext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(dailyl_line, dailyl_time)
line.set_x2(dailyl_line, dailyl_limit_right)
line.set_y1(dailyl_line, dailyl_open)
line.set_y2(dailyl_line, dailyl_open)
label.set_x(dailyl_label, dailyl_limit_right)
label.set_y(dailyl_label, dailyl_open)
label.set_text(dailyl_label, pdltext)
if mergebool
f_LevelMerge(pricearray, labelarray, dailyl_open, dailyl_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////// Daily MID
if is_dailym_enabled
dailym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
dailym_time = dailyh_time
dailym_open = (dailyl_open + dailyh_open) / 2
if displayStyle == 'Right Anchored'
dailym_time := get_limit_right(radistance)
dailym_time
var dailym_line = line.new(x1=dailym_time, x2=dailym_limit_right, y1=dailym_open, y2=dailym_open, color=DailyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var dailym_label = label.new(x=dailym_limit_right, y=dailym_open, text=pdmtext, style=DEFAULT_LABEL_STYLE, textcolor=DailyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(dailym_line, dailym_time)
line.set_x2(dailym_line, dailym_limit_right)
line.set_y1(dailym_line, dailym_open)
line.set_y2(dailym_line, dailym_open)
label.set_x(dailym_label, dailym_limit_right)
label.set_y(dailym_label, dailym_open)
label.set_text(dailym_label, pdmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, dailym_open, dailym_label, DailyColor)
//////////////////////////////////////////////////////////////////////////////////
if is_weekly_enabled
weekly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
cweekly_time = weekly_time
if displayStyle == 'Right Anchored'
cweekly_time := get_limit_right(radistance)
cweekly_time
var weekly_line = line.new(x1=cweekly_time, x2=weekly_limit_right, y1=weekly_open, y2=weekly_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weekly_label = label.new(x=weekly_limit_right, y=weekly_open, text=wotext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weekly_line, cweekly_time)
line.set_x2(weekly_line, weekly_limit_right)
line.set_y1(weekly_line, weekly_open)
line.set_y2(weekly_line, weekly_open)
label.set_x(weekly_label, weekly_limit_right)
label.set_y(weekly_label, weekly_open)
label.set_text(weekly_label, wotext)
if mergebool
f_LevelMerge(pricearray, labelarray, weekly_open, weekly_label, WeeklyColor)
// the weekly open can be the daily open too (monday)
// only the weekly will be draw, in these case we update its label
// if is_weekly_open and can_show_daily
// label.set_text(weekly_label, "DO / WO ")
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// WEEKLY HIGH WEEKLY HIGH WEEKLY HIGH
if is_weeklyrange_enabled
weeklyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
weeklyh_time := get_limit_right(radistance)
weeklyh_time
var weeklyh_line = line.new(x1=weeklyh_time, x2=weeklyh_limit_right, y1=weeklyh_open, y2=weeklyh_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weeklyh_label = label.new(x=weeklyh_limit_right, y=weeklyh_open, text=pwhtext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weeklyh_line, weeklyh_time)
line.set_x2(weeklyh_line, weeklyh_limit_right)
line.set_y1(weeklyh_line, weeklyh_open)
line.set_y2(weeklyh_line, weeklyh_open)
label.set_x(weeklyh_label, weeklyh_limit_right)
label.set_y(weeklyh_label, weeklyh_open)
label.set_text(weeklyh_label, pwhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, weeklyh_open, weeklyh_label, WeeklyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// WEEKLY LOW WEEKLY LOW WEEKLY LOW
if is_weeklyrange_enabled
weeklyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
weeklyl_time := get_limit_right(radistance)
weeklyl_time
var weeklyl_line = line.new(x1=weeklyl_time, x2=weeklyl_limit_right, y1=weekly_open, y2=weekly_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weeklyl_label = label.new(x=weeklyl_limit_right, y=weeklyl_open, text=pwltext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weeklyl_line, weeklyl_time)
line.set_x2(weeklyl_line, weeklyl_limit_right)
line.set_y1(weeklyl_line, weeklyl_open)
line.set_y2(weeklyl_line, weeklyl_open)
label.set_x(weeklyl_label, weeklyl_limit_right)
label.set_y(weeklyl_label, weeklyl_open)
label.set_text(weeklyl_label, pwltext)
if mergebool
f_LevelMerge(pricearray, labelarray, weeklyl_open, weeklyl_label, WeeklyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// Weekly MID
if is_weekly_mid
weeklym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
weeklym_time = weeklyh_time
weeklym_open = (weeklyl_open + weeklyh_open) / 2
if displayStyle == 'Right Anchored'
weeklym_time := get_limit_right(radistance)
weeklym_time
var weeklym_line = line.new(x1=weeklym_time, x2=weeklym_limit_right, y1=weeklym_open, y2=weeklym_open, color=WeeklyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var weeklym_label = label.new(x=weeklym_limit_right, y=weeklym_open, text=pwmtext, style=DEFAULT_LABEL_STYLE, textcolor=WeeklyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(weeklym_line, weeklym_time)
line.set_x2(weeklym_line, weeklym_limit_right)
line.set_y1(weeklym_line, weeklym_open)
line.set_y2(weeklym_line, weeklym_open)
label.set_x(weeklym_label, weeklym_limit_right)
label.set_y(weeklym_label, weeklym_open)
label.set_text(weeklym_label, pwmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, weeklym_open, weeklym_label, WeeklyColor)
////////////////////////////////////////////////////////////////////////////////// YEEEAARRLLYY LOW LOW LOW
if is_yearlyrange_enabled
yearlyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
yearlyl_time := get_limit_right(radistance)
yearlyl_time
var yearlyl_line = line.new(x1=yearlyl_time, x2=yearlyl_limit_right, y1=yearlyl_open, y2=yearlyl_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearlyl_label = label.new(x=yearlyl_limit_right, y=yearlyl_open, text=cyltext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearlyl_line, yearlyl_time)
line.set_x2(yearlyl_line, yearlyl_limit_right)
line.set_y1(yearlyl_line, yearlyl_open)
line.set_y2(yearlyl_line, yearlyl_open)
label.set_x(yearlyl_label, yearlyl_limit_right)
label.set_y(yearlyl_label, yearlyl_open)
label.set_text(yearlyl_label, cyltext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearlyl_open, yearlyl_label, YearlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// YEEEAARRLLYY HIGH HIGH HIGH
if is_yearlyrange_enabled
yearlyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
yearlyh_time := get_limit_right(radistance)
yearlyh_time
var yearlyh_line = line.new(x1=yearlyh_time, x2=yearlyh_limit_right, y1=yearlyh_open, y2=yearlyh_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearlyh_label = label.new(x=yearlyh_limit_right, y=yearlyh_open, text=cyhtext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearlyh_line, yearlyh_time)
line.set_x2(yearlyh_line, yearlyh_limit_right)
line.set_y1(yearlyh_line, yearlyh_open)
line.set_y2(yearlyh_line, yearlyh_open)
label.set_x(yearlyh_label, yearlyh_limit_right)
label.set_y(yearlyh_label, yearlyh_open)
label.set_text(yearlyh_label, cyhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearlyh_open, yearlyh_label, YearlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// YEEEAARRLLYY OPEN
if is_yearly_enabled
yearly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
yearly_time := get_limit_right(radistance)
yearly_time
var yearly_line = line.new(x1=yearly_time, x2=yearly_limit_right, y1=yearly_open, y2=yearly_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearly_label = label.new(x=yearly_limit_right, y=yearly_open, text=yotext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearly_line, yearly_time)
line.set_x2(yearly_line, yearly_limit_right)
line.set_y1(yearly_line, yearly_open)
line.set_y2(yearly_line, yearly_open)
label.set_x(yearly_label, yearly_limit_right)
label.set_y(yearly_label, yearly_open)
label.set_text(yearly_label, yotext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearly_open, yearly_label, YearlyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// yearly MID
if is_yearly_mid
yearlym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
yearlym_time = yearlyh_time
yearlym_open = (yearlyl_open + yearlyh_open) / 2
if displayStyle == 'Right Anchored'
yearlym_time := get_limit_right(radistance)
yearlym_time
var yearlym_line = line.new(x1=yearlym_time, x2=yearlym_limit_right, y1=yearlym_open, y2=yearlym_open, color=YearlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var yearlym_label = label.new(x=yearlym_limit_right, y=yearlym_open, text=cymtext, style=DEFAULT_LABEL_STYLE, textcolor=YearlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(yearlym_line, yearlym_time)
line.set_x2(yearlym_line, yearlym_limit_right)
line.set_y1(yearlym_line, yearlym_open)
line.set_y2(yearlym_line, yearlym_open)
label.set_x(yearlym_label, yearlym_limit_right)
label.set_y(yearlym_label, yearlym_open)
label.set_text(yearlym_label, cymtext)
if mergebool
f_LevelMerge(pricearray, labelarray, yearlym_open, yearlym_label, YearlyColor)
////////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY OPEN
if is_quarterly_enabled
quarterly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
quarterly_time := get_limit_right(radistance)
quarterly_time
var quarterly_line = line.new(x1=quarterly_time, x2=quarterly_limit_right, y1=quarterly_open, y2=quarterly_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterly_label = label.new(x=quarterly_limit_right, y=quarterly_open, text=qotext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterly_line, quarterly_time)
line.set_x2(quarterly_line, quarterly_limit_right)
line.set_y1(quarterly_line, quarterly_open)
line.set_y2(quarterly_line, quarterly_open)
label.set_x(quarterly_label, quarterly_limit_right)
label.set_y(quarterly_label, quarterly_open)
label.set_text(quarterly_label, qotext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterly_open, quarterly_label, quarterlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY High
if is_quarterlyrange_enabled
quarterlyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
quarterlyh_time := get_limit_right(radistance)
quarterlyh_time
var quarterlyh_line = line.new(x1=quarterlyh_time, x2=quarterlyh_limit_right, y1=quarterlyh_open, y2=quarterlyh_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterlyh_label = label.new(x=quarterlyh_limit_right, y=quarterlyh_open, text=pqhtext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterlyh_line, quarterlyh_time)
line.set_x2(quarterlyh_line, quarterlyh_limit_right)
line.set_y1(quarterlyh_line, quarterlyh_open)
line.set_y2(quarterlyh_line, quarterlyh_open)
label.set_x(quarterlyh_label, quarterlyh_limit_right)
label.set_y(quarterlyh_label, quarterlyh_open)
label.set_text(quarterlyh_label, pqhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterlyh_open, quarterlyh_label, quarterlyColor)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY Low
if is_quarterlyrange_enabled
quarterlyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
quarterlyl_time := get_limit_right(radistance)
quarterlyl_time
var quarterlyl_line = line.new(x1=quarterlyl_time, x2=quarterlyl_limit_right, y1=quarterlyl_open, y2=quarterlyl_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterlyl_label = label.new(x=quarterlyl_limit_right, y=quarterlyl_open, text=pqltext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterlyl_line, quarterlyl_time)
line.set_x2(quarterlyl_line, quarterlyl_limit_right)
line.set_y1(quarterlyl_line, quarterlyl_open)
line.set_y2(quarterlyl_line, quarterlyl_open)
label.set_x(quarterlyl_label, quarterlyl_limit_right)
label.set_y(quarterlyl_label, quarterlyl_open)
label.set_text(quarterlyl_label, pqltext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterlyl_open, quarterlyl_label, quarterlyColor)
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// QUATERLLYYYYY MID
if is_quarterly_mid
quarterlym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
quarterlym_time = quarterlyh_time
quarterlym_open = (quarterlyl_open + quarterlyh_open) / 2
if displayStyle == 'Right Anchored'
quarterlym_time := get_limit_right(radistance)
quarterlym_time
var quarterlym_line = line.new(x1=quarterlym_time, x2=quarterlym_limit_right, y1=quarterlym_open, y2=quarterlym_open, color=quarterlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var quarterlym_label = label.new(x=quarterlym_limit_right, y=quarterlym_open, text=pqmtext, style=DEFAULT_LABEL_STYLE, textcolor=quarterlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(quarterlym_line, quarterlym_time)
line.set_x2(quarterlym_line, quarterlym_limit_right)
line.set_y1(quarterlym_line, quarterlym_open)
line.set_y2(quarterlym_line, quarterlym_open)
label.set_x(quarterlym_label, quarterlym_limit_right)
label.set_y(quarterlym_label, quarterlym_open)
label.set_text(quarterlym_label, pqmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, quarterlym_open, quarterlym_label, quarterlyColor)
////////////////////////////////////////////////////////////////////////////////// Monthly LOW LOW LOW
if is_monthlyrange_enabled
monthlyl_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monthlyl_time := get_limit_right(radistance)
monthlyl_time
var monthlyl_line = line.new(x1=monthlyl_time, x2=monthlyl_limit_right, y1=monthlyl_open, y2=monthlyl_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlyl_label = label.new(x=monthlyl_limit_right, y=monthlyl_open, text=pmltext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlyl_line, monthlyl_time)
line.set_x2(monthlyl_line, monthlyl_limit_right)
line.set_y1(monthlyl_line, monthlyl_open)
line.set_y2(monthlyl_line, monthlyl_open)
label.set_x(monthlyl_label, monthlyl_limit_right)
label.set_y(monthlyl_label, monthlyl_open)
label.set_text(monthlyl_label, pmltext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthlyl_open, monthlyl_label, MonthlyColor)
// the weekly open can be the daily open too (monday)
// only the weekly will be draw, in these case we update its label
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////// MONTHLY HIGH HIGH HIGH
if is_monthlyrange_enabled
monthlyh_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monthlyh_time := get_limit_right(radistance)
monthlyh_time
var monthlyh_line = line.new(x1=monthlyh_time, x2=monthlyh_limit_right, y1=monthlyh_open, y2=monthlyh_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlyh_label = label.new(x=monthlyh_limit_right, y=monthlyh_open, text=pmhtext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlyh_line, monthlyl_time)
line.set_x2(monthlyh_line, monthlyh_limit_right)
line.set_y1(monthlyh_line, monthlyh_open)
line.set_y2(monthlyh_line, monthlyh_open)
label.set_x(monthlyh_label, monthlyh_limit_right)
label.set_y(monthlyh_label, monthlyh_open)
label.set_text(monthlyh_label, pmhtext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthlyh_open, monthlyh_label, MonthlyColor)
// the weekly open can be the daily open too (monday)
// only the weekly will be draw, in these case we update its label
//////////////////////////////////////////////////////////////////////////////// MONTHLY MID
if is_monthly_mid
monthlym_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
monthlym_time = monthlyh_time
monthlym_open = (monthlyl_open + monthlyh_open) / 2
if displayStyle == 'Right Anchored'
monthlym_time := get_limit_right(radistance)
monthlym_time
var monthlym_line = line.new(x1=monthlym_time, x2=monthlym_limit_right, y1=monthlym_open, y2=monthlym_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlym_label = label.new(x=monthlym_limit_right, y=monthlym_open, text=pmmtext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlym_line, monthlym_time)
line.set_x2(monthlym_line, monthlym_limit_right)
line.set_y1(monthlym_line, monthlym_open)
line.set_y2(monthlym_line, monthlym_open)
label.set_x(monthlym_label, monthlym_limit_right)
label.set_y(monthlym_label, monthlym_open)
label.set_text(monthlym_label, pmmtext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthlym_open, monthlym_label, MonthlyColor)
//////////////////////////////////////////////////////////////////////////////////
if is_monthly_enabled
monthly_limit_right = get_limit_right(DEFAULT_EXTEND_RIGHT)
if displayStyle == 'Right Anchored'
monthly_time := get_limit_right(radistance)
monthly_time
var monthlyLine = line.new(x1=monthly_time, x2=monthly_limit_right, y1=monthly_open, y2=monthly_open, color=MonthlyColor, width=DEFAULT_LINE_WIDTH, xloc=xloc.bar_time, style=linestyles)
var monthlyLabel = label.new(x=monthly_limit_right, y=monthly_open, text=motext, style=DEFAULT_LABEL_STYLE, textcolor=MonthlyColor, size=DEFAULT_LABEL_SIZE, xloc=xloc.bar_time)
line.set_x1(monthlyLine, monthly_time)
line.set_x2(monthlyLine, monthly_limit_right)
line.set_y1(monthlyLine, monthly_open)
line.set_y2(monthlyLine, monthly_open)
label.set_x(monthlyLabel, monthly_limit_right)
label.set_y(monthlyLabel, monthly_open)
label.set_text(monthlyLabel, motext)
if mergebool
f_LevelMerge(pricearray, labelarray, monthly_open, monthlyLabel, MonthlyColor)
/////////////////////////////////////////////////////////////////////////////
// the monthly open can be the weekly open (monday 1st) and/or daily open too
// only the monthly will be draw, in these case we update its label
// if is_monthly_open
// if can_show_daily
// label.set_text(monthlyLabel, "DO / MO ")
// if is_weekly_open
// if can_show_weekly
// label.set_text(monthlyLabel, "WO / MO ")
// if can_show_daily and can_show_weekly
// label.set_text(monthlyLabel, "DO / WO / MO ")
// the start of the line is drew from the first week of the month
// if the first day of the weekly candle (monday) is the 2nd of the month
// we fix the start of the line position on the Prev weekly candle
if timeframe.isweekly and dayofweek(monthly_time) != dayofweek.monday
line.set_x1(monthlyLine, monthly_time - (weekly_time - weekly_time ))
Sequential SMT + TCISD DeeptradeiqShort description. Educational indicator for studying Quarterly Theory Sequential smt concepts and True Change in State of Delivery across multiple timeframes.
FULL DESCRIPTION:
📊 Overview
An educational tool designed for studying Quarterly Theory Sequential concepts and temporal price analysis. This indicator visualizes divergence patterns between correlated instruments and tracks time-based price structures for analytical and learning purposes.
🔍 Key Features
Multi-Timeframe Analysis: Three modes - Quarters (6h), Sub-Quarters (90m), and Micro-Quarters (22.5m)
Sequential smt Divergence Visualization: Compare two instruments to study sequential divergence concepts with visual markers and invalidation tracking
True Change in State of Delivery (TCISD): Pattern identification with reference levels showing potential delivery state transitions
Customizable Visuals: Period boxes, high/low labels, color schemes, line styles, and information table
Timezone Support: DST-aware calculations for accurate period detection
⚙️ How It Works
The indicator divides trading sessions into time-based periods and tracks price extremes for each period. It compares the current instrument with a second pair (default: EURUSD) to identify when their price structures diverge sequentially - a key concept in Quarterly Theory education. Visual markers, lines, and labels help identify these patterns for study purposes.
🎯 Educational Applications
Study Quarterly Theory Sequential concepts in live market conditions
Understand temporal price structures and their characteristics
Analyze correlation and divergence between related instruments
Observe True Change in State of Delivery pattern formations
Practice pattern recognition and chart reading skills
Learn how price structures evolve across different timeframes
🛠️ Customization Options
Select analysis timeframe mode (Quarters/Sub-Quarters/Micro-Quarters)
Choose comparison pair for sequential analysis
Toggle visual elements (boxes, labels, lines, table)
Customize colors, styles, and sizes to match your chart theme
Show/hide invalidation markers and reference levels.
⚠️ IMPORTANT DISCLAIMER
This indicator is provided strictly for EDUCATIONAL and ANALYTICAL purposes. It does NOT provide trading signals, financial advice, or investment recommendations.
All patterns and markers are for study and observation only
Past price structures do not predict future movements
No guarantee of accuracy or profitability
Users must conduct independent analysis and risk assessment
All trading involves substantial risk of loss
Seek professional financial advice before making investment decisions
The creator assumes NO responsibility for trading decisions or financial outcomes from using this tool. This is a learning instrument - not a trading system.
KING 2 Super Trend Hull (Multi MA)KING supertrend MA nın multi time frame eklenmiş hali alexsander ma gibi ortalamalar da var içinde
Multi-Timeframe Liquidity ZonesXUAUSD 流动性清扫图 关闭自动调整参数，要求收盘回另一侧，重生流动性检测。高点回溯周期5
阈值0.03 数量50
XAUUSD Liquidity Sweep Chart: Disable automatic parameter adjustment, require closing on the opposite side, and regenerate liquidity detection. High point lookback period: 5. Threshold: 0.03. Quantity: 50.
ART Customizable Overbought Oversold indicatorThis toolkit will help you identify RSI levels on either extremes, you can customize them.
FVG — Major Gaps OnlyA gap is an area on the price chart where no trading occurred, so the candle jumps from one level to another without filling the intermediate prices.
In traditional markets (stocks, indices), gaps often occur due to overnight trading halts.
DarkPool FlowDarkPool Flow is a professional-grade technical analysis tool designed to align retail traders with the dominant "smart money" flow. Unlike standard moving average crossovers that often generate false signals during consolidation, this script employs a multi-layered filtering engine to isolate high-probability trends.
The core philosophy of this indicator is that Trends are fractal. A sustainable move on a lower timeframe must be supported by momentum on a higher timeframe. By comparing a "Fast Signal Trend" against a "Slow Anchor Trend" (e.g., Daily vs. Weekly), the script identifies the market bias used by institutional algorithms.
This edition features a Smart Recovery Engine, ensuring that valid trends are not missed simply because momentum started slowly, and a Dynamic Cloud that visually represents the strength of the trend spread.
Key Features
1. Auto-Adaptive Timeframe Logic
The script eliminates the guesswork of Multi-Timeframe (MTF) selection. By enabling "Auto-Adapt," the indicator detects your current chart timeframe and automatically maps it to the mathematically correct institutional pairings:
Scalping (<15m): Uses 15-Minute Trend vs. 1-Hour Anchor.
Day Trading (15m - 1H): Uses 4-Hour Trend vs. Daily Anchor.
Swing Trading (4H - Daily): Uses Daily Trend vs. Weekly Anchor (The classic "Golden" setup).
Investing (Weekly): Uses 21-Week EMA vs. 50-Week SMA (Bull Market Support Band logic).
2. Smart Recovery Signal Engine
Standard crossover scripts often miss major moves if the specific breakout candle has low volume or weak ADX. This script utilizes a state-machine logic that "remembers" the trend direction. If a trend begins during low volatility (gray candles), the script waits. The moment volatility and momentum confirm the move, a Smart Recovery Signal is triggered, allowing you to enter an existing trend safely.
3. Chop Protection (Gray Candles)
Preservation of capital is the priority. The script analyzes the Average Directional Index (ADX) and Volatility (ATR).
Colored Candles (Green/Red): The market is trending with sufficient strength. Trading is permitted.
Gray Candles: The market is in a low-energy chop or consolidation (ADX < 20). Trading is discouraged.
4. Dynamic Trend Cloud
The space between the Fast and Slow trends is filled with a dynamic cloud.
Darker/Opaque Cloud: Indicates a widening spread, suggesting accelerating momentum.
Lighter/Transparent Cloud: Indicates a narrowing spread, suggesting the trend may be weakening or consolidating.
5. Pullback & Retest Signals (+)
While triangles mark the start of a trend, the Plus (+) signs mark low-risk opportunities to add to a position. These appear when price dips into the cloud, finds support at the "Fair Value" zone, and closes back in the direction of the trend with confirmed momentum.
User Guide & Strategy
Setup
Add the indicator to your chart.
For Beginners: Enable "Auto-Adaptive Timeframes" in the settings.
For Advanced Users: Disable Auto-Adapt and manually configure your Fast/Slow pairings (Default is Daily 50 EMA / Weekly 50 EMA).
Signal Mode: Choose "First Breakout Only" for a cleaner chart, or "All Signals" if you wish to see re-entry points during choppy starts.
Long Entry Criteria (Buy)
Trend: The Cloud must be Green (Fast Trend > Slow Trend).
Signal: A Green Triangle appears below the bar.
Confirmation: The signal candle must not be Gray.
Re-Entry: A small Green (+) sign appears, indicating a successful test of the cloud support.
Short Entry Criteria (Sell)
Trend: The Cloud must be Red (Fast Trend < Slow Trend).
Signal: A Red Triangle appears above the bar.
Confirmation: The signal candle must not be Gray.
Re-Entry: A small Red (+) sign appears, indicating a successful test of the cloud resistance.
Stop Loss & Risk Management
Stop Loss: A standard institutional stop loss is placed just beyond the Slow Trend Line (the outer edge of the cloud). If price closes beyond the Slow Trend, the macro thesis is invalid.
Take Profit: Target liquidity pools or use a trailing stop based on the Fast Trend line.
Settings Overview
Mode Selection: Toggle between Auto-Adaptive logic or Manual control.
Manual Configuration: Define the specific Timeframe, Length, and Type (EMA, SMA, WMA) for both Fast and Slow trends.
Signal Logic: Toggle "Show Pullback Signals" on/off. Switch between "First Breakout" or "All Signals."
Quality Filters: Toggle individual filters (ATR, RSI, ADX) to adjust sensitivity. Turning these off makes the script more responsive but increases false signals.
Visual Style: Customize colors for Bullish, Bearish, and Neutral (Gray) states. Adjust cloud transparency.
Disclaimer
Risk Warning: Trading financial markets involves a high degree of risk and is not suitable for all investors. You could lose some or all of your initial investment.
Educational Use Only: This script and the information provided herein are for educational and informational purposes only. They do not constitute financial advice, investment advice, trading advice, or any other recommendation.
No Guarantee: Past performance of any trading system or methodology is not necessarily indicative of future results. The "Institutional Trend" indicator is a tool to assist in technical analysis, not a crystal ball. The creators of this script assume no responsibility or liability for any trading losses or damages incurred as a result of using this tool. Always perform your own due diligence and consult with a qualified financial advisor before making investment decisions.
CRTSA Indicator — Market Strength & StructureCRTSA combines market strength, trend, and structure in a single panel.
It identifies key zones, impulses, internal support/resistance levels, and early trend shifts.
Designed for scalping and intraday trading, it provides a clear and direct reading of the market’s true momentum.
Key Levels v1Key Levels
This comprehensive multi-timeframe indicator provides traders with key price levels and opening ranges across multiple timeframes, designed to identify significant support/resistance zones and market structure.
KEY FEATURES:
📦 Monthly Range Box
- Automatically draws a box capturing the high and low of the first 9 hours of each new month
- Box extends until the next month begins
- Includes an optional mid-line showing the 50% level of the range
- Fully customizable colors, line styles, and background opacity
📊 Multi-Timeframe Open Lines
The indicator plots horizontal lines at the open price of:
- Midnight Open (00:00 session start)
- 4-Hour Open (updates every 4-hour candle)
- Daily Open (true daily candle open)
- Weekly Open (start of trading week)
- Monthly Open (start of new month)
- Yearly Open (start of new year)
🎯 Smart Label System
- Automatic label combining when multiple timeframe opens overlap at the same price
- Clean text labels positioned ahead of current price to avoid obstruction
- Labels show combined timeframes (e.g., "Monthly Open / Weekly Open")
⚙️ Customization Options
Each timeframe open line includes:
- Toggle on/off independently
- Custom color selection
- Line style options (Solid, Dashed, Dotted)
- Organized settings grouped by timeframe for easy navigation
🔧 Technical Implementation
- Uses request.security() for accurate higher timeframe data
- Works on any chart timeframe
- Lines extend 10 bars beyond current price for clear label visibility
- Efficient overlap detection prevents duplicate labels
IDEAL FOR:
✓ Identifying key institutional levels
✓ Trading range breakouts
✓ Multi-timeframe analysis
✓ Support and resistance zones
✓ Session-based trading strategies
All settings are organized chronologically from shortest to longest timeframe for intuitive configuration.
Multi-TF EMA(20) — JcsatasiyaOverview
This indicator plots 7 multi-timeframe EMA(20) lines on any chart and displays a clean dynamic label for each EMA showing:
Full timeframe name (Yearly, Half-Yearly, Quarterly, Monthly, Weekly, etc.)
EMA(20) value formatted with exactly 2 decimals
A label that is positioned automatically to the right of the latest candle
White text for maximum readability
Color-coded lines for each timeframe
All EMA lines extend horizontally and update in real-time when new candles form on the selected timeframes.
✅ Key Features
• 7 Custom Timeframes
Choose any timeframe for each EMA (Yearly, 6-Month, 3-Month, Monthly, Weekly, Daily, 4H, etc.)
• Horizontal EMA Levels
Each EMA is drawn as a fixed horizontal level, making structure and bias easier to analyze.
• Dynamic Label Placement
Labels automatically position:
Horizontally: Left, Middle, or Right of the right-side future area
Vertically: Above, Middle, or Below the EMA line
• Clean Readable Labels
Always white text
Shows: EMA (20) – Timeframe Price: 123.45
Price always displays with 2 decimals
Label style auto-adjusts based on position
• Color Customization
Each timeframe EMA has its own color picker.
• All EMA Thickness Unified
Set one line thickness for all EMA lines.
• Reliable Multi-TF Accuracy
Uses request.security() with proper lookahead handling.
⭐ Why This Indicator Is Useful
This tool makes it extremely easy to visualize where your chart sits relative to major multi-timeframe EMA levels.
You immediately see:
Higher-timeframe trend direction
Bias zones
Key support/resistance EMA levels
Long-term vs short-term trend alignment
Price interaction with institutional EMAs
Perfect for day traders, swing traders, and position traders.
📘 HOW TO USE
1️⃣ Add to Chart
After adding the indicator, open the Settings → Inputs panel.
2️⃣ Choose the 7 Timeframes
For each slot, select your desired timeframe (example setup):
Yearly
Half Yearly
Quarterly
Monthly
Weekly
Daily
4H
3️⃣ Customize Colors
Pick a different color for each EMA for clarity.
4️⃣ Choose Label Placement
Use the label position controls:
Vertical: Upper / Middle / Below
Horizontal: Left / Middle / Right (relative to right-side future space)
5️⃣ Adjust Line Thickness (Optional)
A single slider controls the thickness of all 7 EMAs.
📝 NOTES
The indicator places labels 2–50 bars into the future depending on chosen position.
Labels are always visible and readable due to white text.
EMA values always show exactly two decimals, even for crypto, indices, and forex.
Works on any market and any chart timeframe.
TrategyMulti-Indicator Trading System - Detailed Description
═══════════════════════════════════════════
OVERVIEW
This indicator combines four proven technical analysis tools (EMA, RSI, MACD, ATR) with a specific logic that filters out low-probability setups. Unlike simple indicator mashups, this system requires all conditions to align simultaneously before generating a signal, significantly reducing false entries.
═══════════════════════════════════════════
CORE COMPONENTS & LOGIC
1. Trend Detection - Triple EMA Filter
The system uses three Exponential Moving Averages (5, 10, 20 periods) to establish trend direction and strength:
For LONG signals:
• EMA(5) must be above EMA(10)
• EMA(10) must be above EMA(20)
• Price must be trading above all three EMAs
This creates a "stacked EMA" configuration that confirms a strong uptrend.
For SHORT signals:
• EMA(5) must be below EMA(10)
• EMA(10) must be below EMA(20)
• Price must be trading below all three EMAs
This inverse configuration confirms a strong downtrend.
2. Momentum Confirmation - RSI Filter
The RSI (14-period) acts as a momentum filter to avoid entering during exhausted moves:
For LONG signals:
• RSI must be above 40 (avoiding oversold extremes)
• RSI must be rising (current RSI > previous RSI)
For SHORT signals:
• RSI must be below 60 (avoiding overbought extremes)
• RSI must be falling (current RSI < previous RSI)
This prevents entries at extreme overbought/oversold levels while confirming momentum direction.
3. Entry Trigger - MACD Crossover
The MACD (12, 26, 9) provides the precise entry timing:
LONG trigger: MACD line crosses above Signal line
SHORT trigger: MACD line crosses below Signal line
The signal only fires when this crossover occurs while all other conditions are already met.
4. Risk Management - ATR-Based TP/SL
Take Profit and Stop Loss levels are calculated dynamically using the 14-period ATR (Average True Range), adjusted for timeframe:
5-Minute Charts:
• Take Profit: 1.0 × ATR
• Stop Loss: 0.5 × ATR
4-Hour Charts and above:
• Take Profit: 2.0 × ATR
• Stop Loss: 1.0 × ATR
This adaptive approach accounts for different volatility levels across timeframes.
═══════════════════════════════════════════
SIGNAL GENERATION LOGIC
A signal is only generated when ALL four conditions are simultaneously true:
LONG Signal Requirements:
1. ✓ Triple EMA alignment (bullish stack)
2. ✓ Price above all EMAs
3. ✓ RSI > 40 and rising
4. ✓ MACD bullish crossover
SHORT Signal Requirements:
1. ✓ Triple EMA alignment (bearish stack)
2. ✓ Price below all EMAs
3. ✓ RSI < 60 and falling
4. ✓ MACD bearish crossover
This multi-layered filtering approach is what differentiates this system from basic indicator combinations.
═══════════════════════════════════════════
WHY THIS COMBINATION WORKS
Trend + Momentum + Timing:
• EMAs establish the overall trend context
• RSI confirms momentum is present (not exhausted)
• MACD provides precise entry timing
• ATR adapts risk management to current volatility
Key Innovation: The system waits for all filters to align rather than acting on individual signals, which significantly reduces whipsaws and false breakouts common in single-indicator strategies.
═══════════════════════════════════════════
OPTIMIZED TIMEFRAMES
While the indicator works on all timeframes, it has been specifically optimized and backtested on:
• 5-minute charts (for scalping/day trading)
• 4-hour charts (for swing trading)
The ATR multipliers automatically adjust based on the selected timeframe.
═══════════════════════════════════════════
VISUAL FEATURES
• Green arrows below bars: Long signal
• Red arrows above bars: Short signal
• Green line: Take Profit level
• Red line: Stop Loss level
• Alert capability: Configurable alerts for paid TradingView subscriptions
═══════════════════════════════════════════
HOW TO USE
1. Add the indicator to your chart
2. Wait for a colored arrow to appear
3. Enter the trade in the direction of the arrow
4. Set your Take Profit at the green line
5. Set your Stop Loss at the red line
6. (Optional) Set up alerts to receive notifications
Note: Not every arrow will show TP/SL lines. Lines only appear when the ATR-based calculation determines there is sufficient volatility to justify the trade setup.
═══════════════════════════════════════════
WHAT MAKES THIS INVITE-ONLY WORTHY
Unlike free indicators that simply plot standard EMAs, RSI, or MACD separately, this system:
1. Integrates all four indicators with specific thresholds designed to work together
2. Uses adaptive risk management that adjusts to timeframe and volatility
The value lies not in the individual components (which are public domain) but in the specific combination logic, thresholds, and ATR-based risk system that took months of testing to optimize.
═══════════════════════════════════════════
ACCESS INFORMATION
This is an invite-only indicator. To request access:
• Visit our website
We offer both monthly subscriptions and lifetime access.
═══════════════════════════════════════════
RISK DISCLAIMER
This indicator is a technical analysis tool and does not constitute financial advice. All trading involves substantial risk of loss. Past performance does not guarantee future results. The indicator provides signals based on historical price patterns, but cannot predict future market movements. Always use proper risk management and never risk more than you can afford to lose.
═══════════════════════════════════════════
Questions? Feel free to message us on TradingView, or to email us.
London First 15m Candle (Real-Time NY)London First 15-Minute Candle (Real-Time New York Time)
This custom TradingView indicator identifies and tracks the first 15-minute candle of the London session, but calculated in real-time according to New York time (EST/EDT).
🔹 What the Indicator Does
1. Detects the London Session Open (Real NY Time)
You define the London session start time in New York hours (default: 3:00 AM NY Time).
The indicator monitors the first 15 minutes from the defined start time (3:00–3:15 NY time).
Only today’s candle is tracked — historical London ranges are not shown.
2. Builds the London Opening Range Candle (15m)
While the 15-minute window is still open, it continuously tracks:
Highest price reached (London High)
Lowest price reached (London Low)
The values update in real time only within the 3:00–3:15 window.
At 3:15 NY time, the candle is locked in and no longer changes.
3. Draws Three Persistent Levels on the Chart
Once the London candle closes, the indicator plots:
🔴 Top Line (London High)
Extended to the right across the chart.
🟢 Bottom Line (London Low)
Extended to the right across the chart.
⚪ Mid Line (Middle of the Range)
Computed as:
(londonHigh + londonLow) / 2
Also extended to the right.
All lines:
Are only drawn for today.
Auto-delete and refresh when a new trading day begins.
4. Works on ANY Timeframe
Even if the indicator runs on:
1m
2m
5m
1h
etc.
…it still uses a real 15-minute aggregation, ensuring the London candle is accurate.
5. Clean Chart — No Historical London Levels
The script:
Removes old lines at the start of each new day.
Keeps only today’s active London range.
This prevents clutter and ensures clarity.
6. Optional Alerts (if enabled)
The indicator can generate alerts when the market crosses:
The top of the London range
The bottom of the London range
The midline
For example:
Price breaks above London High
Price breaks below London Low
Price crosses the Midline up or down
These can be used for:
Breakout strategies
Liquidity grabs
Range-trading confirmations
7. Fully Customizable
User inputs allow you to modify:
London session start hour (NY Time)
Candle duration (fixed at 15 minutes)
Line colors:
High line color
Low line color
Midline color
Line widths
Summary
This indicator gives you a clean and accurate view of the first 15-minute candle of the London session — critical for many ICT/SMS/prop firm strategies — with:
Real-time NY-based calculation
Automatic cleanup
Clear range lines
Custom colors
Alerts for breakouts
Advanced Delta Trading System ProAdvanced Delta Trading System Pro
Overview
This indicator is an advanced order flow analysis tool that combines Delta Volume Analysis, Cumulative Volume Delta (CVD), Multi-Timeframe Trend Confirmation, and Volume Profile Zones to identify high-probability trading opportunities based on institutional buying and selling pressure.
🔍 Core Concepts & Methodology
1. Range-Weighted Delta Calculation (Original Implementation)
Unlike basic delta indicators that simply subtract selling volume from buying volume, this script uses a range-weighted approach:
Range Weight = |Price Movement| / Candle Range
Bar Delta = Volume × Direction × Range Weight
Why this matters:
Accounts for intra-bar price action strength
Provides more accurate representation of directional conviction
Filters out low-conviction volume during ranging periods
2. Cumulative Volume Delta (CVD) with Momentum
The script calculates CVD by accumulating bar deltas and applies:
EMA smoothing to reduce noise (adjustable period)
Delta Momentum indicator: Measures the rate of change of delta relative to its average
CVD Slope detection: Identifies accumulation/distribution phases
Formula:
Delta Momentum = Current Absolute Delta / Average Absolute Delta
This normalized momentum metric helps filter low-conviction signals.
3. Multi-Timeframe CVD Confluence (Unique Feature)
The indicator pulls CVD trend data from a higher timeframe (default: 15min) to:
Confirm signals only when aligned with HTF institutional flow
Display HTF bias in the dashboard (Bull ▲ / Bear ▼ / Neutral)
Prevent counter-trend trades against larger timeframe momentum
Edge: Many delta indicators operate on single timeframes; this multi-timeframe approach significantly reduces false signals.
4. Volume Profile Zone Detection
Instead of static support/resistance, the script dynamically identifies:
High Volume Nodes (HVN): Areas with 1.5x above-average volume - potential magnets/reversal zones
Low Volume Nodes (LVN): Areas with <0.5x average volume - breakout zones with minimal resistance
These zones are visualized as semi-transparent boxes on the chart, updated in real-time.
5. Delta-CVD Divergence Detection
The script identifies:
Bullish Divergence: Price makes lower low while CVD makes higher low (accumulation)
Bearish Divergence: Price makes higher high while CVD makes lower high (distribution)
Uses pivot detection with adjustable lookback periods and draws divergence lines automatically.
🎯 Signal Generation Logic
Buy Signal Requirements:
Bar delta exceeds threshold (Average Delta × Imbalance Multiplier)
Delta momentum ≥ minimum threshold (default: 1.2)
CVD slope is positive (accumulation phase)
Higher timeframe CVD is bullish (if MTF enabled)
Candle closes green (price confirmation)
Sell Signal Requirements:
Same criteria but inverted for selling pressure.
Enhanced Signals:
Signals are strengthened when accompanied by divergences, combining immediate imbalance with underlying accumulation/distribution patterns.
📊 Visual Features
1. Intelligent Candle Coloring
Color intensity based on delta momentum (0-3 scale)
Lime: Strong buying | Red: Strong selling | Gray: Neutral
Helps quickly identify conviction behind price moves
2. Delta Labels
Optional labels showing exact delta values (in thousands for readability)
Adjustable frequency (every Nth bar)
Color-coded by strength
3. Real-Time Dashboard
Displays:
Current bar delta
Cumulative Volume Delta (CVD)
Delta momentum reading
Higher timeframe bias
Active signals and divergences
⚙️ Customization Options
Delta Settings:
CVD Smoothing: Controls EMA period for CVD line
Avg Delta Length: Lookback for delta average calculation
Delta Momentum Period: Smoothing for momentum indicator
Signal Filters:
Imbalance Multiplier: Threshold for signal generation (higher = fewer, stronger signals)
CVD Confluence: Require/disable CVD trend alignment
Min Momentum: Filter weak signals below threshold
Volume Zones:
Lookback Period: Bars analyzed for HVN/LVN detection
Max Zone Boxes: Limit visual clutter
Toggle HVN/LVN independently
Multi-Timeframe:
Select any higher timeframe for CVD analysis
HTF Bias Panel: Show/hide dashboard element
🔔 Alert Conditions
Long/Short Signals: Fires when all confluence conditions met
Divergence Alerts: Bullish/Bearish divergence detected
Extreme Momentum: Delta momentum exceeds 2.5× average
HTF Trend Change: Higher timeframe CVD reverses
💡 How to Use
For Scalping:
Use 1-5min charts with 15min HTF confirmation
Focus on extreme momentum alerts (>2.5×)
Enter on signals near HVN zones for better R:R
For Swing Trading:
Use 15min-1H charts with 4H HTF confirmation
Wait for divergences + signal confluence
Avoid LVN zones (price likely to slice through)
Volume Profile Strategy:
Buy at HVN support with bullish delta
Sell at HVN resistance with bearish delta
Target LVN zones for breakout trades
🆚 What Makes This Script Unique
Unlike standard delta indicators, this combines:
Range-weighted delta (more accurate than simple volume delta)
Multi-timeframe confirmation (institutional flow alignment)
Dynamic volume profile zones (not static S/R)
Momentum-filtered signals (reduces noise significantly)
Divergence integration (catches reversals early)
Compared to free alternatives: Most delta scripts show raw cumulative delta without momentum filtering, MTF analysis, or volume profile integration. This script provides a complete order flow analysis system in one indicator.
⚠️ Important Notes
Not a standalone system: Use with price action and market structure
Optimize settings per asset: Crypto needs different settings than forex/stocks
Higher timeframes = more reliable: Reduce noise on lower timeframes with longer smoothing
Volume quality matters: Works best on high-liquidity assets with accurate volume data
📈 Best Timeframes
Scalping: 1m-5m (with 15m HTF)
Day Trading: 5m-15m (with 1H HTF)
Swing Trading: 1H-4H (with D HTF)
This indicator is designed for traders who understand order flow concepts and want a comprehensive, multi-layered approach to delta analysis beyond basic cumulative volume delta indicators.
51 - By GoldmanMrBaNNathis script is a multi-timeframe alignment tool designed to help users visually compare the trend direction of a higher timeframe with the movement on a lower timeframe.
The indicator simply displays when both selected timeframes are moving in the same direction based on a customizable trend-detection method (such as moving average alignment).
Its purpose is to provide clarity, structure, and directional alignment for chart analysis.
Users can select:
A higher timeframe
A lower timeframe
Trend calculation method
Visual display options
The tool is made to support analysis only.
It does not execute trades, generate financial advice, or guarantee outcomes.
Always use additional independent research when making decisions.
Range Deviations PRO | Trade SymmetryRange Deviations PRO — Extended Session Levels
An enhanced version of the original Range Deviations by @joshuuu, retaining the full core logic while adding a key upgrade:
🔹 All session ranges, midlines, and deviation levels now extend into the next trading session, giving seamless multi-session context.
Supports Asia, CBDR, Flout, ONS, and Custom Sessions — with options for half/full standard deviations, equilibrium, and range boxes exactly as in the original.
Extending these levels helps identify:
• Liquidity sweeps
• Trap moves / false breaks
• Daily high/low projections
• Premium–discount behavior across sessions
Ideal for traders using ICT concepts who want clearer continuation of session structure into the next day.
Credit: Original logic by @joshuuu — enhancements by TradeSymmetry.
Disclaimer: Educational use only. Not financial advice.
Bassi MACD Pro + ADX Filter + Smart Histogram TP + RSIA professional-grade MACD indicator that dramatically reduces false signals by combining four powerful filters:
Key Features
Classic MACD (12,26,9) with clean, high-visibility histogram coloring
ADX + DI filter – only takes trades when ADX > user-defined threshold (default 25) ensuring you trade only in strong trending markets
Smart Histogram Take-Profit logic – automatically detects the exact moment bullish/bearish momentum starts to weaken after a strong move and marks a precise TP level (one TP per trade – no repainting, no multiple signals)
Zero-line crossover confirmation + histogram direction filter – eliminates many whipsaw signals common in regular MACD
Separate RSI pane with overbought/oversold levels and visual markers (for additional confluence – does not interfere with main logic)
Visual Signals
Green “MACD BUY” label + lime triangle = confirmed long entry in strong trend
Red “MACD SELL” label + red triangle = confirmed short entry in strong trend
Small lime/red “TP” triangles = Smart Histogram Take-Profit triggered (perfect exit timing based on momentum fade)
Alert Conditions Included
MACD BUY
MACD SELL
TP Long Hit
TP Short Hit
Combined “Any Signal” alert
Why this version outperforms standard MACD
Most MACD crossovers fail in ranging markets. This script solves that by:
Requiring strong trend (ADX filter)
Confirming histogram is actually growing in the new direction
Waiting for the true zero-line cross with momentum
Giving you an intelligent, non-fixed % take-profit based on real histogram exhaustion
Excellent for swing trading, day trading, crypto, forex, and stocks on any timeframe (works especially well on 1H–4H–Daily).
Clean, fast, no repainting, fully alert-ready.
Add to chart → set your alerts → trade only the highest-probability MACD signals.
Multi-TF Candle Gap DetectorHigh timeframe gap detector, these work well to identify key levels to trade from
