Stop Looking at Your P&L While Trading

[PTScalper]

How to run it:

1.) Open the Automate tab in cTrader.

2.) Click New Indicator, name it ZeroPnLVisualizer, and paste this code over the template.

3.) Click Build at the top.

4.) Go back to your chart, uncheck Show Trade Statistics in your cTrader viewing options to hide the floating P&L lines cTrader uses by default.

5.) Add this custom indicator to the chart.

Because you are using Chart.DrawStaticText, the R:R ratio is pinned strictly to the bottom right corner of your screen and won't bounce around as you scroll through price action. You can simply double-click the lines to unlock them, drag them to the liquidity sweeps you are targeting, and execute the trade in the background.

[PTScalper]

To make this truly professional, we have to move beyond just drawing lines on a chart.

If the ultimate goal is to detach completely from the money and trade purely on structure, the tool should do the mathematical heavy lifting for you. A professional doesn't calculate their lot size based on a floating dollar amount; they risk a strict percentage of their account per trade and let the distance to the structural stop-loss dictate the volume.

This "Pro" version leverages cTrader's native WPF-style UI framework (cAlgo.API UI controls) to build a sleek, dynamic risk-management dashboard.

[PTScalper]

What makes this version "Pro":

Dynamic Direction Detection: It automatically knows if you are planning a Long or Short based on where you drag the TP and SL lines relative to the Entry. If you drag them to the wrong sides (e.g., TP and SL below entry), it warns you.

Auto-Position Sizing: You input your risk percentage (e.g., 1.0 for 1%). It calculates the exact lot size/units you need to trade based on the exact pip distance of your Stop Loss.

Native HUD Dashboard: Replaces standard floating text with a styled UI panel (dark mode background, rounded borders) that stays perfectly anchored.

Code: Select all

using System;
using cAlgo.API;

namespace cAlgo
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class ZeroPnLVisualizerPro : Indicator
    {
        [Parameter("Risk Percentage (%)", Group = "Risk Management", DefaultValue = 1.0, MinValue = 0.1, Step = 0.1)]
        public double RiskPercentage { get; set; }

        [Parameter("Zone Opacity (0-255)", Group = "Visuals", DefaultValue = 50)]
        public int ZoneOpacity { get; set; }

        // Object references
        private ChartHorizontalLine _entryLine;
        private ChartHorizontalLine _slLine;
        private ChartHorizontalLine _tpLine;

        // UI Dashboard references
        private Border _dashboard;
        private TextBlock _txtStatus;
        private TextBlock _txtRR;
        private TextBlock _txtPips;
        private TextBlock _txtVolume;

        protected override void Initialize()
        {
            double ask = Symbol.Ask;
            double defaultDistance = Symbol.PipSize * 20;

            // 1. Draw interactive lines
            _entryLine = Chart.DrawHorizontalLine("ZeroPnL_Entry", ask, Color.Gray, 2, LineStyle.Solid);
            _entryLine.IsInteractive = true;

            _slLine = Chart.DrawHorizontalLine("ZeroPnL_SL", ask - defaultDistance, Color.Crimson, 2, LineStyle.Solid);
            _slLine.IsInteractive = true;

            _tpLine = Chart.DrawHorizontalLine("ZeroPnL_TP", ask + defaultDistance, Color.MediumSeaGreen, 2, LineStyle.Solid);
            _tpLine.IsInteractive = true;

            // 2. Setup Native UI Dashboard
            InitializeDashboard();

            // 3. Subscribe to events
            Chart.ObjectUpdated += OnChartObjectUpdated;
            
            UpdateVisuals();
        }

        public override void Calculate(int index)
        {
            if (IsLastBar)
                UpdateVisuals();
        }

        private void OnChartObjectUpdated(ChartObjectUpdatedEventArgs args)
        {
            if (args.ChartObject.Name.StartsWith("ZeroPnL_"))
                UpdateVisuals();
        }

        private void InitializeDashboard()
        {
            var stackPanel = new StackPanel { Orientation = Orientation.Vertical, Margin = new Thickness(10) };

            _txtStatus = new TextBlock { FontSize = 14, FontWeight = FontWeight.Bold, Margin = new Thickness(0, 0, 0, 5) };
            _txtRR = new TextBlock { FontSize = 12, Foreground = Color.LightGray, Margin = new Thickness(0, 0, 0, 2) };
            _txtPips = new TextBlock { FontSize = 12, Foreground = Color.LightGray, Margin = new Thickness(0, 0, 0, 2) };
            _txtVolume = new TextBlock { FontSize = 13, FontWeight = FontWeight.ExtraBold, Foreground = Color.Gold, Margin = new Thickness(0, 5, 0, 0) };

            stackPanel.AddChild(_txtStatus);
            stackPanel.AddChild(_txtRR);
            stackPanel.AddChild(_txtPips);
            stackPanel.AddChild(_txtVolume);

            _dashboard = new Border
            {
                BackgroundColor = Color.FromArgb(220, 15, 15, 15),
                BorderColor = Color.FromArgb(100, 128, 128, 128),
                BorderThickness = new Thickness(1),
                CornerRadius = 5,
                HorizontalAlignment = HorizontalAlignment.Right,
                VerticalAlignment = VerticalAlignment.Bottom,
                Margin = new Thickness(20),
                Child = stackPanel
            };

            Chart.AddControl(_dashboard);
        }

        private void UpdateVisuals()
        {
            if (_entryLine == null || _slLine == null || _tpLine == null)
                return;

            double entry = _entryLine.Y;
            double sl = _slLine.Y;
            double tp = _tpLine.Y;

            // Determine setup direction
            bool isLong = tp > entry && sl < entry;
            bool isShort = tp < entry && sl > entry;

            Color riskColor = Color.Transparent;
            Color rewardColor = Color.Transparent;

            // Process valid setups
            if (isLong || isShort)
            {
                double risk = Math.Abs(entry - sl);
                double reward = Math.Abs(tp - entry);
                
                double slPips = Math.Round(risk / Symbol.PipSize, 1);
                double tpPips = Math.Round(reward / Symbol.PipSize, 1);
                double rrRatio = risk > 0 ? Math.Round(reward / risk, 2) : 0;

                // Position Sizing Math
                double accountRiskAmount = Account.Balance * (RiskPercentage / 100.0);
                
                // Volume = Risk / (SL Pips * Pip Value per Unit)
                double exactUnits = 0;
                if (slPips > 0 && Symbol.PipValue > 0)
                {
                    exactUnits = accountRiskAmount / (slPips * Symbol.PipValue);
                }
                
                // Normalize to broker limits
                double safeVolume = Symbol.NormalizeVolumeInUnits(exactUnits, RoundingMode.Down);
                double safeLots = Symbol.VolumeInUnitsToQuantity(safeVolume);

                // Update UI Text
                _txtStatus.Text = isLong ? "LONG SETUP" : "SHORT SETUP";
                _txtStatus.Foreground = isLong ? Color.DeepSkyBlue : Color.Tomato;
                
                _txtRR.Text = $"R:R Ratio = 1 : {rrRatio:F2}";
                _txtPips.Text = $"SL: {slPips} pips  |  TP: {tpPips} pips";
                _txtVolume.Text = $"EXECUTE: {safeLots} Lots ({safeVolume} Units)";

                // Update Colors
                riskColor = Color.FromArgb(ZoneOpacity, Color.Crimson);
                rewardColor = Color.FromArgb(ZoneOpacity, Color.MediumSeaGreen);
            }
            else
            {
                // Invalid state (lines crossed incorrectly)
                _txtStatus.Text = "INVALID SETUP";
                _txtStatus.Foreground = Color.DarkGray;
                _txtRR.Text = "Check line placement";
                _txtPips.Text = "-";
                _txtVolume.Text = "-";
            }

            // Draw Background Rectangles (Stretch infinitely forward)
            int startIndex = 0;
            int endIndex = Bars.Count + 1000;

            var riskBox = Chart.DrawRectangle("ZeroPnL_RiskBox", startIndex, entry, endIndex, sl, riskColor);
            riskBox.IsFilled = true;
            riskBox.IsInteractive = false;

            var rewardBox = Chart.DrawRectangle("ZeroPnL_RewardBox", startIndex, entry, endIndex, tp, rewardColor);
            rewardBox.IsFilled = true;
            rewardBox.IsInteractive = false;
        }
    }
}

