window.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_WINDOW_H
#define EGT_WINDOW_H
 
#include <egt/detail/meta.h>
#include <egt/frame.h>
#include <egt/image.h>
#include <egt/label.h>
#include <egt/screen.h>
#include <egt/widgetflags.h>
#include <memory>
 
namespace egt
{
inline namespace v1
{
 
namespace detail
{
class WindowImpl;
class PlaneWindow;
}
 
class EGT_API Window : public Frame
{
public:
 
    static const PixelFormat DEFAULT_FORMAT;
 
    explicit Window(PixelFormat format_hint = DEFAULT_FORMAT,
                    WindowHint hint = WindowHint::automatic)
        : Window({}, format_hint, hint)
    {}
 
    explicit Window(const Rect& rect,
                    PixelFormat format_hint = DEFAULT_FORMAT,
                    WindowHint hint = WindowHint::automatic);
 
    Window(Frame& parent,
           const Rect& rect,
           PixelFormat format_hint = DEFAULT_FORMAT,
           WindowHint hint = WindowHint::automatic);
    explicit Window(Serializer::Properties& props)
        : Window(props, false)
    {
    }
 
protected:
 
    explicit Window(Serializer::Properties& props, bool is_derived);
 
public:
 
    Window(const Window&) = delete;
    Window& operator=(const Window&) = delete;
    Window(Window&&) noexcept;
    Window& operator=(Window&&) noexcept;
 
    using Frame::damage;
 
    void damage(const Rect& rect) override;
 
    EGT_NODISCARD Screen* screen() const override;
 
    EGT_NODISCARD bool has_screen() const override;
 
    void move(const Point& point) override;
 
    void show() override;
 
    void hide() override;
 
    void resize(const Size& size) override;
 
    using Frame::scale;
 
    void scale(float hscale, float vscale) override;
 
    EGT_NODISCARD float hscale() const
    {
        return m_hscale;
    }
 
    EGT_NODISCARD float vscale() const
    {
        return m_vscale;
    }
 
    void paint(Painter& painter) override;
 
    /*
     * Damage rectangles propagate up the widget tree and stop at a top level
     * widget, which can only be a window. As it propagates up, the damage
     * rectangle origin changes value to respect the current frame.  When
     * drawing those rectangles, as they propagate down the widget hierarchy
     * the opposite change happens to the rectangle origin.
     */
    void begin_draw() override;
    using Frame::begin_draw;
 
    EGT_NODISCARD PixelFormat format() const
    {
        auto frame = find_screen();
        if (frame)
            return frame->screen()->format();
 
        return PixelFormat::invalid;
    }
 
    void format_hint(PixelFormat format_hint)
    {
        m_format_hint = format_hint;
    }
 
    EGT_NODISCARD PixelFormat format_hint() const { return m_format_hint; }
 
    void window_hint(WindowHint hint)
    {
        m_hint = hint;
    }
 
    EGT_NODISCARD WindowHint window_hint() const { return m_hint; }
 
    void serialize(Serializer& serializer) const override;
 
    ~Window() noexcept override;
 
protected:
 
    virtual void do_draw();
 
    virtual void allocate_screen();
 
    void create_impl(const Rect& rect,
                     PixelFormat format_hint,
                     WindowHint hint);
 
    virtual void default_damage(const Rect& rect)
    {
        Frame::damage(rect);
    }
 
    virtual void default_resize(const Size& size)
    {
        Frame::resize(size);
    }
 
    virtual void default_scale(float scalex, float scaley)
    {
        Frame::scale(scalex, scaley);
    }
 
    virtual void default_move(const Point& point)
    {
        Frame::move(point);
    }
 
    virtual void default_begin_draw()
    {
        if (m_parent)
        {
            begin_draw(m_parent);
            return;
        }
 
        do_draw();
    }
 
    virtual void default_show()
    {
        Frame::show();
    }
 
    virtual void default_hide()
    {
        Frame::hide();
    }
 
    virtual void default_paint(Painter& painter)
    {
        Frame::paint(painter);
    }
 
    std::unique_ptr<detail::WindowImpl> m_impl;
 
    void main_window();
 
    PixelFormat m_format_hint;
 
    WindowHint m_hint;
 
    float m_hscale{1.0};
 
    float m_vscale{1.0};
 
    friend class detail::WindowImpl;
    friend class detail::PlaneWindow;
};
 
// NOLINTNEXTLINE(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
class EGT_API TopWindow : public Window
{
public:
 
    using Window::Window;
 
    TopWindow& operator=(const TopWindow&) = delete;
    TopWindow& operator=(TopWindow&&) = default;
 
    void show_cursor(const Image& image = Image("res:internal_cursor"));
 
    void hide_cursor();
 
    ~TopWindow() noexcept override;
 
protected:
 
    void handle_mouse(Event& event);
 
    std::unique_ptr<Window> m_cursor;
 
private:
 
    Object::RegisterHandle m_handle{0};
};
 
}
}
 
#endif