mouse_event.hpp

// Copyright Take Vos 2020.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "mouse_buttons.hpp"
#include "../geometry/point.hpp"
#include "../geometry/vector.hpp"
#include "../geometry/transform.hpp"
#include <chrono>
 
namespace tt {
 
struct mouse_event {
    enum class Type { None, Entered, Exited, Move, Drag, ButtonDown, ButtonUp, Wheel };
 
    Type type;
 
    std::chrono::utc_time<std::chrono::nanoseconds> timePoint;
 
    point2 position;
 
    point2 downPosition;
 
    vector2 wheelDelta;
 
    mouse_buttons cause;
 
    mouse_buttons down;
 
    int clickCount;
 
    mouse_event() noexcept :
        type(Type::None),
        position(),
        cause(),
        down(),
        clickCount(0)
    {
    }
 
    static mouse_event entered(point2 position={}) noexcept {
        mouse_event event;
        event.position = position;
        event.type = mouse_event::Type::Entered;
        return event;
    }
 
    static mouse_event exited() noexcept {
        // Position far away from the left/bottom corner, but where even
        // after translations will not cause the position to be infinite.
        constexpr float far_ = std::numeric_limits<float>::max() * -0.5f;
 
        mouse_event event;
        event.position = point2{far_, far_};
        event.type = mouse_event::Type::Exited;
        return event;
    }
 
    [[nodiscard]] vector2 delta() const noexcept
    {
        return type == Type::Drag ? position - downPosition : vector2{};
    }
 
    [[nodiscard]] friend mouse_event operator*(geo::transformer auto const &transform, mouse_event const &rhs) noexcept
    {
        auto r = rhs;
        r.position = point2{transform * rhs.position};
        r.downPosition = point2{transform * rhs.downPosition};
        r.wheelDelta = vector2{transform * rhs.wheelDelta};
        return r;
    }
 
    friend std::string to_string(mouse_event const &rhs) noexcept {
        char const *type_s;
        switch (rhs.type) {
        using enum mouse_event::Type;
        case None: type_s = "none"; break;
        case Entered: type_s = "entered"; break;
        case Exited: type_s = "exited"; break;
        case Move: type_s = "move"; break;
        case Drag: type_s = "drag"; break;
        case ButtonDown: type_s = "down"; break;
        case ButtonUp: type_s = "up"; break;
        case Wheel: type_s = "wheel"; break;
        default: tt_no_default();
        }
 
        return std::format("<mouse {} {}>", type_s, rhs.position);
    }
 
    friend std::ostream &operator<<(std::ostream &lhs, mouse_event const &rhs) {
        return lhs << to_string(rhs);
    }
};
 
 
 
}