documentation/3.0.0/WindowBase_8hpp_source.html

//

// SFML - Simple and Fast Multimedia Library

// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)

//

// This software is provided 'as-is', without any express or implied warranty.

// In no event will the authors be held liable for any damages arising from the use of this software.

//

// Permission is granted to anyone to use this software for any purpose,

// including commercial applications, and to alter it and redistribute it freely,

// subject to the following restrictions:

//

// 1. The origin of this software must not be misrepresented;

//    you must not claim that you wrote the original software.

//    If you use this software in a product, an acknowledgment

//    in the product documentation would be appreciated but is not required.

//

// 2. Altered source versions must be plainly marked as such,

//    and must not be misrepresented as being the original software.

//

// 3. This notice may not be removed or altered from any source distribution.

//


#pragma once


// Headers

#include <SFML/Window/Export.hpp>


#include <SFML/Window/Vulkan.hpp>

#include <SFML/Window/WindowEnums.hpp>

#include <SFML/Window/WindowHandle.hpp>


#include <SFML/System/Time.hpp>

#include <SFML/System/Vector2.hpp>


#include <memory>

#include <optional>


#include <cstdint>


namespace sf

{

class Cursor;

class String;

class VideoMode;


namespace priv

{

class WindowImpl;

}


class Event;


class SFML_WINDOW_API WindowBase

{

public:

    WindowBase();


    WindowBase(VideoMode mode, const String& title, std::uint32_t style = Style::Default, State state = State::Windowed);


    WindowBase(VideoMode mode, const String& title, State state);


    explicit WindowBase(WindowHandle handle);


    virtual ~WindowBase();


    WindowBase(const WindowBase&) = delete;


    WindowBase& operator=(const WindowBase&) = delete;


    WindowBase(WindowBase&&) noexcept;


    WindowBase& operator=(WindowBase&&) noexcept;


    virtual void create(VideoMode mode, const String& title, std::uint32_t style = Style::Default, State state = State::Windowed);


    virtual void create(VideoMode mode, const String& title, State state);


    virtual void create(WindowHandle handle);


    virtual void close();


    [[nodiscard]] bool isOpen() const;


    [[nodiscard]] std::optional<Event> pollEvent();


    [[nodiscard]] std::optional<Event> waitEvent(Time timeout = Time::Zero);


    template <typename... Ts>

    void handleEvents(Ts&&... handlers);


    [[nodiscard]] Vector2i getPosition() const;


    void setPosition(Vector2i position);


    [[nodiscard]] Vector2u getSize() const;


    void setSize(Vector2u size);


    void setMinimumSize(const std::optional<Vector2u>& minimumSize);


    void setMaximumSize(const std::optional<Vector2u>& maximumSize);


    void setTitle(const String& title);


    void setIcon(Vector2u size, const std::uint8_t* pixels);


    void setVisible(bool visible);


    void setMouseCursorVisible(bool visible);


    void setMouseCursorGrabbed(bool grabbed);


    void setMouseCursor(const Cursor& cursor);


    void setKeyRepeatEnabled(bool enabled);


    void setJoystickThreshold(float threshold);


    void requestFocus();


    [[nodiscard]] bool hasFocus() const;


    [[nodiscard]] WindowHandle getNativeHandle() const;


    [[nodiscard]] bool createVulkanSurface(const VkInstance&            instance,

                                           VkSurfaceKHR&                surface,

                                           const VkAllocationCallbacks* allocator = nullptr);


protected:

    virtual void onCreate();


    virtual void onResize();


private:

    friend class Window;


    void filterEvent(const Event& event);


    void initialize();


    // Member data

    std::unique_ptr<priv::WindowImpl> m_impl;

    Vector2u                          m_size;

};


} // namespace sf


#include <SFML/Window/WindowBase.inl>


Time.hpp

Vector2.hpp

Vulkan.hpp

VkInstance
struct VkInstance_T * VkInstance
Definition Vulkan.hpp:35

VkSurfaceKHR
std::uint64_t VkSurfaceKHR
Definition Vulkan.hpp:47

WindowEnums.hpp

WindowHandle.hpp

Export.hpp

SFML_WINDOW_API
#define SFML_WINDOW_API
Definition Window/Export.hpp:42

sf::Cursor
Cursor defines the appearance of a system cursor.
Definition Cursor.hpp:51

sf::Event
Defines a system event and its parameters.
Definition Event.hpp:47

sf::String
Utility string class that automatically handles conversions between types and encodings.
Definition String.hpp:89

sf::Time
Represents a time value.
Definition Time.hpp:42

sf::Vector2< int >

sf::VideoMode
VideoMode defines a video mode (size, bpp)
Definition VideoMode.hpp:44

sf::WindowBase
Window that serves as a base for other windows.
Definition WindowBase.hpp:63

sf::WindowBase::WindowBase
WindowBase()
Default constructor.

sf::WindowBase::WindowBase
WindowBase(VideoMode mode, const String &title, State state)
Construct a new window.

sf::WindowBase::WindowBase
WindowBase(const WindowBase &)=delete
Deleted copy constructor.

sf::WindowBase::~WindowBase
virtual ~WindowBase()
Destructor.

sf::WindowBase::WindowBase
WindowBase(WindowHandle handle)
Construct the window from an existing control.

sf::WindowBase::WindowBase
WindowBase(VideoMode mode, const String &title, std::uint32_t style=Style::Default, State state=State::Windowed)
Construct a new window.

sf::WindowBase::WindowBase
WindowBase(WindowBase &&) noexcept
Move constructor.

sf::WindowBase::operator=
WindowBase & operator=(const WindowBase &)=delete
Deleted copy assignment.

sf::Window
Window that serves as a target for OpenGL rendering.
Definition Window/Window.hpp:56

sf::State
State
Enumeration of the window states.
Definition WindowEnums.hpp:55

sf::WindowHandle
"platform-specific" WindowHandle
Low-level window handle type, specific to each platform.
Definition WindowHandle.hpp:68

sf
Definition AudioResource.hpp:36