open_gl_image_component.h

Go to the documentation of this file.

#pragma once
 
#include "open_gl_component.h"
#include "fonts.h"
#include "open_gl_image.h"
 
class SynthSection;
 
class OpenGlImageComponent : public OpenGlComponent {
public:
    OpenGlImageComponent(String name = "");
 
    virtual ~OpenGlImageComponent() = default;
 
    virtual void paintBackground(Graphics& g) override {
        redrawImage(false);
    }
 
    virtual void paintToImage(Graphics& g) {
        Component* component = component_ ? component_ : this;
        if (paint_entire_component_)
            component->paintEntireComponent(g, false);
        else
            component->paint(g);
    }
 
    virtual void init(OpenGlWrapper& open_gl) override;
 
    virtual void render(OpenGlWrapper& open_gl, bool animate) override;
 
    virtual void destroy(OpenGlWrapper& open_gl) override;
 
    virtual void redrawImage(bool force);
 
    void setComponent(Component* component) { component_ = component; }
 
    void setScissor(bool scissor) { image_.setScissor(scissor); }
 
    void setUseAlpha(bool use_alpha) { image_.setUseAlpha(use_alpha); }
 
    void setColor(Colour color) { image_.setColor(color); }
 
    OpenGlImage& image() { return image_; }
 
    void setActive(bool active) { active_ = active; }
 
    void setStatic(bool static_image) { static_image_ = static_image; }
 
    void paintEntireComponent(bool paint_entire_component) { paint_entire_component_ = paint_entire_component; }
 
    bool isActive() const { return active_; }
 
protected:
    Component* component_;            
    bool active_;                     
    bool static_image_;               
    bool paint_entire_component_;     
    std::unique_ptr<Image> draw_image_;  
    OpenGlImage image_;               
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(OpenGlImageComponent)
};
 
 
template <class ComponentType>
class OpenGlAutoImageComponent : public ComponentType {
public:
    using ComponentType::ComponentType;
 
    virtual void mouseDown(const MouseEvent& e) override {
        ComponentType::mouseDown(e);
        redoImage();
    }
 
    virtual void mouseUp(const MouseEvent& e) override {
        ComponentType::mouseUp(e);
        redoImage();
    }
 
    virtual void mouseDoubleClick(const MouseEvent& e) override {
        ComponentType::mouseDoubleClick(e);
        redoImage();
    }
 
    virtual void mouseEnter(const MouseEvent& e) override {
        ComponentType::mouseEnter(e);
        redoImage();
    }
 
    virtual void mouseExit(const MouseEvent& e) override {
        ComponentType::mouseExit(e);
        redoImage();
    }
 
    virtual void mouseWheelMove(const MouseEvent& e, const MouseWheelDetails& wheel) override {
        ComponentType::mouseWheelMove(e, wheel);
        redoImage();
    }
 
    OpenGlImageComponent* getImageComponent() { return &image_component_; }
 
    virtual void redoImage() { image_component_.redrawImage(true); }
 
protected:
    OpenGlImageComponent image_component_; 
};
 
 
class OpenGlTextEditor : public OpenGlAutoImageComponent<TextEditor>, public TextEditor::Listener {
public:
    OpenGlTextEditor(String name) : OpenGlAutoImageComponent(name) {
        monospace_ = false;
        image_component_.setComponent(this);
        addListener(this);
    }
 
    OpenGlTextEditor(String name, wchar_t password_char) : OpenGlAutoImageComponent(name, password_char) {
        monospace_ = false;
        image_component_.setComponent(this);
        addListener(this);
    }
 
    bool keyPressed(const KeyPress& key) override {
        bool result = TextEditor::keyPressed(key);
        redoImage();
        return result;
    }
 
    void textEditorTextChanged(TextEditor&) override { redoImage(); }
    void textEditorFocusLost(TextEditor&) override { redoImage(); }
 
    virtual void mouseDrag(const MouseEvent& e) override {
        TextEditor::mouseDrag(e);
        redoImage();
    }
 
