window.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
#ifndef FENNEC_PLATFORM_INTERFACE_WINDOW_H
#define FENNEC_PLATFORM_INTERFACE_WINDOW_H
 
#include <fennec/platform/interface/fwd.h>
 
#include <fennec/math/ext/rect.h>
 
#include <fennec/string/string.h>
 
#include <fennec/containers/bitfield.h>
#include <fennec/containers/optional.h>
#include <fennec/memory/pointers.h>
 
namespace fennec
{
 
class window {
// Structures & Typedefs ===============================================================================================
public:
    static constexpr size_t nullid = -1;
 
    enum mode_ : uint8_t {
        mode_windowed = 0,
        mode_minimized,
        mode_maximized,
        mode_fullscreen,
        mode_exclusive_fullscreen,
    };
 
    enum vsync_ : uint8_t {
        vsync_disabled = 0,
        vsync_enabled,
        vsync_adaptive
    };
 
    enum flag_ : uint8_t {
        flag_always_on_top = 0, // Window always appears on top level
        flag_borderless,        // Window has no border decorations
        flag_modal,             // Window always appears above parent and blocks input going to parent
        flag_pass_mouse,        // Mouse interaction passes to next underlying window in the application
        flag_popup,             // Window does not show in taskbar and closes when loses focus
        flag_resizable,         // Window can be resized through functions defined by Desktop Environment
        flag_transparent,       // Window has an alpha value
        flag_no_focus,          // Window can be focused
 
        flag_count
    };
 
    enum state_ : uint8_t {
        state_running = 0, // Window is running
        state_child,       // Window is a child
        state_suspended,   // Window is suspended
        state_visible,     // Window is visible
 
        state_count
    };
 
    using flags_t = bitfield<flag_count>;
    using state_t = bitfield<state_count>;
 
    struct accessibility {
        string name, description;
    };
 
    struct config {
        string  title;
        flags_t flags;
        uint8_t mode;
 
        size_t parent;
        irect  rect;
 
        double_t fractional_scaling;
 
        accessibility accessibility;
    };
 
    struct state {
        uint8_t  mode;
        irect    rect;
        state_t  flags;
        int_t    buffer_scale;
        double_t fractional_scaling;
    };
 
    window(display_server* server, const config& conf, window* parent);
 
    virtual ~window();
 
    const config& get_config() const { return cfg; }
 
    window* get_parent() const { return parent; }
    window* get_root()   const { return root;   }
 
    const ivec2& get_size()     const { return state.rect.size;     }
    const ivec2& get_position() const { return state.rect.position; }
 
    int get_width()    const { return state.rect.size.x;   }
    int get_height()   const { return state.rect.size.y;   }
    int get_pos_x()    const { return state.rect.position.x;   }
    int get_pos_y()    const { return state.rect.position.y;   }
 
    bool is_visible()   const { return state.flags.test(state_visible);   }
    bool is_child()     const { return state.flags.test(state_child); }
    bool is_running()   const { return state.flags.test(state_running);   }
    bool is_suspended() const { return state.flags.test(state_suspended); }
 
    bool get_flag(uint8_t flag) const { return cfg.flags.test(flag); }
 
    bool is_always_on_top() const { return get_flag(flag_always_on_top); }
    bool is_borderless()    const { return get_flag(flag_borderless); }
    bool is_modal()         const { return get_flag(flag_modal); }
    bool is_passing_mouse() const { return get_flag(flag_pass_mouse); }
    bool is_popup()         const { return get_flag(flag_popup); }
    bool is_resizable()     const { return get_flag(flag_resizable); }
    bool is_transparent()   const { return get_flag(flag_transparent); }
    bool is_no_focus()      const { return get_flag(flag_no_focus); }
 
 
    virtual bool set_flag(uint8_t flag, bool val) = 0;
 
    bool set_always_on_top(bool val) { return set_flag(flag_always_on_top, val); }
    bool set_borderless(bool val)    { return set_flag(flag_borderless, val);    }
    bool set_modal(bool val)         { return set_flag(flag_modal, val);         }
    bool set_passing_mouse(bool val) { return set_flag(flag_pass_mouse, val);    }
    bool set_popup(bool val)         { return set_flag(flag_popup, val);         }
    bool set_resizable(bool val)     { return set_flag(flag_resizable, val);     }
    bool set_transparent(bool val)   { return set_flag(flag_transparent, val);   }
    bool set_no_focus(bool val)      { return set_flag(flag_no_focus, val);      }
 
    virtual void initialize() = 0;
    virtual void shutdown() = 0;
 
    virtual void begin_frame();
    virtual void end_frame();
 
    virtual void* get_native_handle() = 0;
 
protected:
    display_server* const  server;
    window*         const  parent;
    config                 cfg;
    state                  state;
    window*                root;
    unique_ptr<gfxsurface> gfx_surface;
};
 
template<typename DisplayT>
class window_base : public window {
public:
    window_base(display_server* display, const config& conf, window* parent)
        : window(display, conf, parent) {
    }
 
    using display_t = DisplayT;
};
 
}
 
#endif // FENNEC_PLATFORM_INTERFACE_WINDOW_H