overlay.h

#pragma once
 
#include <cgv/defines/deprecated.h>
#include <cgv/gui/event_handler.h>
#include <cgv/gui/provider.h>
#include <cgv/render/context.h>
#include <cgv/render/drawable.h>
#include <cgv/utils/pointer_test.h>
#include <cgv_g2d/trect.h>
#include <cgv_g2d/utils.h>
 
#include <cgv/gui/key_event.h>
#include <cgv/gui/mouse_event.h>
 
#include "lib_begin.h"
 
namespace cgv {
namespace app {
 
class CGV_API overlay :
    public cgv::base::node,
    public cgv::render::drawable,
    public cgv::gui::provider,
    public cgv::gui::event_handler
{
public:
    enum AlignmentOption {
        AO_FREE,        // alignment solely controlled by margin
        AO_START,       // left for horizontal, bottom for vertical direction
        AO_CENTER,      // center of the viewport for both directions
        AO_END,         // right for horizontal, top for vertical direction
        AO_PERCENTUAL,  // alignment based on offset from lower left corner based on percentual size of viewport
    };
 
    enum StretchOption {
        SO_NONE,        // size is unchanged
        SO_HORIZONTAL,  // width is stretched to cover viewport
        SO_VERTICAL,    // height is stretched to cover viewport
        SO_BOTH,        // width and height are stretched to cover viewport
        SO_PERCENTUAL,  // width and height are scaled according to percentual size of viewport
    };
 
private:
    ivec2 last_viewport_size_ = ivec2(-1);
    ivec2 last_size_ = ivec2(-1);
    ivec2 last_local_mouse_pos_ = ivec2(-1);
    bool captured_mouse_ = false;
    cgv::g2d::irect container_;
    bool blocks_events_ = false;
 
    AlignmentOption horizontal_alignment_ = AlignmentOption::AO_START;
    AlignmentOption vertical_alignment_ = AlignmentOption::AO_START;
    StretchOption stretch_ = SO_NONE;
    ivec2 margin_ = ivec2(0);
    vec2 percentual_offset_ = vec2(0.0f);
    vec2 percentual_size_ = vec2(1.0f);
 
    template<typename T>
    data::ref_ptr<cgv::gui::control<T>> add_layout_member_control(const std::string& label, T& value, const std::string& gui_type = "", const std::string& options = "", const std::string& align = "\n") {
        data::ref_ptr<cgv::gui::control<T>> cp = add_control(label, value, gui_type, options, align);
        if(cp)
            connect_copy(cp->value_change, cgv::signal::rebind(this, &overlay::on_layout_change));
        return cp;
    }
 
protected:
    virtual void on_visibility_change();
 
    virtual void on_layout_change();
 
    void update_layout();
 
    virtual void create_gui_impl() {};
 
public:
    struct gui_options_t {
        std::string heading = "";
        bool create_default_tree_node = true;
        bool show_heading = false;
        bool show_layout_options = true;
        bool allow_alignment = true;
        bool allow_stretch = true;
        bool allow_margin = true;
    };
    gui_options_t gui_options;
 
    virtual bool self_reflect(cgv::reflect::reflection_handler& _rh) { return false; }
 
    virtual void stream_help(std::ostream& os) {};
 
    virtual bool handle(cgv::gui::event& e);
 
    virtual bool handle_key_event(cgv::gui::key_event& e) { return false; };
 
    virtual bool handle_mouse_event(cgv::gui::mouse_event& e, cgv::ivec2 local_mouse_pos) { return false; };
 
    virtual void handle_member_change(const cgv::utils::pointer_test& m) {}
 
    virtual void on_set(void* member_ptr);
 
    bool blocks_events() const { return blocks_events_; }
 
    void blocks_events(bool flag) { blocks_events_ = flag; }
 
    ivec2 get_viewport_size() const { return last_viewport_size_; }
 
    virtual ivec2 get_local_mouse_pos(ivec2 mouse_pos) const;
 
    cgv::g2d::irect get_rectangle() const { return container_; }
 
    cgv::g2d::irect get_local_rectangle() const { return cgv::g2d::irect(ivec2(0), container_.size); }
 
    AlignmentOption get_horizontal_alignment() const { return horizontal_alignment_; }
 
    AlignmentOption get_vertical_alignment() const { return vertical_alignment_; }
 
    vec2 get_percentual_offset() const { return percentual_offset_; }
 
    void set_alignment(AlignmentOption horizontal, AlignmentOption vertical, vec2 percentual_offset = vec2(-1.0f));
 
    StretchOption get_stretch() const { return stretch_; }
 
    vec2 get_percentual_size() const { return percentual_size_; }
 
    void set_stretch(StretchOption stretch, vec2 percentual_size = vec2(-1.0f));
 
    ivec2 get_margin() const { return margin_; }
 
    void set_margin(const ivec2& margin);
 
    void set_size(const ivec2& size);
 
    void set_visibility(bool visible);
 
    void toggle_visibility();
 
    bool ensure_viewport(cgv::render::context& ctx);
 
    bool ensure_layout(cgv::render::context& ctx);
 
    virtual bool is_hit(const ivec2& mouse_pos) const;
 
    bool begin_overlay_gui();
    void end_overlay_gui();
 
    void create_layout_gui();
 
    void create_gui();
};
 
typedef cgv::data::ref_ptr<overlay> overlay_ptr;
 
}
}
 
#include <cgv/config/lib_end.h>