IconTextButton(String const& icon, String const& text)

: icon(icon)

{

setButtonText(text);

}

void setActiveColour(Colour const& background, Colour const& text)

{

activeBackground = background;

activeText = text;

repaint();

}

void paintButton(Graphics& g, bool shouldDrawButtonAsHighlighted, bool shouldDrawButtonAsDown) override

{

auto bounds = getLocalBounds().reduced(4, 0);

bool const on = getToggleState();

// Background

Colour background = on && activeBackground.has_value() ? *activeBackground : PlugDataColours::popupMenuBackgroundColour.contrasting(0.04f);

if (shouldDrawButtonAsDown || shouldDrawButtonAsHighlighted)

background = background.contrasting(0.04f);

g.setColour(background);

g.fillRoundedRectangle(bounds.toFloat(), 4.0f);

// Text + icon colour

Colour const foreground = on && activeBackground.has_value() ? activeText : PlugDataColours::popupMenuTextColour;

g.setColour(foreground);

g.setFont(Fonts::getCurrentFont().withHeight(14.f));

g.drawText(getButtonText(), bounds, Justification::centred, true);

// Icon on the left

auto iconBounds = bounds.removeFromLeft(getHeight());

Fonts::drawIcon(g, icon, iconBounds, foreground, 14);

}

String icon;

std::optional<Colour> activeBackground;

Colour activeText;

public:

VolumeSliderDecibelPopup()

{

setAlwaysOnTop(true);

}

void paint(Graphics& g) override

{

g.fillAll(PlugDataColours::levelMeterBackgroundColour);

g.setColour(PlugDataColours::toolbarTextColour.withAlpha(0.666f));

g.drawText(String(decibelValue) + "dB", getLocalBounds(), textJustification);

}

void setValue(float const newValue)

{

float realGain;

if (newValue <= 0.8f)

realGain = pow(jmap(newValue, 0.0f, 0.8f, 0.0f, 1.0f), 2.5f);

else

realGain = jmap(newValue, 0.8f, 1.0f, 1.0f, 2.0f);

decibelValue = std::clamp<int>(Decibels::gainToDecibels(realGain), -96, 6);

repaint();

}

void setJustification(Justification const justification)

{

textJustification = justification;

}

int decibelValue = 0;

Justification textJustification = Justification::left;

: Slider(Slider::LinearHorizontal, Slider::NoTextBox)

