line_editor.h

Go to the documentation of this file.

#pragma once
 
#include "JuceHeader.h"
 
#include "line_generator.h"
#include "open_gl_image_component.h"
#include "open_gl_multi_image.h"
#include "open_gl_multi_quad.h"
#include "open_gl_line_renderer.h"
#include "synth_lfo.h"
#include "synth_module.h"
 
class LineEditor : public OpenGlLineRenderer, public TextEditor::Listener {
public:
    static constexpr float kPositionWidth = 9.0f;
    static constexpr float kPowerWidth = 7.0f;
    static constexpr float kRingThickness = 0.45f;
    static constexpr float kGrabRadius = 12.0f;
    static constexpr float kDragRadius = 20.0f;
 
    static constexpr int kResolution = 64;
    static constexpr int kNumWrapPoints = 8;
    static constexpr int kDrawPoints = kResolution + LineGenerator::kMaxPoints;
    static constexpr int kTotalPoints = kDrawPoints + 2 * kNumWrapPoints;
 
    static constexpr int kMaxGridSizeX = 32;
    static constexpr int kMaxGridSizeY = 24;
 
    static constexpr float kPaddingY = 6.0f;
    static constexpr float kPaddingX = 0.0f;
 
    static constexpr float kPowerMouseMultiplier = 9.0f;
    static constexpr float kMinPointDistanceForPower = 3.0f;
 
    enum MenuOptions {
        kCancel,
        kCopy,
        kPaste,
        kSave,
        kEnterPhase,
        kEnterValue,
        kResetPower,
        kRemovePoint,
        kInit,
        kFlipHorizontal,
        kFlipVertical,
        kNumMenuOptions
    };
 
    class Listener {
    public:
        virtual ~Listener() { }
 
        virtual void setPhase(float phase) = 0;
 
        virtual void lineEditorScrolled(const MouseEvent& e, const MouseWheelDetails& wheel) = 0;
 
        virtual void togglePaintMode(bool enabled, bool temporary_switch) = 0;
 
        virtual void fileLoaded() = 0;
 
        virtual void importLfo() = 0;
 
        virtual void exportLfo() = 0;
 
        virtual void pointChanged(int index, Point<float> position, bool mouse_up) { }
 
        virtual void powersChanged(bool mouse_up) { }
 
        virtual void pointAdded(int index, Point<float> position) { }
 
        virtual void pointRemoved(int index) { }
 
        virtual void pointsAdded(int index, int num_points_added) { }
 
        virtual void pointsRemoved(int index, int num_points_removed) { }
    };
 
    LineEditor(LineGenerator* line_source);
 
    virtual ~LineEditor();
 
    void resetWavePath();
 
    void resized() override {
        OpenGlLineRenderer::resized();
        drag_circle_.setBounds(getLocalBounds());
        hover_circle_.setBounds(getLocalBounds());
        grid_lines_.setBounds(getLocalBounds());
        position_circle_.setBounds(getLocalBounds());
        point_circles_.setBounds(getLocalBounds());
        power_circles_.setBounds(getLocalBounds());
        resetPositions();
    }
 
    float padY(float y);
 
    float unpadY(float y);
 
    float padX(float x);
 
    float unpadX(float x);
 
    virtual void mouseDown(const MouseEvent& e) override;
    virtual void mouseDoubleClick(const MouseEvent& e) override;
    virtual void mouseMove(const MouseEvent& e) override;
    virtual void mouseDrag(const MouseEvent& e) override;
    virtual void mouseUp(const MouseEvent& e) override;
 
    virtual void respondToCallback(int point, int power, int option);
 
    bool hasMatchingSystemClipboard();
 
    void paintLine(const MouseEvent& e);
 
    void drawDown(const MouseEvent& e);
 
    void drawDrag(const MouseEvent& e);
 
    void drawUp(const MouseEvent& e);
 
    void mouseWheelMove(const MouseEvent& e, const MouseWheelDetails& wheel) override;
    void mouseExit(const MouseEvent& e) override;
    void clearActiveMouseActions();
 
    void renderGrid(OpenGlWrapper& open_gl, bool animate);
 
    void renderPoints(OpenGlWrapper& open_gl, bool animate);
 
