Event.hpp

Go to the documentation of this file.

//
// 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/Joystick.hpp>
#include <SFML/Window/Keyboard.hpp>
#include <SFML/Window/Mouse.hpp>
#include <SFML/Window/Sensor.hpp>
 
#include <SFML/System/Vector2.hpp>
 
#include <variant>
 
 
namespace sf
{
class Event
{
public:
    struct Closed
    {
    };

    struct Resized
    {
        Vector2u size; 
    };

    struct FocusLost
    {
    };

    struct FocusGained
    {
    };

    struct TextEntered
    {
        std::uint32_t unicode{}; 
    };

    struct KeyPressed
    {
        Keyboard::Key      code{};     
        Keyboard::Scancode scancode{}; 
        bool               alt{};      
        bool               control{};  
        bool               shift{};    
        bool               system{};   
    };

    struct KeyReleased
    {
        Keyboard::Key      code{};     
        Keyboard::Scancode scancode{}; 
        bool               alt{};      
        bool               control{};  
        bool               shift{};    
        bool               system{};   
    };

    struct MouseWheelScrolled
    {
        Mouse::Wheel wheel{}; 
        float        delta{}; 
        Vector2i     position; 
    };

    struct MouseButtonPressed
    {
        Mouse::Button button{}; 
        Vector2i      position; 
    };

    struct MouseButtonReleased
    {
        Mouse::Button button{}; 
        Vector2i      position; 
    };

    struct MouseMoved
    {
        Vector2i position; 
    };

    struct MouseMovedRaw
    {
        Vector2i delta; 
    };

    struct MouseEntered
    {
    };

    struct MouseLeft
    {
    };

    struct JoystickButtonPressed
    {
        unsigned int joystickId{}; 
        unsigned int button{}; 
    };

    struct JoystickButtonReleased
    {
        unsigned int joystickId{}; 
        unsigned int button{}; 
    };

    struct JoystickMoved
    {
        unsigned int   joystickId{}; 
        Joystick::Axis axis{};       
        float          position{};   
    };

    struct JoystickConnected
    {
        unsigned int joystickId{}; 
    };

    struct JoystickDisconnected
    {
        unsigned int joystickId{}; 
    };

    struct TouchBegan
    {
        unsigned int finger{}; 
        Vector2i     position; 
    };

    struct TouchMoved
    {
        unsigned int finger{}; 
        Vector2i     position; 
    };

    struct TouchEnded
    {
        unsigned int finger{}; 
        Vector2i     position; 
    };

    struct SensorChanged
    {
        Sensor::Type type{}; 
        Vector3f     value;  
    };

    template <typename TEventSubtype>
    Event(const TEventSubtype& eventSubtype);

    template <typename TEventSubtype>
    [[nodiscard]] bool is() const;

    template <typename TEventSubtype>
    [[nodiscard]] const TEventSubtype* getIf() const;

    template <typename T>
    decltype(auto) visit(T&& visitor) const;
 
private:
    // Member data
    std::variant<Closed,
                 Resized,
                 FocusLost,
                 FocusGained,
                 TextEntered,
                 KeyPressed,
                 KeyReleased,
                 MouseWheelScrolled,
                 MouseButtonPressed,
                 MouseButtonReleased,
                 MouseMoved,
                 MouseMovedRaw,
                 MouseEntered,
                 MouseLeft,
                 JoystickButtonPressed,
                 JoystickButtonReleased,
                 JoystickMoved,
                 JoystickConnected,
                 JoystickDisconnected,
                 TouchBegan,
                 TouchMoved,
                 TouchEnded,
                 SensorChanged>
        m_data; 

    // Helper functions
    template <typename T, typename... Ts>
    [[nodiscard]] static constexpr bool isInParameterPack(const std::variant<Ts...>*)
    {
        return (std::is_same_v<T, Ts> || ...);
    }
 
    template <typename T>
    static constexpr bool isEventSubtype = isInParameterPack<T>(decltype (&m_data)(nullptr));
};
 
} // namespace sf
 
#include <SFML/Window/Event.inl>