mirror of
https://codeberg.org/armin/rmx-19.git
synced 2026-10-11 16:51:55 +02:00
354 lines
13 KiB
C++
354 lines
13 KiB
C++
#include "PluginEditor.h"
|
||
#include "BuildInfo.h"
|
||
#include <juce_gui_basics/juce_gui_basics.h>
|
||
|
||
RackEditor::RackEditor (RMX19AudioProcessor& p)
|
||
: AudioProcessorEditor (p)
|
||
, proc (p)
|
||
, display (p)
|
||
{
|
||
face = juce::Colour (0xff16130f);
|
||
|
||
backgroundImage = juce::ImageFileFormat::loadFrom (BinaryData::b3_png,
|
||
BinaryData::b3_pngSize);
|
||
|
||
// circular joystick ring: angles run clockwise from 12 o'clock
|
||
up = new DirWedge ("UP", 0.0);
|
||
right = new DirWedge ("RIGHT", juce::MathConstants<double>::halfPi);
|
||
down = new DirWedge ("DOWN", juce::MathConstants<double>::pi);
|
||
left = new DirWedge ("LEFT", -juce::MathConstants<double>::halfPi);
|
||
|
||
okB = new CentreOkButton ("OK");
|
||
escB = new EscButton ("ESC");
|
||
|
||
for (auto* b : { (juce::Button*) up, (juce::Button*) down,
|
||
(juce::Button*) left, (juce::Button*) right,
|
||
(juce::Button*) okB, (juce::Button*) escB })
|
||
addAndMakeVisible (b);
|
||
|
||
up->onClick = [this] { display.navUp(); };
|
||
down->onClick = [this] { display.navDown(); };
|
||
left->onClick = [this] { display.navLeft(); };
|
||
right->onClick = [this] { display.navRight(); };
|
||
okB->onClick = [this] { display.navEnter(); };
|
||
escB->onClick = [this] { display.navExit(); };
|
||
|
||
addAndMakeVisible (display);
|
||
|
||
scaleBox.addItem ("50%", 1);
|
||
scaleBox.addItem ("75%", 2);
|
||
scaleBox.addItem ("100%", 3);
|
||
scaleBox.addItem ("125%", 4);
|
||
scaleBox.addItem ("150%", 5);
|
||
scaleBox.addItem ("200%", 6);
|
||
scaleBox.addItem ("250%", 7);
|
||
scaleBox.addItem ("300%", 8);
|
||
scaleBox.setSelectedId (5, juce::dontSendNotification);
|
||
scaleBox.setJustificationType (juce::Justification::centred);
|
||
scaleBox.setTextWhenNothingSelected ("UI scale");
|
||
scaleBox.setColour (juce::ComboBox::backgroundColourId, juce::Colour (0xff221d18));
|
||
scaleBox.setColour (juce::ComboBox::outlineColourId, juce::Colour (0xff6b5f4e));
|
||
scaleBox.setColour (juce::ComboBox::textColourId, juce::Colour (0xffd8cdb9));
|
||
scaleBox.setColour (juce::ComboBox::arrowColourId, juce::Colour (0xffd8cdb9));
|
||
scaleBox.setColour (juce::PopupMenu::backgroundColourId, juce::Colour (0xff1c1813));
|
||
scaleBox.setColour (juce::PopupMenu::textColourId, juce::Colour (0xffd8cdb9));
|
||
scaleBox.setColour (juce::PopupMenu::highlightedBackgroundColourId, juce::Colour (0xff3a332b));
|
||
scaleBox.onChange = [this]
|
||
{
|
||
switch (scaleBox.getSelectedId())
|
||
{
|
||
case 1: setScale (0.5f); break;
|
||
case 2: setScale (0.75f); break;
|
||
case 3: setScale (1.0f); break;
|
||
case 4: setScale (1.25f); break;
|
||
case 5: setScale (1.5f); break;
|
||
case 6: setScale (2.0f); break;
|
||
case 7: setScale (2.5f); break;
|
||
case 8: setScale (3.0f); break;
|
||
default: break;
|
||
}
|
||
};
|
||
addAndMakeVisible (scaleBox);
|
||
|
||
setWantsKeyboardFocus (true);
|
||
setScale (1.5f);
|
||
startTimerHz (18);
|
||
}
|
||
|
||
RackEditor::~RackEditor()
|
||
{
|
||
stopTimer();
|
||
}
|
||
|
||
void RackEditor::paint (juce::Graphics& g)
|
||
{
|
||
// full-area backdrop so scaled edges stay covered
|
||
g.fillAll (juce::Colour (0xff0d0b09));
|
||
|
||
const auto b = juce::Rectangle<int> (0, 0, baseW, baseH);
|
||
|
||
// --- metal rack face (b3.png background, cover-scaled) ---
|
||
if (backgroundImage.isValid())
|
||
{
|
||
const float imageAspect = (float) backgroundImage.getWidth() / (float) backgroundImage.getHeight();
|
||
const float boxAspect = (float) b.getWidth() / (float) b.getHeight();
|
||
|
||
int sx = 0, sy = 0, sw = backgroundImage.getWidth(), sh = backgroundImage.getHeight();
|
||
if (imageAspect > boxAspect)
|
||
{
|
||
sw = (int) (backgroundImage.getHeight() * boxAspect);
|
||
sx = (backgroundImage.getWidth() - sw) / 2;
|
||
}
|
||
else
|
||
{
|
||
sh = (int) (backgroundImage.getWidth() / boxAspect);
|
||
sy = (backgroundImage.getHeight() - sh) / 2;
|
||
}
|
||
g.drawImage (backgroundImage, b.getX(), b.getY(),
|
||
juce::roundToInt (b.getWidth() * uiScale),
|
||
juce::roundToInt (b.getHeight() * uiScale),
|
||
sx, sy, sw, sh);
|
||
}
|
||
else
|
||
{
|
||
g.setColour (face);
|
||
g.fillRect (b);
|
||
}
|
||
|
||
g.setColour (juce::Colour (0xff08));
|
||
g.addTransform (juce::AffineTransform::scale (uiScale));
|
||
|
||
// brushed texture
|
||
g.setColour (juce::Colour::fromRGBA (255, 255, 255, 7));
|
||
for (int x = 0; x < b.getWidth(); x += 3)
|
||
g.fillRect (x, 0, 1, b.getHeight());
|
||
|
||
// rack rails (top/bottom)
|
||
g.setColour (juce::Colour (0xff221e1a));
|
||
g.fillRect (0, 0, b.getWidth(), 4);
|
||
g.fillRect (0, b.getHeight() - 4, b.getWidth(), 4);
|
||
g.setColour (juce::Colour (0xff5a5347));
|
||
g.fillRect (0, 4, b.getWidth(), 1);
|
||
g.fillRect (0, b.getHeight() - 5, b.getWidth(), 1);
|
||
|
||
// brand plate
|
||
g.setColour (juce::Colour (0xff614f3a));
|
||
g.fillRect (12, 6, 150, 12);
|
||
g.setColour (juce::Colour (0xffc9a86f));
|
||
g.setFont (juce::FontOptions ("Arial", 10.0f, juce::Font::bold));
|
||
g.drawFittedText ("RMX-19", 12, 6, 150, 12, juce::Justification::centred, 1);
|
||
|
||
// rear engraving text (kept clear of the UI-scale dropdown at the bottom right)
|
||
g.setColour (juce::Colour (0xff6e6657));
|
||
g.setFont (juce::FontOptions ("Courier New", 8.0f, juce::Font::plain));
|
||
const juce::String ser = "RMX-19 S/N 0001-1943-04-19 24BIT/96K SUPER SOUND MODULE BUILT "
|
||
+ juce::String (BUILD_DATE) + " " + juce::String (BUILD_TIME);
|
||
g.drawFittedText (ser, 12, b.getHeight() - 16, b.getWidth() - 128, 11, juce::Justification::centred, 1);
|
||
}
|
||
|
||
void RackEditor::resized()
|
||
{
|
||
// everything renders in base 656×248 space, scaled by an affine transform
|
||
const juce::AffineTransform tf = juce::AffineTransform::scale (uiScale);
|
||
|
||
// UI-scale dropdown now scales with the rest of the UI
|
||
scaleBox.setTransform (tf);
|
||
scaleBox.setBounds (baseW - 112, baseH - 30, 104, 20);
|
||
|
||
// LCD recessed module
|
||
const juce::Rectangle<int> lcdArea (14, 24, 356, 168);
|
||
display.setTransform (tf);
|
||
display.setBounds (lcdArea);
|
||
|
||
// circular joystick ring + separate ESC key, to the right of the LCD
|
||
const juce::Rectangle<int> navArea (lcdArea.getRight() + 16, 26, baseW - lcdArea.getRight() - 30, 164);
|
||
|
||
constexpr float ro = DirWedge::outerR;
|
||
const float ringCx = (float) navArea.getCentreX();
|
||
const float ringCy = (float) lcdArea.getCentreY(); // ring sits centred on the display
|
||
|
||
// all four wedges share the ring's bounding box; each paints only its own sector
|
||
const juce::Rectangle<int> ringBox ((int) (ringCx - ro), (int) (ringCy - ro),
|
||
(int) (ro * 2.0f), (int) (ro * 2.0f));
|
||
|
||
up->setTransform (tf); up->setBounds (ringBox);
|
||
right->setTransform (tf); right->setBounds (ringBox);
|
||
down->setTransform (tf); down->setBounds (ringBox);
|
||
left->setTransform (tf); left->setBounds (ringBox);
|
||
|
||
// OK, dead centre of the ring
|
||
okB->setTransform (tf);
|
||
okB->setBounds ((int) (ringCx - CentreOkButton::radius), (int) (ringCy - CentreOkButton::radius),
|
||
(int) (CentreOkButton::radius * 2.0f), (int) (CentreOkButton::radius * 2.0f));
|
||
|
||
// ESC, a round key centred on the point the old rectangular key occupied
|
||
constexpr float escD = EscButton::diameter;
|
||
const float escCx = (float) navArea.getX() + 54.0f;
|
||
const float escCy = (float) ringBox.getBottom() - 10.0f;
|
||
escB->setTransform (tf);
|
||
escB->setBounds ((int) (escCx - escD * 0.5f), (int) (escCy - escD * 0.5f),
|
||
(int) escD, (int) escD);
|
||
}
|
||
|
||
void RackEditor::setScale (float s)
|
||
{
|
||
uiScale = s;
|
||
setSize (juce::roundToInt (baseW * s), juce::roundToInt (baseH * s));
|
||
resized(); // ensure child layouts refresh at the new size
|
||
}
|
||
|
||
void RackEditor::timerCallback()
|
||
{
|
||
powerPulse = 0.5f + 0.5f * std::sin (juce::Time::getMillisecondCounter() * 0.0022f);
|
||
// only the pulsing power LED needs redraws; everything else is static
|
||
const int ledX = getWidth() - 20, ledY = 18;
|
||
repaint (ledX - 26, ledY - 7, 30, 14);
|
||
}
|
||
|
||
bool RackEditor::keyPressed (const juce::KeyPress& k)
|
||
{
|
||
if (display.keyTrap (k))
|
||
{
|
||
repaint();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// ---- buttons -------------------------------------------------------------
|
||
|
||
// shared palette for the black joystick keys
|
||
static const juce::Colour keyFace (0xff080808); // black key body
|
||
static const juce::Colour keyDown (0xff1c1c1c); // pressed
|
||
static const juce::Colour keyRim (0xff4a4741); // keeps black keys legible on dark metal
|
||
static const juce::Colour keyRimDn (0xff8a8a86);
|
||
static const juce::Colour legendIdle (0xfff2f2f2); // white arrow legends
|
||
static const juce::Colour legendHot (0xffffffff);
|
||
|
||
// solid triangular arrow centred on `centre`, pointing along `angleRad`
|
||
// (radians clockwise from 12 o'clock, screen y pointing down)
|
||
static void drawArrow (juce::Graphics& g, const juce::Point<float>& centre,
|
||
double angleRad, float size)
|
||
{
|
||
const float dx = (float) std::sin (angleRad);
|
||
const float dy = (float) -std::cos (angleRad);
|
||
const float px = -dy, py = dx; // perpendicular, for the two rear corners
|
||
|
||
const float back = size * 0.80f;
|
||
const float wide = size * 0.85f;
|
||
|
||
juce::Path t;
|
||
t.startNewSubPath (centre.x + dx * size, centre.y + dy * size);
|
||
t.lineTo (centre.x - dx * back + px * wide, centre.y - dy * back + py * wide);
|
||
t.lineTo (centre.x - dx * back - px * wide, centre.y - dy * back - py * wide);
|
||
t.closeSubPath();
|
||
g.fillPath (t);
|
||
}
|
||
|
||
void RackEditor::DirWedge::paintButton (juce::Graphics& g, bool over, bool down)
|
||
{
|
||
const juce::Point<float> c (outerR, outerR);
|
||
|
||
// a pressed key sinks slightly into the ring
|
||
const float ro = down ? outerR - 1.5f : outerR;
|
||
const float ri = down ? innerR + 1.5f : innerR;
|
||
|
||
const double a0 = angle - halfSpan;
|
||
const double a1 = angle + halfSpan;
|
||
|
||
juce::Path wedge;
|
||
wedge.startNewSubPath (c.getPointOnCircumference (ro, a0));
|
||
wedge.addCentredArc (c.x, c.y, ro, ro, 0.0f, a0, a1, false);
|
||
wedge.lineTo (c.getPointOnCircumference (ri, a1));
|
||
wedge.addCentredArc (c.x, c.y, ri, ri, 0.0f, a1, a0, false);
|
||
wedge.closeSubPath();
|
||
|
||
g.setColour (down ? keyDown : keyFace);
|
||
g.fillPath (wedge);
|
||
g.setColour (down ? keyRimDn : keyRim);
|
||
g.strokePath (wedge, juce::PathStrokeType (1.0f));
|
||
|
||
// white arrow legend, centred across the wedge band and pointing outwards
|
||
g.setColour (over || down ? legendHot : legendIdle);
|
||
drawArrow (g, c.getPointOnCircumference ((innerR + outerR) * 0.5f, angle), angle, 11.0f);
|
||
}
|
||
|
||
bool RackEditor::DirWedge::hitTest (int x, int y)
|
||
{
|
||
if (! juce::Component::hitTest (x, y))
|
||
return false;
|
||
|
||
const float dx = (float) x - outerR;
|
||
const float dy = (float) y - outerR;
|
||
const float r = std::sqrt (dx * dx + dy * dy);
|
||
|
||
if (r < innerR || r > outerR)
|
||
return false;
|
||
|
||
// same convention as the painted sector: radians clockwise from 12 o'clock
|
||
double diff = std::atan2 (dx, -dy) - angle;
|
||
|
||
for (; diff > juce::MathConstants<double>::pi; diff -= juce::MathConstants<double>::twoPi) {}
|
||
for (; diff < -juce::MathConstants<double>::pi; diff += juce::MathConstants<double>::twoPi) {}
|
||
|
||
return std::abs (diff) <= halfSpan;
|
||
}
|
||
|
||
bool RackEditor::CentreOkButton::hitTest (int x, int y)
|
||
{
|
||
if (! juce::Component::hitTest (x, y))
|
||
return false;
|
||
|
||
const float dx = (float) x - radius;
|
||
const float dy = (float) y - radius;
|
||
|
||
return dx * dx + dy * dy <= radius * radius;
|
||
}
|
||
|
||
void RackEditor::CentreOkButton::paintButton (juce::Graphics& g, bool over, bool down)
|
||
{
|
||
const auto c = getLocalBounds().getCentre().toFloat();
|
||
const float r = radius - (down ? 1.0f : 0.0f);
|
||
|
||
juce::Path disc;
|
||
disc.addEllipse (c.x - r, c.y - r, r * 2.0f, r * 2.0f);
|
||
|
||
g.setColour (down ? keyDown : keyFace);
|
||
g.fillPath (disc);
|
||
g.setColour (down ? keyRimDn : keyRim);
|
||
g.strokePath (disc, juce::PathStrokeType (1.0f));
|
||
|
||
g.setColour (over || down ? legendHot : legendIdle);
|
||
g.setFont (juce::FontOptions ("Arial", 9.5f, juce::Font::bold));
|
||
g.drawText (getName(), getLocalBounds(), juce::Justification::centred, true);
|
||
}
|
||
|
||
bool RackEditor::EscButton::hitTest (int x, int y)
|
||
{
|
||
if (! juce::Component::hitTest (x, y))
|
||
return false;
|
||
|
||
const float r = diameter * 0.5f;
|
||
const float dx = (float) x - r;
|
||
const float dy = (float) y - r;
|
||
|
||
return dx * dx + dy * dy <= r * r;
|
||
}
|
||
|
||
void RackEditor::EscButton::paintButton (juce::Graphics& g, bool over, bool down)
|
||
{
|
||
const auto c = getLocalBounds().getCentre().toFloat();
|
||
const float r = diameter * 0.5f - (down ? 1.0f : 0.0f);
|
||
|
||
juce::Path disc;
|
||
disc.addEllipse (c.x - r, c.y - r, r * 2.0f, r * 2.0f);
|
||
|
||
g.setColour (down ? keyDown : keyFace);
|
||
g.fillPath (disc);
|
||
g.setColour (down ? keyRimDn : keyRim);
|
||
g.strokePath (disc, juce::PathStrokeType (1.0f));
|
||
|
||
g.setColour (over || down ? legendHot : legendIdle);
|
||
g.setFont (juce::FontOptions ("Arial", 7.0f, juce::Font::bold));
|
||
g.drawText (getName(), getLocalBounds(), juce::Justification::centred, true);
|
||
}
|