Krotos_LookAndFeel.cpp

Go to the documentation of this file.

#include "Krotos_LookAndFeel.h"
 
namespace krotos
{
    const Identifier Krotos_LookAndFeel::Properties::AlertWindow::AlertWidthID{"AlertWidth"};
    const Identifier Krotos_LookAndFeel::Properties::AlertWindow::AlertHeightID{"AlertHeight"};
 
    const Identifier Krotos_LookAndFeel::Properties::ComboBox::DisableHover{"DisableHover"};
    const Identifier Krotos_LookAndFeel::Properties::ComboBox::RoundedCornerID{"RoundedCornerID"};
    const Identifier Krotos_LookAndFeel::Properties::ComboBox::IconPositionID{"ComboBoxIconPosition"};
    const Identifier Krotos_LookAndFeel::Properties::ComboBox::FontSize{"ComboBoxFontSize"};
    const Identifier Krotos_LookAndFeel::Properties::ComboBox::UseCustomIcon{"ComboBoxUseCustomIcon"};
 
    Krotos_LookAndFeel::Krotos_LookAndFeel() { setColourScheme(getKrotosDefaultColourScheme()); }
 
#ifdef CONCEPT_STYLE
 
    // The rotary slider style used in Concept
    void Krotos_LookAndFeel::drawRotarySlider(Graphics& g, int x, int y, int width, int height, float sliderPos,
                                              float rotaryStartAngle, float rotaryEndAngle, juce::Slider& slider)
    {
        float border = 5.0; // Must leave enough space around the slider for the shadow
 
        float radius((float)juce::jmin(width / 2, height / 2));
        radius -= border;
        const float centreX(x + width * 0.5f);
        const float centreY(y + height * 0.5f);
        const float rx(centreX - radius);
        const float ry(centreY - radius);
        const float rw(radius * 2.0f);
        const float angle(rotaryStartAngle + sliderPos * (rotaryEndAngle - rotaryStartAngle));
        const bool isMouseOver(slider.isMouseOverOrDragging() && slider.isEnabled());
        juce::DropShadow shadow(juce::DropShadow(juce::Colours::black.withAlpha(0.22f), /*Radius*/ 2,
                                                 /*offset*/ juce::Point<int>(3, 3)));
        auto fillColour = findColour(Slider::ColourIds::rotarySliderFillColourId);
        auto backgroundColour = findColour(Slider::ColourIds::backgroundColourId);
        auto disabledFillColour = fillColour.darker();
        auto disabledBackgroundColour = backgroundColour.darker();
 
        if (radius > 12.0f)
        {
            const float thickness = 0.75f;
 
            {
                juce::Path p;
                g.fillPath(p, juce::AffineTransform::rotation(angle).translated(centreX, centreY));
            }
 
            slider.isEnabled() ? g.setColour(backgroundColour) : g.setColour(disabledBackgroundColour);
 
            // Slider background
            juce::Path outlineArc;
            outlineArc.addPieSegment(rx, ry, rw, rw, rotaryStartAngle, rotaryEndAngle, thickness);
            outlineArc.closeSubPath();
            g.fillPath(outlineArc);
 
            // Slider track
            slider.isEnabled() ? g.setColour(fillColour) : g.setColour(disabledFillColour);
            juce::Path filledArc;
            filledArc.addPieSegment(rx, ry, rw, rw, rotaryStartAngle, angle, thickness);
            g.fillPath(filledArc);
            shadow.drawForPath(g, outlineArc);
        }
        else
        {
            if (slider.isEnabled())
            {
                g.setColour(fillColour.withAlpha(isMouseOver ? 1.0f : 0.7f));
            }
            else
            {
                g.setColour(disabledBackgroundColour);
            }
 
            juce::Path p;
            p.addEllipse(-0.4f * rw, -0.4f * rw, rw * 0.8f, rw * 0.8f);
            juce::PathStrokeType(rw * 0.1f).createStrokedPath(p, p);
 
            p.addLineSegment(juce::Line<float>(0.0f, 0.0f, 0.0f, -radius), rw * 0.2f);
 
            g.fillPath(p, juce::AffineTransform::rotation(angle).translated(centreX, centreY));
        }
    }
 
#else
 
