canvas-event.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Authors:
 *   Matthew Jakeman <mjakeman26@outlook.co.nz>
 *   PBS <pbs3141@gmail.com>
 *
 * Copyright (C) 2022 Authors
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
#ifndef INKSCAPE_UI_WIDGET_EVENTS_CANVAS_EVENT_H
#define INKSCAPE_UI_WIDGET_EVENTS_CANVAS_EVENT_H
 
#include <cstdint>
#include <memory>
#include <optional>
 
#include <gdk/gdk.h>
#include <gdkmm/enums.h>
#include <gdkmm/event.h>
#include <2geom/point.h>
 
#include "enums.h"
#include "util/variant-visitor.h"
 
namespace Gdk { class Device; }
 
namespace Inkscape {
 
struct ExtendedInput
{
    std::optional<double> pressure, xtilt, ytilt;
};
 
inline ExtendedInput extinput_from_gdkevent(Gdk::Event const &event)
{
    auto read = [&] (Gdk::AxisUse axis) -> std::optional<double> {
        double tmp;
        if (event.get_axis(axis, tmp)) {
            return tmp;
        } else {
            return {};
        }
    };
 
    return {
        .pressure = read(Gdk::AxisUse::PRESSURE),
        .xtilt = read(Gdk::AxisUse::XTILT),
        .ytilt = read(Gdk::AxisUse::YTILT)
    };
}
 
struct CanvasEvent
{
    virtual ~CanvasEvent() {}
 
    virtual EventType type() const = 0;
 
    unsigned modifiers = 0;
 
    virtual unsigned modifiersChange() const { return 0; }
 
    unsigned modifiersAfter() const { return modifiers ^ modifiersChange(); }
 
    std::shared_ptr<Gdk::Device const> device;
};
 
struct ButtonEvent : CanvasEvent
{
    unsigned modifiersChange() const override
    {
        switch (button) {
            case 1: return GDK_BUTTON1_MASK;
            case 2: return GDK_BUTTON2_MASK;
            case 3: return GDK_BUTTON3_MASK;
            case 4: return GDK_BUTTON4_MASK;
            case 5: return GDK_BUTTON5_MASK;
            default: return 0; // Buttons can range at least to 9 but mask defined only to 5.
        }
    }
 
    Geom::Point pos;
 
    Geom::Point orig_pos;
 
    unsigned button = 0;
 
    uint32_t time = 0;
};
 
struct ButtonPressEvent final : ButtonEvent
{
    EventType type() const override { return EventType::BUTTON_PRESS; }
 
    int num_press = 1;
 
    ExtendedInput extinput;
};
 
struct ButtonReleaseEvent final : ButtonEvent
{
    EventType type() const override { return EventType::BUTTON_RELEASE; }
};
 
struct KeyEvent : CanvasEvent
{
    unsigned modifiersChange() const override
    {
        switch (keyval) {
            case GDK_KEY_Shift_L:
            case GDK_KEY_Shift_R:
                return GDK_SHIFT_MASK;
            case GDK_KEY_Control_L:
            case GDK_KEY_Control_R:
                return GDK_CONTROL_MASK;
            case GDK_KEY_Alt_L:
            case GDK_KEY_Alt_R:
                return GDK_ALT_MASK;
            case GDK_KEY_Meta_L:
            case GDK_KEY_Meta_R:
                return GDK_META_MASK;
            default:
                return 0;
        }
    }
 
    uint32_t keyval = 0;
 
    uint16_t keycode = 0;
 
    int group = 0;
 
    uint32_t time = 0;
 
    std::optional<Geom::Point> pos;
 
    std::optional<Geom::Point> orig_pos;
};
 
struct KeyPressEvent final : KeyEvent
{
    EventType type() const override { return EventType::KEY_PRESS; }
};
 
struct KeyReleaseEvent final : KeyEvent
{
    EventType type() const override { return EventType::KEY_RELEASE; }
};
 
struct MotionEvent final : CanvasEvent
{
    EventType type() const override { return EventType::MOTION; }
 
    Geom::Point pos;
 
    uint32_t time = 0;
 
    bool control_point_synthesized = false;
 
    ExtendedInput extinput;
};
 
struct EnterEvent final : CanvasEvent
{
    EventType type() const override { return EventType::ENTER; }
 
    Geom::Point pos;
};
 
struct LeaveEvent final : CanvasEvent
{
    EventType type() const override { return EventType::LEAVE; }
};
 
struct ScrollEvent final : CanvasEvent
{
    EventType type() const override { return EventType::SCROLL; }
 
