OSDWidget.hh

Go to the documentation of this file.

#ifndef OSDWIDGET_HH
#define OSDWIDGET_HH
 
#include "TclObject.hh"
 
#include "gl_vec.hh"
 
#include <array>
#include <memory>
#include <span>
#include <string_view>
#include <vector>
 
namespace openmsx {
 
class Display;
class OutputSurface;
class Interpreter;
 
class OSDWidget
{
        using SubWidgets = std::vector<std::unique_ptr<OSDWidget>>;
 
protected:
        static constexpr auto widgetProperties = [] {
                using namespace std::literals;
                return std::array{
                        "-type"sv, "-x"sv, "-y"sv, "-z"sv, "-relx"sv, "-rely"sv, "-scaled"sv,
                        "-clip"sv, "-mousecoord"sv, "-suppressErrors"sv,
                };
        }();
 
public:
        virtual ~OSDWidget() = default;
 
        [[nodiscard]] std::string_view getName() const { return name.getString(); }
        [[nodiscard]] virtual gl::vec2 getPos() const { return pos; }
        [[nodiscard]] gl::vec2 getRelPos() const { return relPos; }
        [[nodiscard]] float    getZ()      const { return z; }
 
        [[nodiscard]]       OSDWidget* getParent()       { return parent; }
        [[nodiscard]] const OSDWidget* getParent() const { return parent; }
        [[nodiscard]] const SubWidgets& getChildren() const { return subWidgets; }
        void addWidget(std::unique_ptr<OSDWidget> widget);
        void deleteWidget(OSDWidget& widget);
 
        [[nodiscard]] virtual std::span<const std::string_view> getProperties() const {
                return widgetProperties;
        }
        virtual void setProperty(Interpreter& interp,
                                 std::string_view name, const TclObject& value);
        virtual void getProperty(std::string_view name, TclObject& result) const;
        [[nodiscard]] virtual float getRecursiveFadeValue() const;
        [[nodiscard]] virtual bool isRecursiveFading() const = 0;
        [[nodiscard]] virtual std::string_view getType() const = 0;
 
        void invalidateRecursive();
        void paintRecursive(OutputSurface& output);
 
        [[nodiscard]] int getScaleFactor(const OutputSurface& output) const;
        [[nodiscard]] gl::vec2 transformPos(const OutputSurface& output,
                                            gl::vec2 pos, gl::vec2 relPos) const;
        struct BoundingBox { gl::vec2 pos; gl::vec2 size; };
        [[nodiscard]] BoundingBox getBoundingBox(const OutputSurface& output) const;
        [[nodiscard]] virtual gl::vec2 getSize(const OutputSurface& output) const = 0;
 
        // Is visible? Or may become visible (fading-in).
        [[nodiscard]] virtual bool isVisible() const = 0;
 
        [[nodiscard]] Display& getDisplay() const { return display; }
 
protected:
        OSDWidget(Display& display, TclObject name);
        void invalidateChildren() const;
        [[nodiscard]] bool needSuppressErrors() const;
 
        virtual void invalidateLocal() = 0;
        virtual void paint(OutputSurface& output) = 0;
 
private:
        [[nodiscard]] gl::vec2 getMouseCoord() const;
        [[nodiscard]] gl::vec2 transformReverse(const OutputSurface& output,
                                                gl::vec2 pos) const;
        void setParent(OSDWidget* parent_) { parent = parent_; }
        void resortUp  (const OSDWidget* elem);
        void resortDown(const OSDWidget* elem);
 
private:
        SubWidgets subWidgets;
 
        Display& display;
        OSDWidget* parent = nullptr;
 
        TclObject name;
        gl::vec2 pos;
        gl::vec2 relPos;
        float z = 0.0f;
        bool scaled = false;
        bool clip = false;
        bool suppressErrors = false;
};
 
} // namespace openmsx
 
#endif