    // The rotary slider style used in Krotos Studio
    void Krotos_LookAndFeel::drawRotarySlider(Graphics& g, int /*x*/, int /*y*/, int width, int /*height*/,
                                              float sliderPos, float /*rotaryStartAngle*/, float /*rotaryEndAngle*/,
                                              juce::Slider& slider)
    {
        slider.setPopupDisplayEnabled(false, false, nullptr);
 
        float globalAlpha = slider.isEnabled() ? layout.enabledAlphaEnabled : layout.enabledAlphaDisabled;
        float mouseOverAlpha =
                slider.isMouseOverOrDragging() ? layout.mouseOverAlphaOver : layout.mouseOverAlphaDefault;
 
        Colour trackColourInner = layout.trackColourInner.withAlpha(globalAlpha);
        Colour thumbColour = layout.thumbColour.withAlpha(globalAlpha);
        Colour trackColourOuter = layout.trackColourOuter.withAlpha(globalAlpha).withAlpha(mouseOverAlpha);
        Colour textColour = layout.textColour.withAlpha(globalAlpha);
 
        float positionRadians = jmap<float>(sliderPos, layout.sliderValueMin, layout.sliderValueMax,
                                            layout.startRadians, layout.endRadians);
 
        // Horribleness to make it resizable maintaining the proportions (almost) of the
        // original 86x96 design
        float scalar = (float)width / layout.enclosingRectangle.getWidth();
        auto scaledSquare = layout.enclosingSquare * scalar;
        auto scaledSquareTrack = layout.enclosingSquareTrack * scalar;
        auto scaledThumbEnd = layout.thumbEnd * scalar;
        auto scaledThumbStart = layout.thumbStart * scalar;
        auto scaledArcCenter = scaledSquare.getCentre();
        auto scaledTextRectangle = layout.textRectangle * scalar;
        scaledTextRectangle.setHeight(layout.textRectangle.getHeight());
        scaledTextRectangle.setX(layout.textRectangle.getX());
 
        // Slider outline arc
        juce::Path outlineArc;
        outlineArc.addPieSegment(scaledSquare, layout.startRadians, layout.endRadians,
                                 layout.outlineArcInnerProportion);
        outlineArc.closeSubPath();
        g.setColour(trackColourOuter);
        g.fillPath(outlineArc);
 
        // Slider track
        juce::Path trackArc;
        trackArc.addPieSegment(scaledSquareTrack, layout.startRadians, positionRadians, layout.trackArcInnerProportion);
        trackArc.closeSubPath();
        g.setColour(trackColourInner);
        g.fillPath(trackArc);
 
        if (slider.isMouseOverOrDragging())
        {
            // Slider thumb
            juce::Path thumb;
            auto thumbEnd = scaledThumbEnd.rotatedAboutOrigin(positionRadians) + scaledArcCenter;
            auto thumbStart = scaledThumbStart.rotatedAboutOrigin(positionRadians) + scaledArcCenter;
            thumb.addLineSegment(juce::Line<float>(thumbStart, thumbEnd), layout.thumbWidth);
            g.setColour(thumbColour);
            g.fillPath(thumb);
 
            // Slider value text
            String value{slider.getValue(), layout.numDecimalPlaces};
            Font font(scaledTextRectangle.getHeight(), Font::FontStyleFlags::plain);
            font.setExtraKerningFactor(layout.KerningFactor);
            g.setFont(font);
            g.setColour(textColour);
            g.drawFittedText(value, scaledTextRectangle.toNearestInt(), Justification::centred, layout.maxTextLines);
        }
    }
 
#endif
 
    Krotos_LookAndFeel::LinkButtonLAF::LinkButtonLAF()
    {
        // Set the text color to #81AFFF for both off and on states
        setColour(TextButton::ColourIds::textColourOffId, Colour(0xff81AFFF));
        setColour(TextButton::ColourIds::textColourOnId, Colour(0xff81AFFF));
    }
 
    void Krotos_LookAndFeel::LinkButtonLAF::drawButtonText(Graphics& g, TextButton& button,
                                                           bool shouldDrawButtonAsHighlighted,
                                                           bool shouldDrawButtonAsDown)
    {
        Font::FontStyleFlags flag = Font::FontStyleFlags::plain;
 
        if (shouldDrawButtonAsDown)
            flag = Font::FontStyleFlags::bold;
 
        Font font(getTextButtonFont(button, button.getHeight()));
        font.setStyleFlags(flag);
        g.setFont(font);
 
        // Set the text color explicitly to #81AFFF
        g.setColour(Colour(0xff81AFFF));
 
        const int yIndent = jmin(4, button.proportionOfHeight(0.3f));
        const int cornerSize = jmin(button.getHeight(), button.getWidth()) / 2;
 
        const int fontHeight = roundToInt(font.getHeight() * 0.6f);
        const int leftIndent = jmin(fontHeight, 2 + cornerSize / (button.isConnectedOnLeft() ? 4 : 2));
        const int rightIndent = jmin(fontHeight, 2 + cornerSize / (button.isConnectedOnRight() ? 4 : 2));
        const int textWidth = button.getWidth() - leftIndent - rightIndent;
 
        if (textWidth > 0)
            g.drawFittedText(button.getButtonText(), leftIndent, yIndent, textWidth, button.getHeight() - yIndent * 2,
                             Justification::centred, 2);
    }
} // namespace krotos