    Geom::Point delta;
 
    Gdk::ScrollUnit unit = Gdk::ScrollUnit::SURFACE;
 
    ExtendedInput extinput;
};
 
namespace canvas_event_detail {
 
template <typename E>
E &cast_helper(CanvasEvent &event)
{
    return static_cast<E &>(event);
}
 
template <typename E>
E const &cast_helper(CanvasEvent const &event)
{
    return static_cast<E const &>(event);
}
 
template <typename E>
E &&cast_helper(CanvasEvent &&event)
{
    return static_cast<E &&>(event);
}
 
} // namespace canvas_event_detail
 
template <typename E, typename... Fs>
void inspect_event(E &&event, Fs... funcs)
{
    using namespace canvas_event_detail;
 
    auto overloaded = VariantVisitor{funcs...};
 
    switch (event.type()) {
        case EventType::ENTER:
            overloaded(cast_helper<EnterEvent>(std::forward<E>(event)));
            break;
        case EventType::LEAVE:
            overloaded(cast_helper<LeaveEvent>(std::forward<E>(event)));
            break;
        case EventType::MOTION:
            overloaded(cast_helper<MotionEvent>(std::forward<E>(event)));
            break;
        case EventType::BUTTON_PRESS:
            overloaded(cast_helper<ButtonPressEvent>(std::forward<E>(event)));
            break;
        case EventType::BUTTON_RELEASE:
            overloaded(cast_helper<ButtonReleaseEvent>(std::forward<E>(event)));
            break;
        case EventType::KEY_PRESS:
            overloaded(cast_helper<KeyPressEvent>(std::forward<E>(event)));
            break;
        case EventType::KEY_RELEASE:
            overloaded(cast_helper<KeyReleaseEvent>(std::forward<E>(event)));
            break;
        case EventType::SCROLL:
            overloaded(cast_helper<ScrollEvent>(std::forward<E>(event)));
            break;
        default:
            break;
    }
}
 
/*
 * Modifier-testing functions.
 */
 
inline constexpr auto INK_GDK_MODIFIER_MASK = GDK_SHIFT_MASK | GDK_CONTROL_MASK | GDK_ALT_MASK;
 
inline bool mod_shift(unsigned modifiers) { return modifiers & GDK_SHIFT_MASK; }
inline bool mod_ctrl(unsigned modifiers) { return modifiers & GDK_CONTROL_MASK; }
inline bool mod_alt(unsigned modifiers) { return modifiers & GDK_ALT_MASK; }
inline bool mod_shift_only(unsigned modifiers) { return (modifiers & INK_GDK_MODIFIER_MASK) == GDK_SHIFT_MASK; }
inline bool mod_ctrl_only(unsigned modifiers) { return (modifiers & INK_GDK_MODIFIER_MASK) == GDK_CONTROL_MASK; }
inline bool mod_alt_only(unsigned modifiers) { return (modifiers & INK_GDK_MODIFIER_MASK) == GDK_ALT_MASK; }
inline bool mod_any(unsigned modifiers) { return modifiers & INK_GDK_MODIFIER_MASK; }
inline bool mod_none(unsigned modifiers) { return !mod_any(modifiers); }
 
template <unsigned button>
inline bool mod_button(unsigned modifiers) { return (1 <= button || button <= 5) && (modifiers & (GDK_BUTTON1_MASK << (button - 1))); }
 
inline bool mod_shift(CanvasEvent const &event) { return mod_shift(event.modifiers); }
inline bool mod_ctrl(CanvasEvent const &event) { return mod_ctrl(event.modifiers); }
inline bool mod_alt(CanvasEvent const &event) { return mod_alt(event.modifiers); }
inline bool mod_shift_only(CanvasEvent const &event) { return mod_shift_only(event.modifiers); }
inline bool mod_ctrl_only(CanvasEvent const &event) { return mod_ctrl_only(event.modifiers); }
inline bool mod_alt_only(CanvasEvent const &event) { return mod_alt_only(event.modifiers); }
inline bool mod_any(CanvasEvent const &event) { return mod_any(event.modifiers); }
inline bool mod_none(CanvasEvent const &event) { return mod_none(event.modifiers); }
 
template <unsigned button>
inline bool mod_button(CanvasEvent const &event) { return mod_button<button>(event.modifiers); }
 
} // namespace Inkscape
 
#endif // INKSCAPE_UI_WIDGET_EVENTS_CANVAS_EVENT_H
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim:filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99: