// Super Timecode Converter

// Copyright (c) 2026 Fiverecords -- MIT License

// https://github.com/fiverecords/SuperTimecodeConverter

#pragma once

#include <JuceHeader.h>

#include "TimecodeCore.h"

#include "CustomLookAndFeel.h" // getMonoFontName(), measureStringWidth()

class TimecodeDisplay : public juce::Component

{

public:

TimecodeDisplay()

{

setOpaque(false);

}

void setTimecode(const Timecode& tc)

{

if (currentTimecode.hours != tc.hours ||

currentTimecode.minutes != tc.minutes ||

currentTimecode.seconds != tc.seconds ||

currentTimecode.frames != tc.frames)

{

currentTimecode = tc;

repaint();

}

}

void setFrameRate(FrameRate fps)

{

if (currentFps != fps)

{

currentFps = fps;

repaint();

}

}

void setSourceName(const juce::String& name)

{

if (sourceName != name)

{

sourceName = name;

repaint();

}

}

void setRunning(bool isRunning)

{

if (running != isRunning)

{

running = isRunning;

repaint();

}

}

// FPS conversion display state

void setFpsConvertEnabled(bool enabled)

{

if (fpsConvertActive != enabled)

{

fpsConvertActive = enabled;

repaint();

}

}

void setOutputTimecode(const Timecode& tc)

{

if (outTimecode.hours != tc.hours ||

outTimecode.minutes != tc.minutes ||

outTimecode.seconds != tc.seconds ||

outTimecode.frames != tc.frames)

{

outTimecode = tc;

if (fpsConvertActive) repaint();

}

}

void setOutputFrameRate(FrameRate fps)

{

if (outFps != fps)

{

outFps = fps;

if (fpsConvertActive) repaint();

}

}

void paint(juce::Graphics& g) override

{

auto bounds = getLocalBounds().toFloat();

// --- Status indicator colour ---

auto statusColour = running ? juce::Colour(0xFF2E7D32) : juce::Colour(0xFF37474F);

// --- Main timecode display ---

juce::String tcText = currentTimecode.toDisplayString(currentFps);

// Scale font to fit available width

// When FPS convert is active, we need room for "/FF" suffix (~14 chars total)

float maxFontSize = 72.0f;

float availW = bounds.getWidth() - 20.0f;

float totalChars = fpsConvertActive ? 14.0f : 11.0f;

// Compute character width ratio dynamically from the actual font metrics

// (avoids hardcoded values that only match a single platform's monospace font)

auto measureFont = juce::Font(juce::FontOptions(getMonoFontName(), maxFontSize, juce::Font::bold));

float charWidthRatio = measureStringWidth(measureFont, "0") / maxFontSize;

if (charWidthRatio <= 0.0f) charWidthRatio = 0.6f; // safe fallback

float fittedSize = availW / (totalChars * charWidthRatio);

float fontSize = juce::jmin(maxFontSize, juce::jmax(24.0f, fittedSize));

float tcHeight = fontSize * 1.25f;

float labelSize = juce::jmin(9.0f, fontSize * 0.14f);

float labelH = 14.0f;

float statusH = 14.0f;

float gap1 = 8.0f; // status -> tc

float gap2 = 4.0f; // tc -> labels

// Total content block height

float contentH = statusH + gap1 + tcHeight + gap2 + labelH;

// Center vertically, but leave room for bottom info

float usableH = bounds.getHeight() - 50.0f; // reserve 50px for source/fps info

float contentY = bounds.getY() + (usableH - contentH) / 2.0f;

contentY = juce::jmax(bounds.getY() + 10.0f, contentY); // don't go above top

// --- Status indicator (dot + label, centred as a unit) ---

float statusY = contentY;

juce::String statusText = running ? "RUNNING" : "STOPPED";

juce::Font statusFont(juce::FontOptions(getMonoFontName(), 11.0f, juce::Font::plain));

float dotSize = 6.0f;

float dotGap = 6.0f;

float textW = measureStringWidth(statusFont, statusText);

float groupW = dotSize + dotGap + textW;

float groupX = bounds.getCentreX() - groupW / 2.0f;

g.setColour(statusColour);

float textMidY = statusY + statusH / 2.0f;

g.fillEllipse(groupX, textMidY - dotSize / 2.0f - 1.0f, dotSize, dotSize);

g.setColour(running ? juce::Colour(0xFF66BB6A) : juce::Colour(0xFF546E7A));

g.setFont(statusFont);

g.drawText(statusText,

juce::Rectangle<float>(groupX + dotSize + dotGap, statusY, textW + 4.0f, statusH),

juce::Justification::centredLeft);

// --- Timecode text ---

float tcY = statusY + statusH + gap1;

juce::Font tcFont(juce::FontOptions(getMonoFontName(), fontSize, juce::Font::bold));

g.setFont(tcFont);

// Timecode colour: bright green when running, muted gray when stopped

auto tcColour = running ? juce::Colour(0xFF00E676) : juce::Colour(0xFF546E7A);

if (fpsConvertActive)

{

// Split rendering: main TC in running colour, "/FF" suffix in cyan/dimmed

juce::String outFrameStr = juce::String::formatted("%02d",

juce::jlimit(0, 29, outTimecode.frames));

juce::String fullText = tcText + "/" + outFrameStr;

// Measure widths to position both parts

float fullW = measureStringWidth(tcFont, fullText);

float mainW = measureStringWidth(tcFont, tcText);

float suffixW = fullW - mainW;

float textStartX = bounds.getCentreX() - fullW / 2.0f;

// Draw main TC (input)

g.setColour(tcColour);

g.drawText(tcText,

juce::Rectangle<float>(textStartX, tcY, mainW, tcHeight),

juce::Justification::centredLeft);

// Draw "/FF" suffix -- cyan when running, dimmer when stopped

g.setColour(running ? juce::Colour(0xFF00ACC1) : juce::Colour(0xFF37474F));

g.drawText("/" + outFrameStr,

juce::Rectangle<float>(textStartX + mainW, tcY, suffixW, tcHeight),

juce::Justification::centredLeft);

}

else

{

// Standard display

g.setColour(tcColour);

g.drawText(tcText,

juce::Rectangle<float>(bounds.getX(), tcY, bounds.getWidth(), tcHeight),

juce::Justification::centred);

}

// --- Labels under each pair ---

float labelY = tcY + tcHeight + gap2;

g.setFont(juce::Font(juce::FontOptions(getMonoFontName(), juce::jmax(7.0f, labelSize), juce::Font::plain)));

// Compute label positions based on the full displayed text width

float centerX = bounds.getCentreX();

float displayChars = fpsConvertActive ? 14.0f : 11.0f;

float tcWidth = fontSize * displayChars * charWidthRatio;

float startX = centerX - tcWidth / 2.0f;

if (fpsConvertActive)

{

// Character layout: HH:MM:SS.FF/FF = 14 chars

// Positions: 01 2 34 5 67 8 9A B CD

// Centre of each group:

// HRS = chars 0-1 -> centre at char 1.0

// MIN = chars 3-4 -> centre at char 3.5

// SEC = chars 6-7 -> centre at char 6.5

// FRM = chars 9-10 -> centre at char 9.5

// OUT = chars 12-13-> centre at char 12.5

float charW = tcWidth / displayChars;

float posHrs = startX + 1.0f * charW;

float posMn = startX + 3.5f * charW;

float posSec = startX + 6.5f * charW;

float posFrm = startX + 9.5f * charW;

float posOut = startX + 12.5f * charW;

g.setColour(juce::Colour(0xFF546E7A));

g.drawText("HRS", juce::Rectangle<float>(posHrs - 15.0f, labelY, 30.0f, 14.0f), juce::Justification::centred);

g.drawText("MIN", juce::Rectangle<float>(posMn - 15.0f, labelY, 30.0f, 14.0f), juce::Justification::centred);

g.drawText("SEC", juce::Rectangle<float>(posSec - 15.0f, labelY, 30.0f, 14.0f), juce::Justification::centred);

g.drawText("FRM", juce::Rectangle<float>(posFrm - 15.0f, labelY, 30.0f, 14.0f), juce::Justification::centred);

// "OUT" label in cyan under the converted frame digits

g.setColour(juce::Colour(0xFF00838F));

g.drawText("OUT", juce::Rectangle<float>(posOut - 15.0f, labelY, 30.0f, 14.0f), juce::Justification::centred);

}

else

{

float segW = tcWidth / 4.0f;

float positions[] = { startX + segW * 0.5f, startX + segW * 1.5f,

startX + segW * 2.5f, startX + segW * 3.5f };

const char* labels[] = { "HRS", "MIN", "SEC", "FRM" };

g.setColour(juce::Colour(0xFF546E7A));

for (int i = 0; i < 4; i++)

{

g.drawText(labels[i],

juce::Rectangle<float>(positions[i] - 15.0f, labelY, 60.0f, 14.0f),

juce::Justification::centred);

}

}

// --- Source + FPS info ---

float infoY = bounds.getBottom() - 40.0f;

g.setFont(juce::Font(juce::FontOptions(getMonoFontName(), 10.0f, juce::Font::plain)));

if (fpsConvertActive)

{

// Show both input and output rates with arrow

juce::String inLabel = "SOURCE: " + sourceName + " | "

+ frameRateToString(currentFps);

juce::String arrow = " -> ";

juce::String outLabel = frameRateToString(outFps) + " FPS";

// Measure to centre the full composite string

juce::Font infoFont(juce::FontOptions(getMonoFontName(), 10.0f, juce::Font::plain));

g.setFont(infoFont);

float inW = measureStringWidth(infoFont, inLabel);

float arW = measureStringWidth(infoFont, arrow);

float outW = measureStringWidth(infoFont, outLabel);

float totW = inW + arW + outW;

float sx = bounds.getCentreX() - totW / 2.0f;

g.setColour(juce::Colour(0xFF37474F));

g.drawText(inLabel, juce::Rectangle<float>(sx, infoY, inW, 14.0f),

juce::Justification::centredLeft);

g.setColour(juce::Colour(0xFF546E7A));

g.drawText(arrow, juce::Rectangle<float>(sx + inW, infoY, arW, 14.0f),

juce::Justification::centredLeft);

g.setColour(juce::Colour(0xFF00ACC1));

g.drawText(outLabel, juce::Rectangle<float>(sx + inW + arW, infoY, outW, 14.0f),

juce::Justification::centredLeft);

}

else

{

g.setColour(juce::Colour(0xFF37474F));

juce::String infoText = "SOURCE: " + sourceName + " | "

+ frameRateToString(currentFps) + " FPS";

g.drawText(infoText,

juce::Rectangle<float>(0.0f, infoY, bounds.getWidth(), 14.0f),

juce::Justification::centred);

}

}

private:

Timecode currentTimecode;

FrameRate currentFps = FrameRate::FPS_30;

juce::String sourceName = "SYSTEM";

bool running = false;

// FPS conversion state

bool fpsConvertActive = false;

Timecode outTimecode;

FrameRate outFps = FrameRate::FPS_30;

JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(TimecodeDisplay)

};