element.h

Go to the documentation of this file.

/* ========================================================================= */
#ifndef __WLMTK_ELEMENT_H__
#define __WLMTK_ELEMENT_H__
 
#include <libbase/libbase.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <wayland-server-core.h>
#include <xkbcommon/xkbcommon.h>
 
#define WLR_USE_UNSTABLE
#include <wlr/util/box.h>
#undef WLR_USE_UNSTABLE
 
struct wlr_scene_tree;
 
typedef struct _wlmtk_element_t wlmtk_element_t;
typedef struct _wlmtk_element_vmt_t wlmtk_element_vmt_t;
 
typedef struct _wlmtk_container_t wlmtk_container_t;
struct wlr_keyboard_key_event;
 
#include "input.h"
 
#define WLR_USE_UNSTABLE
#include <wlr/types/wlr_pointer.h>
#undef WLR_USE_UNSTABLE
 
#ifdef __cplusplus
extern "C" {
#endif  // __cplusplus
 
typedef struct {
    struct wl_signal          pointer_enter;
    struct wl_signal          pointer_leave;
    struct wl_signal          pointer_motion;
} wlmtk_element_events_t;
 
struct _wlmtk_element_vmt_t {
    void (*destroy)(wlmtk_element_t *element_ptr);
 
    struct wlr_scene_node *(*create_scene_node)(
        wlmtk_element_t *element_ptr,
        struct wlr_scene_tree *wlr_scene_tree_ptr);
 
    void (*get_dimensions)(
        wlmtk_element_t *element_ptr,
        int *x1_ptr,
        int *y1_ptr,
        int *x2_ptr,
        int *y2_ptr);
 
    bool (*pointer_accepts_motion)(
        wlmtk_element_t *element_ptr,
        wlmtk_pointer_motion_event_t *motion_event_ptr);
 
    void (*pointer_grab_cancel)(wlmtk_element_t *element_ptr);
 
    bool (*pointer_button)(
        wlmtk_element_t *element_ptr,
        const wlmtk_button_event_t *button_event_ptr);
 
    bool (*pointer_axis)(
        wlmtk_element_t *element_ptr,
        struct wlr_pointer_axis_event *wlr_pointer_axis_event_ptr);
 
    void (*keyboard_blur)(wlmtk_element_t *element_ptr);
 
    bool (*keyboard_event)(
        wlmtk_element_t *element_ptr,
        struct wlr_keyboard_key_event *wlr_keyboard_key_event_ptr);
 
    bool (*keyboard_sym)(
        wlmtk_element_t *element_ptr,
        xkb_keysym_t keysym,
        enum xkb_key_direction direction,
        uint32_t modifiers);
};
 
struct _wlmtk_element_t {
    bs_dllist_node_t          dlnode;
 
    wlmtk_element_vmt_t       vmt;
    wlmtk_element_events_t    events;
 
    wlmtk_container_t         *parent_container_ptr;
 
    struct wlr_scene_node     *wlr_scene_node_ptr;
 
    struct wl_listener        wlr_scene_node_destroy_listener;
 
    wlmtk_pointer_motion_event_t last_pointer_motion_event;
 
    int x;
    int y;
 
    bool                      visible;
 
    bool                      pointer_inside;
 
    bool                      inhibit_pointer_blur;
};
 
bool wlmtk_element_init(wlmtk_element_t *element_ptr);
 
wlmtk_element_vmt_t wlmtk_element_extend(
    wlmtk_element_t *element_ptr,
    const wlmtk_element_vmt_t *element_vmt_ptr);
 
void wlmtk_element_fini(
    wlmtk_element_t *element_ptr);
 
bs_dllist_node_t *wlmtk_dlnode_from_element(
    wlmtk_element_t *element_ptr);
wlmtk_element_t *wlmtk_element_from_dlnode(
    bs_dllist_node_t *dlnode_ptr);
 
void wlmtk_element_set_parent_container(
    wlmtk_element_t *element_ptr,
    wlmtk_container_t *parent_container_ptr);
 
void wlmtk_element_attach_to_scene_graph(
    wlmtk_element_t *element_ptr);
 
void wlmtk_element_set_visible(wlmtk_element_t *element_ptr, bool visible);
 
void wlmtk_element_get_position(
    wlmtk_element_t *element_ptr,
    int *x_ptr,
    int *y_ptr);
 
void wlmtk_element_set_position(
    wlmtk_element_t *element_ptr,
    int x,
    int y);
 
static inline void wlmtk_element_get_dimensions(
    wlmtk_element_t *element_ptr,
    int *left_ptr,
    int *top_ptr,
    int *right_ptr,
    int *bottom_ptr)
{
    element_ptr->vmt.get_dimensions(
        element_ptr, left_ptr, top_ptr, right_ptr, bottom_ptr);
}
 
static inline struct wlr_box wlmtk_element_get_dimensions_box(
    wlmtk_element_t *element_ptr)
{
    struct wlr_box box;
    element_ptr->vmt.get_dimensions(
        element_ptr, &box.x, &box.y, &box.width, &box.height);
    box.width -= box.x;
    box.height -= box.y;
    return box;
}
 
bool wlmtk_element_pointer_motion(
    wlmtk_element_t *element_ptr,
    wlmtk_pointer_motion_event_t *pointer_motion_ptr);
 
bool wlmtk_element_pointer_button(
    wlmtk_element_t *element_ptr,
    const wlmtk_button_event_t *button_event_ptr);
 
bool wlmtk_element_pointer_axis(
    wlmtk_element_t *element_ptr,
    struct wlr_pointer_axis_event *wlr_pointer_axis_event_ptr);
 
bool wlmtk_element_pointer_focus(
    wlmtk_element_t *element_ptr,
    wlmtk_pointer_motion_event_t *motion_event_ptr);
 
void wlmtk_element_pointer_blur(wlmtk_element_t *element_ptr);
 
void wlmtk_element_pointer_grab_cancel(wlmtk_element_t *element_ptr);
 
static inline bool wlmtk_element_keyboard_event(
    wlmtk_element_t *element_ptr,
    struct wlr_keyboard_key_event *wlr_keyboard_key_event_ptr)
{
    return element_ptr->vmt.keyboard_event(
        element_ptr, wlr_keyboard_key_event_ptr);
}
 
static inline bool wlmtk_element_keyboard_sym(
    wlmtk_element_t *element_ptr,
    xkb_keysym_t keysym,
    enum xkb_key_direction direction,
    uint32_t modifiers)
{
    return element_ptr->vmt.keyboard_sym(
        element_ptr, keysym, direction, modifiers);
}
 
static inline void wlmtk_element_keyboard_blur(
    wlmtk_element_t *element_ptr)
{
    if (NULL != element_ptr->vmt.keyboard_blur) {
        element_ptr->vmt.keyboard_blur(element_ptr);
    }
}
 
static inline void wlmtk_element_destroy(
    wlmtk_element_t *element_ptr) {
    element_ptr->vmt.destroy(element_ptr);
}
 
extern const bs_test_case_t wlmtk_element_test_cases[];
 
typedef struct {
    wlmtk_element_t           element;
    wlmtk_element_vmt_t       orig_vmt;
    struct wlr_box            dimensions;
 
    bool                      pointer_accepts_motion_called;
 
    bool                      pointer_button_called;
    wlmtk_button_event_t      pointer_button_event;
    bool                      pointer_axis_called;
    bool                      pointer_grab_cancel_called;
    bool                      has_keyboard_focus;
    bool                      keyboard_event_called;
    bool                      keyboard_sym_called;
 
    struct wlr_pointer_axis_event wlr_pointer_axis_event;
} wlmtk_fake_element_t;
 
wlmtk_fake_element_t *wlmtk_fake_element_create(void);
 
void wlmtk_fake_element_set_dimensions(
    wlmtk_fake_element_t *fake_element_ptr,
    int width, int height);
 
void wlmtk_fake_element_grab_keyboard(wlmtk_fake_element_t *fake_element_ptr);
 
#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus
 
#endif /* __WLMTK_ELEMENT_H__ */
/* == End of element.h ===================================================== */