window.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code 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.
 *
 * Antkeeper source code 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 Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_APP_WINDOW_HPP
#define ANTKEEPER_APP_WINDOW_HPP
 
#include <engine/math/vector.hpp>
#include <engine/event/publisher.hpp>
#include <engine/app/window-events.hpp>
#include <string>
 
namespace gl {
 
    class pipeline;
 
}
 
namespace app {
 
class window_manager;
 
class window
{
public:
    virtual void set_title(const std::string& title) = 0;
    
    virtual void set_position(const math::ivec2& position) = 0;
    
    virtual void set_size(const math::ivec2& size) = 0;
    
    virtual void set_minimum_size(const math::ivec2& size) = 0;
    
    virtual void set_maximum_size(const math::ivec2& size) = 0;
    
    virtual void set_maximized(bool maximized) = 0;
    
    virtual void set_fullscreen(bool fullscreen) = 0;
    
    virtual void set_v_sync(bool v_sync) = 0;
    
    virtual void make_current() = 0;
    
    virtual void swap_buffers() = 0;
    
    [[nodiscard]] inline const std::string& get_title() const noexcept
    {
        return m_title;
    }
    
    [[nodiscard]] inline const math::ivec2& get_windowed_position() const noexcept
    {
        return m_windowed_position;
    }
    
    [[nodiscard]] inline const math::ivec2& get_position() const noexcept
    {
        return m_position;
    }
    
    [[nodiscard]] inline const math::ivec2& get_windowed_size() const noexcept
    {
        return m_windowed_size;
    }
    
    [[nodiscard]] inline const math::ivec2& get_size() const noexcept
    {
        return m_size;
    }
    
    [[nodiscard]] inline const math::ivec2& get_minimum_size() const noexcept
    {
        return m_minimum_size;
    }
    
    [[nodiscard]] inline const math::ivec2& get_maximum_size() const noexcept
    {
        return m_minimum_size;
    }
    
    [[nodiscard]] inline const math::ivec2& get_viewport_size() const noexcept
    {
        return m_viewport_size;
    }
    
    [[nodiscard]] inline bool is_maximized() const noexcept
    {
        return m_maximized;
    }
    
    [[nodiscard]] inline bool is_fullscreen() const noexcept
    {
        return m_fullscreen;
    }
    
    [[nodiscard]] inline bool get_v_sync() const noexcept
    {
        return m_v_sync;
    }
    
    [[nodiscard]] virtual const gl::pipeline& get_graphics_pipeline() const noexcept = 0;
    [[nodiscard]] virtual gl::pipeline& get_graphics_pipeline() noexcept = 0;
    
    [[nodiscard]] inline event::channel<window_closed_event>& get_closed_channel() noexcept
    {
        return m_closed_publisher.channel();
    }
    
    [[nodiscard]] inline event::channel<window_focus_changed_event>& get_focus_changed_channel() noexcept
    {
        return m_focus_changed_publisher.channel();
    }
    
    [[nodiscard]] inline event::channel<window_maximized_event>& get_maximized_channel() noexcept
    {
        return m_maximized_publisher.channel();
    }
    
    [[nodiscard]] inline event::channel<window_minimized_event>& get_minimized_channel() noexcept
    {
        return m_minimized_publisher.channel();
    }
    
    [[nodiscard]] inline event::channel<window_moved_event>& get_moved_channel() noexcept
    {
        return m_moved_publisher.channel();
    }
    
    [[nodiscard]] inline event::channel<window_resized_event>& get_resized_channel() noexcept
    {
        return m_resized_publisher.channel();
    }
    
    [[nodiscard]] inline event::channel<window_restored_event>& get_restored_channel() noexcept
    {
        return m_restored_publisher.channel();
    }
    
protected:
    friend class window_manager;
    
    std::string m_title;
    math::ivec2 m_windowed_position{0, 0};
    math::ivec2 m_position{0, 0};
    math::ivec2 m_windowed_size{0, 0};
    math::ivec2 m_size{0, 0};
    math::ivec2 m_minimum_size{0, 0};
    math::ivec2 m_maximum_size{0, 0};
    math::ivec2 m_viewport_size{0, 0};
    bool m_maximized{false};
    bool m_fullscreen{false};
    bool m_v_sync{false};
    
    event::publisher<window_closed_event> m_closed_publisher;
    event::publisher<window_focus_changed_event> m_focus_changed_publisher;
    event::publisher<window_maximized_event> m_maximized_publisher;
    event::publisher<window_minimized_event> m_minimized_publisher;
    event::publisher<window_moved_event> m_moved_publisher;
    event::publisher<window_resized_event> m_resized_publisher;
    event::publisher<window_restored_event> m_restored_publisher;
};
 
} // namespace app
 
#endif // ANTKEEPER_APP_WINDOW_HPP