    void init(OpenGlWrapper& open_gl) override;
    void render(OpenGlWrapper& open_gl, bool animate) override;
    void destroy(OpenGlWrapper& open_gl) override;
 
    void setSizeRatio(float ratio) { size_ratio_ = ratio; }
 
    float sizeRatio() const { return size_ratio_; }
 
    void setLoop(bool loop) { loop_ = loop; }
 
    void setSmooth(bool smooth) { model_->setSmooth(smooth); resetPositions(); }
 
    bool getSmooth() const { return model_->smooth(); }
 
    void setPaint(bool paint);
 
    void setPaintPattern(std::vector<std::pair<float, float>> pattern) { paint_pattern_ = pattern; }
 
    virtual void setGridSizeX(int size) { grid_size_x_ = size; setGridPositions(); }
 
    virtual void setGridSizeY(int size) { grid_size_y_ = size; setGridPositions(); }
 
    int getGridSizeX() { return grid_size_x_; }
 
    int getGridSizeY() { return grid_size_y_; }
 
    void setModel(LineGenerator* model) { model_ = model; resetPositions(); }
 
    LineGenerator* getModel() { return model_; }
 
    void showTextEntry();
 
    void hideTextEntry();
 
    void textEditorReturnKeyPressed(TextEditor& editor) override;
    void textEditorFocusLost(TextEditor& editor) override;
    void textEditorEscapeKeyPressed(TextEditor& editor) override;
 
    void setSliderPositionFromText();
 
    void setAllowFileLoading(bool allow) { allow_file_loading_ = allow; }
 
    void addListener(Listener* listener) { listeners_.push_back(listener); }
 
    void setActive(bool active) { active_ = active; }
 
    force_inline void resetPositions() { reset_positions_ = true; }
 
    OpenGlComponent* getTextEditorComponent() {
        if (value_entry_)
            return value_entry_->getImageComponent();
        return nullptr;
    }
 
protected:
    void drawPosition(OpenGlWrapper& open_gl, Colour color, float fraction_x);
 
    void setEditingCircleBounds();
 
    void setGridPositions();
 
    void setPointPositions();
 
    void setGlPositions();
 
    int getActivePoint() { return active_point_; }
 
    int getActivePower() { return active_power_; }
 
    int getActiveGridSection() { return active_grid_section_; }
 
    bool isPainting() { return paint_ != temporary_paint_toggle_; }
 
    bool isPaintEnabled() { return paint_; }
 
    vital::poly_float adjustBoostPhase(vital::poly_float phase);
 
    virtual void enableTemporaryPaintToggle(bool toggle);
 
    bool active_;
    std::vector<Listener*> listeners_;
 
private:
    float adjustBoostPhase(float phase);
 
    int getHoverPoint(Point<float> position);
    int getHoverPower(Point<float> position);
    float getSnapRadiusX();
    float getSnapRadiusY();
    float getSnappedX(float x);
    float getSnappedY(float y);
 
    void addPointAt(Point<float> position);
    void movePoint(int index, Point<float> position, bool snap);
    void movePower(int index, Point<float> position, bool all, bool alternate);
    void removePoint(int index);
    float getMinX(int index);
    float getMaxX(int index);
 
    Point<float> valuesToOpenGlPosition(float x, float y);
    Point<float> getPowerPosition(int index);
    bool powerActive(int index);
 
    LineGenerator* model_;
    int active_point_;
    int active_power_;
    int active_grid_section_;
    bool dragging_;
    bool reset_positions_;
    bool allow_file_loading_;
    Point<float> last_mouse_position_;
    int last_model_render_;
    bool loop_;
    int grid_size_x_;
    int grid_size_y_;
    bool paint_;
    bool temporary_paint_toggle_;
    std::vector<std::pair<float, float>> paint_pattern_;
    vital::poly_float last_phase_;
    vital::poly_float last_voice_;
    vital::poly_float last_last_voice_;
    float size_ratio_;
 
    OpenGlQuad drag_circle_;
    OpenGlQuad hover_circle_;
    OpenGlMultiQuad grid_lines_;
    OpenGlQuad position_circle_;
    OpenGlMultiQuad point_circles_;
    OpenGlMultiQuad power_circles_;
    std::unique_ptr<OpenGlTextEditor> value_entry_;
    bool entering_phase_;
    int entering_index_;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(LineEditor)
};