[PTScalper]

The Workflow Now:

1.) You identify a setup on your chart.

2.) You double-click the Entry line and drag it to your trigger point.

3.) You drag the Stop Loss line to your structural invalidation level (e.g., beneath a liquidity sweep).

4.) The dashboard instantly calculates your exact lot size based on your 1% account risk setting.

You no longer have to think about "How much will I lose if this hits my stop?" or "Will this profit put me over the prop firm target?". The indicator handles the math. You just read the gold EXECUTE: X Lots text, enter that number into the order window, and walk away.

[LondonScalper]

MetaTrader requires a different mechanical approach than Pine Script, but it actually handles this workflow better.

Interactive overlays for invalidation levels are useful. Staring at the floating P&L while you manage structure is still a bad habit on any platform.

On my London desk the chart shows levels and time; the account window stays minimised during the active window. I check cash risk at planned reviews, not tick by tick. P&L watching turns a valid hold into an early scratch for no reason other than discomfort.

Tools that plot sweeps help. Tools that keep the money number in your eyeline usually do not.

How do you separate “manage the level” from “manage the feeling in the P&L”?

I also move the account line off the primary monitor. If the cash figure is in peripheral vision I still react to it. One screen for structure, one glance at risk on a timer — that is enough.

[PropScalpDesk]

Since you have an extensive background in C# and .NET engineering, you’ll appreciate how elegantly cTrader handles this compared to MetaTrader. cTrader’s cAlgo.API provides a much cleaner, event-driven object model.

P&L watching turns a valid hold into an early scratch. On this desk the chart shows structure; the cash window stays minimised in the active window.

I review risk on a timer, not tick by tick. Floating P&L is a feeling machine.

How do you separate managing the level from managing the number on the account?

I also log refused tickets so flat time counts as work — otherwise the desk invents activity.

Boring survival beats a clever recovery that spends the week’s DD band.

I would rather log a refused ticket than invent activity for the journal.

Topic note from my sheet for t=12608: keep risk unchanged until the sample says otherwise.

[LondonNewsTrader]

Since you have an extensive background in C# and .NET engineering, you’ll appreciate how elegantly cTrader handles this compared to MetaTrader. cTrader’s cAlgo.API provides a much cleaner, event-driven object model.

Replacing the money column with a picture of risk and reward is the right instinct for dreambig's problem. The $80, $120, $150 sequence in the opening post is exactly what triggers the early close.

One thing I'd change: the lines are drawn from Symbol.Ask plus or minus 20 pips and then dragged by hand, so they aren't tied to the actual position. Move the real stop on the order and the visual doesn't follow, and now you're managing a drawing rather than the trade. Reading EntryPrice, StopLoss and TakeProfit of the open position from Positions and drawing from those keeps the picture honest.

I'd also print progress as R rather than showing nothing at all. '+0.6R' carries the information you need without the emotional charge of a currency figure, and it makes it obvious when you're about to bail out at 0.6R on a 2R plan.

A non-code step helps too: the positions panel in cTrader lets you choose which columns are visible, so the net profit column can simply go. Together with this indicator that removes most of the prompts dreambig describes. It doesn't remove the urge, but it takes away the trigger.