    void applyFont() {
        Font font;
        if (monospace_)
            font = Fonts::instance()->monospace().withPointHeight(getHeight() / 2.0f);
        else
            font = Fonts::instance()->proportional_light().withPointHeight(getHeight() / 2.0f);
 
        applyFontToAllText(font);
        redoImage();
    }
 
    void visibilityChanged() override {
        TextEditor::visibilityChanged();
 
        if (isVisible() && !isMultiLine())
            applyFont();
    }
 
    void resized() override {
        TextEditor::resized();
        if (isMultiLine()) {
            float indent = image_component_.findValue(Skin::kLabelBackgroundRounding);
            setIndents(indent, indent);
            return;
        }
 
        if (monospace_)
            setIndents(getHeight() * 0.2, getHeight() * 0.17);
        else
            setIndents(getHeight() * 0.2, getHeight() * 0.15);
        if (isVisible())
            applyFont();
    }
 
    void setMonospace() {
        monospace_ = true;
    }
 
private:
    bool monospace_; 
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(OpenGlTextEditor)
};
 
 
class PlainTextComponent : public OpenGlImageComponent {
public:
    enum FontType {
        kTitle,
        kLight,
        kRegular,
        kMono,
        kNumFontTypes
    };
 
    PlainTextComponent(String name, String text) : OpenGlImageComponent(name), text_(std::move(text)),
                                                   text_size_(1.0f), font_type_(kRegular),
                                                   justification_(Justification::centred),
                                                   buffer_(0) {
        setInterceptsMouseClicks(false, false);
    }
 
    void resized() override {
        OpenGlImageComponent::resized();
        redrawImage(true);
    }
 
    void setText(String text) {
        if (text_ == text)
            return;
 
        text_ = text;
        redrawImage(true);
    }
 
    String getText() const { return text_; }
 
    void paintToImage(Graphics& g) override {
        g.setColour(Colours::white);
 
        if (font_type_ == kTitle)
            g.setFont(Fonts::instance()->proportional_title().withPointHeight(text_size_));
        else if (font_type_ == kLight)
            g.setFont(Fonts::instance()->proportional_light().withPointHeight(text_size_));
        else if (font_type_ == kRegular)
            g.setFont(Fonts::instance()->proportional_regular().withPointHeight(text_size_));
        else
            g.setFont(Fonts::instance()->monospace().withPointHeight(text_size_));
 
        Component* component = component_ ? component_ : this;
 
        g.drawFittedText(text_, buffer_, 0, component->getWidth() - 2 * buffer_,
                         component->getHeight(), justification_, false);
    }
 
    void setTextSize(float size) {
        text_size_ = size;
        redrawImage(true);
    }
 
    void setFontType(FontType font_type) {
        font_type_ = font_type;
    }
 
    void setJustification(Justification justification) {
        justification_ = justification;
    }
 
    void setBuffer(int buffer) { buffer_ = buffer; }
 
private:
    String text_;                
    float text_size_;            
    FontType font_type_;         
    Justification justification_;
    int buffer_;                 
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PlainTextComponent)
};
 
 
class PlainShapeComponent : public OpenGlImageComponent {
public:
    PlainShapeComponent(String name) : OpenGlImageComponent(name), justification_(Justification::centred) {
        setInterceptsMouseClicks(false, false);
    }
 
    void paintToImage(Graphics& g) override {
        Component* component = component_ ? component_ : this;
        Rectangle<float> bounds = component->getLocalBounds().toFloat();
        Path shape = shape_;
        shape.applyTransform(shape.getTransformToScaleToFit(bounds, true, justification_));
 
        g.setColour(Colours::white);
        g.fillPath(shape);
    }
 
    void setShape(Path shape) {
        shape_ = shape;
        redrawImage(true);
    }
 
    void setJustification(Justification justification) { justification_ = justification; }
 
private:
    Path shape_;                  
    Justification justification_; 
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(PlainShapeComponent)
};