ImguiApplicationMonad.hh

#ifndef VTESTBED_GUI_IMGUIAPPLICATIONMONAD_HH
#define VTESTBED_GUI_IMGUIAPPLICATIONMONAD_HH

#include <type_traits>

#include <Magnum/GL/DefaultFramebuffer.h>
#include <vtestbed/gui/MagnumImgui/MagnumImGui.h>
#include <vtestbed/gui/imgui.hh>
#include <vtestbed/gui/types.hh>

namespace vtb {

    namespace gui {

        template <class Base>
        class ImguiApplicationMonad: public Base {

            static_assert(
                std::is_base_of<::vtb::gui::Application,Base>::value,
                "bad base class"
            );

        private:
            using typename Base::Arguments;
            using typename Base::Configuration;

        private:
            MagnumImGui _imgui;

        public:

            ImguiApplicationMonad(const Arguments& args, const Configuration& conf):
            Base{args, conf} { this->initImGui(); }

            template <class ... Args>
            inline explicit
            ImguiApplicationMonad(Args&& ... args):
            Base(std::forward<Args>(args)...) { this->initImGui(); }

        protected:

            inline void initImGui() { this->Base::initImGui(this->imgui()); }

            void
            drawEvent() override {
                using namespace Magnum;
                GL::defaultFramebuffer.clear(
                    GL::FramebufferClear::Color|GL::FramebufferClear::Depth
                );
                this->imgui().newFrame(
                    this->windowSize(),
                    GL::defaultFramebuffer.viewport().size()
                );
                this->Base::drawEvent();
                this->imgui().drawFrame();
                this->swapBuffers();
                this->redraw();
            }

            void
            keyPressEvent(KeyEvent& event) override {
                if (this->imgui().keyPressEvent(event)) {
                    return;
                }
                this->Base::keyPressEvent(event);
            }

            void
            keyReleaseEvent(KeyEvent& event) override {
                if (this->imgui().keyReleaseEvent(event)) {
                    return;
                }
                this->Base::keyReleaseEvent(event);
            }

            void
            mousePressEvent(MouseEvent& event) override {
                if (this->imgui().mousePressEvent(event)) {
                    return;
                }
                this->Base::mousePressEvent(event);
            }

            void
            mouseReleaseEvent(MouseEvent& event) override {
                if (this->imgui().mouseReleaseEvent(event)) {
                    return;
                }
                this->Base::mouseReleaseEvent(event);
            }

            void
            mouseMoveEvent(MouseMoveEvent& event) override {
                if (this->imgui().mouseMoveEvent(event)) {
                    return;
                }
                this->Base::mouseMoveEvent(event);
            }

            void
            mouseScrollEvent(MouseScrollEvent& event) override {
                if (this->imgui().mouseScrollEvent(event)) {
                    return;
                }
                this->Base::mouseScrollEvent(event);
            }

            void
            textInputEvent(TextInputEvent& event) override {
                if (this->imgui().textInputEvent(event)) {
                    return;
                }
                this->Base::textInputEvent(event);
            }

            inline MagnumImGui& imgui() { return this->_imgui; }
            inline const MagnumImGui& imgui() const { return this->_imgui; }

        };

    }

}

#endif // vim:filetype=cpp