{

setSliderSnapsToMousePosition(false);

addListener(this);

decibelPopup.setAlpha(0.0f);

addChildComponent(decibelPopup);

updater.addAnimator(animator, [this]() {

decibelPopup.setVisible(animationFadeIn);

});

{

bool needsRepaint = false;

for (int i = 0; i < std::min<int>(peak.size(), 2); i++) {

audioLevel[i] *= fadeFactor;

if (peakBarsFade[i])

peakLevel[i] *= fadeFactor;

if (peak[i] > audioLevel[i]) {

audioLevel[i] = peak[i];

if (peak[i] >= 1.0f)

clipping[i] = true;

else

clipping[i] = false;

}

if (peak[i] > peakLevel[i]) {

peakLevel[i] = peak[i];

peakBarsFade[i] = false;

startTimer(i, 1700);

}

if (std::abs(peakLevel[i] - lastPeak[i]) > repaintTheshold

|| std::abs(audioLevel[i] - lastLevel[i]) > repaintTheshold

|| (peakLevel[i] == 0.0f && lastPeak[i] != 0.0f)

|| (audioLevel[i] == 0.0f && lastLevel[i] != 0.0f)) {

lastPeak[i] = peakLevel[i];

lastLevel[i] = audioLevel[i];

needsRepaint = true;

}

}

if (needsRepaint)

repaint();

{

auto const height = getHeight() / 4.0f;

auto const barHeight = height * 0.6f;

auto const halfBarHeight = barHeight * 0.5f;

auto const width = getWidth() - 12.0f;

constexpr auto x = 6.0f;

constexpr auto outerBorderWidth = 2.5f;

auto constexpr doubleOuterBorderWidth = 2.0f * outerBorderWidth;

auto const bgHeight = getHeight() - doubleOuterBorderWidth;

auto const bgWidth = width - doubleOuterBorderWidth;

auto const meterWidth = width - bgHeight;

auto const barWidth = meterWidth - 2;

auto const leftOffset = x + bgHeight * 0.5f;

g.setColour(PlugDataColours::levelMeterBackgroundColour);

g.fillRoundedRectangle(x + outerBorderWidth + 4, outerBorderWidth, bgWidth - 8, bgHeight, Corners::defaultCornerRadius);

for (int ch = 0; ch < numChannels; ch++) {

auto const barYPos = outerBorderWidth + (ch + 1) * (bgHeight / 3.0f) - halfBarHeight;

auto const barLength = jmin(audioLevel[ch] * barWidth, barWidth);

auto const peekPos = jmin(peakLevel[ch] * barWidth, barWidth);

if (peekPos > 1) {

g.setColour(clipping[ch] ? Colours::red : PlugDataColours::levelMeterActiveColour);

g.fillRect(leftOffset, barYPos, barLength, barHeight);

g.fillRect(leftOffset + peekPos, barYPos, 1.0f, barHeight);

}

}

auto const backgroundColour = PlugDataColours::levelMeterThumbColour;

auto const value = getValue();

auto const thumbSize = getHeight() * 0.66f;

auto const position = Point<float>(margin + value * (getWidth() - margin * 2), getHeight() * 0.5f);

auto thumb = Rectangle<float>(thumbSize, thumbSize).withCentre(position);

thumb = thumb.withSizeKeepingCentre(thumb.getWidth() - 12, thumb.getHeight());

g.setColour(backgroundColour.darker(thumb.contains(getMouseXYRelative().toFloat()) ? 0.3f : 0.0f).withAlpha(0.8f));

g.fillRoundedRectangle(thumb, Corners::defaultCornerRadius * 0.5f);

{

auto const value = getValue();

auto const thumbSize = getHeight() * 0.7f;

auto const sliderPosition = Point<int>(margin + value * (getWidth() - margin * 2), getHeight() * 0.5f);

auto const thumb = Rectangle<int>(thumbSize, thumbSize).withCentre(sliderPosition);

decibelPopup.setValue(value);

if (auto const shouldBeVisible = (thumb.contains(mousePosition) || isDragging)) {

if (value > 0.5f) {

decibelPopup.setBounds(Rectangle<int>(18, 2, 40, getHeight() - 4));

decibelPopup.setJustification(Justification::left);

} else {

decibelPopup.setBounds(Rectangle<int>(getWidth() - 50, 2, 40, getHeight() - 4));

decibelPopup.setJustification(Justification::right);

}

if (shouldBeVisible != decibelPopup.isVisible()) {

animationFadeIn = true;

decibelPopup.setVisible(true);

animator.start();

}

} else {

if (shouldBeVisible != decibelPopup.isVisible()) {

animationFadeIn = false;

animator.start();

}

}

{

repaint();

Slider::mouseEnter(e);

updatePopup(e.getPosition(), false);

{

repaint();

Slider::mouseExit(e);

updatePopup(e.getPosition(), false);

{

repaint();

Slider::mouseMove(e);

updatePopup(e.getPosition(), false);

{

repaint();

Slider::mouseUp(e);

{

if (!e.mods.isLeftButtonDown())

return;

repaint();

Slider::mouseDown(e);

void addMessage(MidiMessage const& message, bool isInput)

{

messages.add({ isInput, message });

if (messages.size() > 1000) {

messages.erase(messages.begin(), messages.begin() + (messages.size() - 1000));

}

NullCheckedInvocation::invoke(onChange);

}

void clear()

{

messages.clear();

NullCheckedInvocation::invoke(onChange);

}

std::pair<bool, MidiMessage> const& operator[](size_t const ind) const { return messages[messages.size() - ind - 1]; }

size_t size() const { return messages.size(); }

std::function<void()> onChange;

static constexpr auto numToStore = 1000;

HeapArray<std::pair<bool, MidiMessage>> messages;

, private TableListBoxModel {

enum {

messageColumn = 1,

channelColumn,

dataColumn

};

explicit MIDIHistory(PluginEditor* editor, MIDIListModel& model)

: messages(model)

, bouncer(table.getViewport())

{

addAndMakeVisible(table);

table.setColour(ListBox::backgroundColourId, Colours::transparentBlack);

table.setModel(this);

table.setClickingTogglesRowSelection(false);

table.setHeader([&] {

auto header = std::make_unique<TableHeaderComponent>();

header->addColumn("Type", messageColumn, 110, 30, -1, TableHeaderComponent::visible | TableHeaderComponent::appearsOnColumnMenu);

header->addColumn("Ch.", channelColumn, 45, 30, -1, TableHeaderComponent::visible | TableHeaderComponent::appearsOnColumnMenu);

header->addColumn("Message", dataColumn, 125, 30, -1, TableHeaderComponent::visible | TableHeaderComponent::appearsOnColumnMenu);

return header;

}());

table.getViewport()->setScrollBarsShown(true, false, false, false);

table.getViewport()->setViewPositionProportionately(0.0f, 1.0f);

midiHistoryTitle.setText("MIDI history", dontSendNotification);

midiHistoryTitle.setFont(Fonts::getBoldFont().withHeight(14.0f));

midiHistoryTitle.setJustificationType(Justification::centred);

addAndMakeVisible(midiHistoryTitle);

midiSettingsButton.onClick = [this, editor] {

Dialogs::showSettingsDialog(editor, 1);

closeCalloutBox();

};

addAndMakeVisible(midiSettingsButton);

messages.onChange = [&] { table.updateContent(); };

setSize(278, 200);

}

void closeCalloutBox()

{

MessageManager::callAsync([_callout = SafePointer(findParentComponentOfClass<CallOutBox>())]() {

if (_callout)

_callout->dismiss();

});

}

void paint(Graphics& g) override

{

g.setColour(PlugDataColours::levelMeterBackgroundColour);

g.fillRoundedRectangle(getLocalBounds().reduced(2, 32).toFloat(), Corners::defaultCornerRadius);

g.setColour(PlugDataColours::outlineColour);

g.drawLine(0, 58, getWidth(), 58);

}

~MIDIHistory() override { messages.onChange = nullptr; }

void resized() override

{

auto bounds = getLocalBounds();

midiHistoryTitle.setBounds(0, 6, getWidth(), 20);

midiSettingsButton.setBounds(bounds.removeFromBottom(32).reduced(2, 4).withTrimmedTop(1));

table.setBounds(bounds.withTrimmedTop(32).reduced(2, 0));

}

int getNumRows() override { return static_cast<int>(messages.size()); }

void paintRowBackground(Graphics&, int, int, int, bool) override { }

void paintCell(Graphics&, int, int, int, int, bool) override { }

Component* refreshComponentForCell(int const rowNumber,

int const columnId,

bool,

Component* existingComponentToUpdate) override

{

delete existingComponentToUpdate;

auto const index = static_cast<int>(messages.size()) - 1 - rowNumber;

auto const message = messages[static_cast<size_t>(index)];

auto* label = new Label({ }, [&] {

auto const direction = message.first ? "In: " : "Out: ";

switch (columnId) {

case messageColumn:

return direction + getEventString(message.second);

// case timeColumn: return String (message.getTimeStamp());

case channelColumn:

return String(message.second.getChannel());

case dataColumn:

return getDataString(message.second);

default:

break;

}

jassertfalse;

return String();

}());

label->setFont(Fonts::getDefaultFont().withHeight(14.0f));

return label;

}

static String getEventString(MidiMessage const& m)

{

if (m.isNoteOn())

return "Note on";

if (m.isNoteOff())

return "Note off";

if (m.isProgramChange())

return "Pgm. change";

if (m.isPitchWheel())

return "Pitch wheel";

if (m.isAftertouch())

return "Aftertouch";

if (m.isChannelPressure())

return "Ch. pressure";

if (m.isAllNotesOff())

return "All notes off";

if (m.isAllSoundOff())

return "All sound off";

if (m.isMetaEvent())

return "Meta event";

if (m.isController()) {

return "Ctl. " + String(m.getControllerNumber());

}

return String::toHexString(m.getRawData(), m.getRawDataSize());

}

static String getDataString(MidiMessage const& m)

{

if (m.isNoteOn())

return MidiMessage::getMidiNoteName(m.getNoteNumber(), true, true, 3) + " Velocity " + String(m.getVelocity());

if (m.isNoteOff())

return MidiMessage::getMidiNoteName(m.getNoteNumber(), true, true, 3) + " Velocity " + String(m.getVelocity());

if (m.isProgramChange())

return String(m.getProgramChangeNumber());

if (m.isPitchWheel())

return String(m.getPitchWheelValue());

if (m.isAftertouch())

return MidiMessage::getMidiNoteName(m.getNoteNumber(), true, true, 3) + ": " + String(m.getAfterTouchValue());

if (m.isChannelPressure())

return String(m.getChannelPressureValue());

if (m.isController())

return String(m.getControllerValue());

return { };

}

MIDIListModel& messages;

TableListBox table;

Label midiHistoryTitle;

BouncingViewportAttachment bouncer;

IconTextButton midiSettingsButton = IconTextButton(Icons::MIDI, "MIDI Settings...");

;

, public ToolbarSource::Listener

, public SettableTooltipClient {

MIDIBlinker()

{

setTooltip("MIDI activity");

setRepaintsOnMouseActivity(true);

lookAndFeelChanged();

}

void lookAndFeelChanged() override

{

activeColour = PlugDataColours::levelMeterActiveColour;

bgColour = PlugDataColours::levelMeterBackgroundColour;

textColour = PlugDataColours::toolbarTextColour;

}

void paint(Graphics& g) override

{

auto const isHovered = isMouseOver() || currentCalloutBox;

Fonts::drawIcon(g, Icons::MIDI, getLocalBounds().removeFromLeft(16).withTrimmedTop(1), textColour.brighter(isHovered ? 0.8f : 0.0f), 13);

auto const offsetY = getHeight() / 4.0f;

constexpr auto offsetX = 20.0f;

auto const midiInPos = Point<float>(offsetX, offsetY);

auto const midiOutPos = Point<float>(offsetX, offsetY * 2.4f);

g.setColour(blinkMidiIn ? activeColour : bgColour.brighter(isHovered ? 0.2f : 0.0f));

g.fillEllipse(midiInPos.x, midiInPos.y, 5, 5);

g.setColour(blinkMidiOut ? activeColour : bgColour.brighter(isHovered ? 0.2f : 0.0f));

g.fillEllipse(midiOutPos.x, midiOutPos.y, 5, 5);

}

void midiReceivedChanged(bool const midiReceived) override

{

blinkMidiIn = midiReceived;

repaint();

}

void midiSentChanged(bool const midiSent) override

{

blinkMidiOut = midiSent;

repaint();

}

void midiMessageReceived(MidiMessage const& midiReceived) override

{

messages.addMessage(midiReceived, true);

}

void midiMessageSent(MidiMessage const& midiSent) override

{

messages.addMessage(midiSent, false);

}

void mouseDown(MouseEvent const& e) override

{

if (!e.mods.isLeftButtonDown())

return;

// check if the callout is active, otherwise mouse down / up will trigger callout box again

if (isCallOutBoxActive) {

isCallOutBoxActive = false;

}

}

void mouseUp(MouseEvent const& e) override

{

if (!e.mods.isLeftButtonDown())

return;

if (!isCallOutBoxActive) {

auto* editor = findParentComponentOfClass<PluginEditor>();

auto midiLogger = std::make_unique<MIDIHistory>(editor, messages);

currentCalloutBox = &editor->showCalloutBox(std::move(midiLogger), getScreenBounds());

isCallOutBoxActive = true;

} else {

isCallOutBoxActive = false;

}

}

bool blinkMidiIn = false;

bool blinkMidiOut = false;

bool isCallOutBoxActive = false;

MIDIListModel messages;

Colour activeColour;

Colour bgColour;

Colour textColour;

static inline SafePointer<CallOutBox> currentCalloutBox = nullptr;

CPUHistoryGraph(CircularBuffer<float>& history, int const length)

: historyLength(length)

, historyGraph(history)

{

mappingMode = SettingsFile::getInstance()->getPropertyAsValue("cpu_meter_mapping_mode").getValue();

}

void resized() override

{

bounds = getLocalBounds().reduced(6);

roundedClip.addRoundedRectangle(bounds, Corners::defaultCornerRadius * 0.75f);

}

void paint(Graphics& g) override

{

// clip the rectangle to rounded corners

g.saveState();

g.reduceClipRegion(roundedClip);

g.setColour(PlugDataColours::levelMeterBackgroundColour);

g.fillRect(bounds);

auto bottom = bounds.getBottom();

auto height = bounds.getHeight();

auto const points = historyLength;

auto const distribute = static_cast<float>(bounds.getWidth()) / points;

Path graphTopLine;

auto getCPUScaledY = [this, bottom, height](float const value) -> float {

float graphValue;

switch (mappingMode) {

case 1:

graphValue = pow(value, 1.0f / 1.5f);

break;

case 2:

graphValue = pow(value, 1.0f / 3.5f);

break;

default:

graphValue = value;

break;

}

return bottom - height * graphValue;

};

auto const startPoint = Point<float>(bounds.getTopLeft().getX(), getCPUScaledY(0));

graphTopLine.startNewSubPath(startPoint);

auto lastValues = historyGraph.last(points);

for (int i = 0; i < points; i++) {

auto const xPos = i * distribute + bounds.getTopLeft().getX() + distribute;

auto const newPoint = Point<float>(xPos, getCPUScaledY(lastValues[i] * 0.01f));

graphTopLine.lineTo(newPoint);

}

Path graphFilled = graphTopLine;

graphFilled.lineTo(bounds.getBottomRight().toFloat());

graphFilled.lineTo(bounds.getBottomLeft().toFloat());

graphFilled.closeSubPath();

g.setColour(PlugDataColours::levelMeterActiveColour.withAlpha(0.3f));

g.fillPath(graphFilled);

g.setColour(PlugDataColours::levelMeterActiveColour);

g.strokePath(graphTopLine, PathStrokeType(1.0f));

g.restoreState();

}

void updateMapping(int const mapping)

{

if (mappingMode != mapping) {

mappingMode = mapping;

repaint();

}

}

int historyLength;

CircularBuffer<float>& historyGraph;

Rectangle<int> bounds;

Path roundedClip;

int mappingMode;

JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CPUHistoryGraph);

CPUMeterPopup(CircularBuffer<float>& history, CircularBuffer<float>& longHistory)

{

cpuGraph = std::make_unique<CPUHistoryGraph>(history, 200);

cpuGraphLongHistory = std::make_unique<CPUHistoryGraph>(longHistory, 300);

addAndMakeVisible(cpuGraph.get());

addAndMakeVisible(cpuGraphLongHistory.get());

fastGraphTitle.setText("CPU usage recent", dontSendNotification);

fastGraphTitle.setFont(Fonts::getBoldFont().withHeight(14.0f));

fastGraphTitle.setJustificationType(Justification::centred);

addAndMakeVisible(fastGraphTitle);

slowGraphTitle.setText("CPU usage last 5 minutes", dontSendNotification);

slowGraphTitle.setFont(Fonts::getBoldFont().withHeight(14.0f));

slowGraphTitle.setJustificationType(Justification::centred);

addAndMakeVisible(slowGraphTitle);

linear.setConnectedEdges(TextButton::ConnectedEdgeFlags::ConnectedOnRight);

logA.setConnectedEdges(TextButton::ConnectedEdgeFlags::ConnectedOnLeft | TextButton::ConnectedEdgeFlags::ConnectedOnRight);

logB.setConnectedEdges(TextButton::ConnectedEdgeFlags::ConnectedOnLeft);

auto buttons = SmallArray<TextButton*> { &linear, &logA, &logB };

int i = 0;

for (auto* button : buttons) {

button->setRadioGroupId(hash("cpu_meter_mapping_mode"));

button->setClickingTogglesState(true);

button->onClick = [this, i] {

SettingsFile::getInstance()->setProperty("cpu_meter_mapping_mode", i);

cpuGraph->updateMapping(i);

cpuGraphLongHistory->updateMapping(i);

};

button->setColour(TextButton::textColourOffId, PlugDataColours::popupMenuTextColour);

button->setColour(TextButton::textColourOnId, PlugDataColours::popupMenuTextColour);

button->setColour(TextButton::buttonColourId, PlugDataColours::popupMenuBackgroundColour.contrasting(0.04f));

button->setColour(TextButton::buttonOnColourId, PlugDataColours::popupMenuBackgroundColour.contrasting(0.075f));

button->setColour(ComboBox::outlineColourId, Colours::transparentBlack);

addAndMakeVisible(button);

i++;

}

auto const currentMappingMode = SettingsFile::getInstance()->getProperty<int>("cpu_meter_mapping_mode");

buttons[currentMappingMode]->setToggleState(true, dontSendNotification);

setSize(212, 177);

}

~CPUMeterPopup() override

{

onClose();

}

void resized() override

{

fastGraphTitle.setBounds(0, 6, getWidth(), 20);

cpuGraph->setBounds(0, fastGraphTitle.getBottom(), getWidth(), 50);

slowGraphTitle.setBounds(0, cpuGraph->getBottom(), getWidth(), 20);

cpuGraphLongHistory->setBounds(0, slowGraphTitle.getBottom(), getWidth(), 50);

auto b = getLocalBounds().withTop(cpuGraphLongHistory->getBottom() + 5).reduced(6, 0).withHeight(20);

auto const buttonWidth = getWidth() / 3;

linear.setBounds(b.removeFromLeft(buttonWidth));

logA.setBounds(b.removeFromLeft(buttonWidth).expanded(1, 0));

logB.setBounds(b.removeFromLeft(buttonWidth).expanded(1, 0));

}

std::function<void()> getUpdateFunc()

{

return [this] {

this->update();

};

}

std::function<void()> getUpdateFuncLongHistory()

{

return [this] {

this->updateLong();

};

}

std::function<void()> onClose = [] { };

void update()

{

cpuGraph->repaint();

}

void updateLong()

{

cpuGraphLongHistory->repaint();

}

Label fastGraphTitle;

Label slowGraphTitle;

std::unique_ptr<CPUHistoryGraph> cpuGraph;

std::unique_ptr<CPUHistoryGraph> cpuGraphLongHistory;

TextButton linear = TextButton("Linear");

TextButton logA = TextButton("Log A");

TextButton logB = TextButton("Log B");

JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CPUMeterPopup);

, public ToolbarSource::Listener

, public Timer

, public SettableTooltipClient {

CPUMeter()

{

startTimer(1000);

setTooltip("CPU usage");

setRepaintsOnMouseActivity(true);

}

void paint(Graphics& g) override

{

Colour textColour;

if (isMouseOver() || currentCalloutBox)

textColour = PlugDataColours::toolbarTextColour.brighter(0.8f);

else

textColour = PlugDataColours::toolbarTextColour;

Fonts::drawIcon(g, Icons::CPU, getLocalBounds().removeFromLeft(16), textColour, 14);

Fonts::drawFittedText(g, String(cpuUsageToDraw) + "%", getLocalBounds().withTrimmedLeft(22).withTrimmedTop(1), textColour, 1, 0.9f, 13.5, Justification::centredLeft);

}

void timerCallback() override

{

auto const lastCpuUsage = cpuUsage.last();

auto const oldCpuUsage = cpuUsageToDraw;

cpuUsageToDraw = round(lastCpuUsage);

cpuUsageLongHistory.push(lastCpuUsage);

updateCPUGraphLong();

if (oldCpuUsage != cpuUsageToDraw)

repaint();

}

void mouseDown(MouseEvent const& e) override

{

if (!e.mods.isLeftButtonDown())

return;

// check if the callout is active, otherwise mouse down / up will trigger callout box again

if (isCallOutBoxActive) {

isCallOutBoxActive = false;

}

}

void mouseUp(MouseEvent const& e) override

{

if (!e.mods.isLeftButtonDown())

return;

if (!isCallOutBoxActive) {

auto cpuHistory = std::make_unique<CPUMeterPopup>(cpuUsage, cpuUsageLongHistory);

updateCPUGraph = cpuHistory->getUpdateFunc();

updateCPUGraphLong = cpuHistory->getUpdateFuncLongHistory();

cpuHistory->onClose = [this] {

updateCPUGraph = [] { };

updateCPUGraphLong = [] { };

repaint();

};

auto* editor = findParentComponentOfClass<PluginEditor>();

currentCalloutBox = &editor->showCalloutBox(std::move(cpuHistory), getScreenBounds());

isCallOutBoxActive = true;

} else {

isCallOutBoxActive = false;

}

}

void cpuUsageChanged(float const newCpuUsage) override

{

cpuUsage.push(newCpuUsage);

updateCPUGraph();

}

std::function<void()> updateCPUGraph = [] { };

std::function<void()> updateCPUGraphLong = [] { };

static inline SafePointer<CallOutBox> currentCalloutBox = nullptr;

bool isCallOutBoxActive = false;

CircularBuffer<float> cpuUsage = CircularBuffer<float>(256);

CircularBuffer<float> cpuUsageLongHistory = CircularBuffer<float>(512);

int cpuUsageToDraw = 0;

JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(CPUMeter);