mirrors
/
weston
mirror of https://gitlab.freedesktop.org/wayland/weston.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
weston/libweston/compositor.h

2326 lines
66 KiB
C
Raw Permalink Blame History

/*
* Copyright © 2008-2011 Kristian Høgsberg
* Copyright © 2012, 2017, 2018 Collabora, Ltd.
* Copyright © 2017, 2018 General Electric Company
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef _WAYLAND_SYSTEM_COMPOSITOR_H_
#define _WAYLAND_SYSTEM_COMPOSITOR_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdbool.h>
#include <stdint.h>
#include <time.h>
#include <pixman.h>
#include <xkbcommon/xkbcommon.h>
#define WL_HIDE_DEPRECATED
#include <wayland-server.h>
#include "matrix.h"
#include "config-parser.h"
#include "zalloc.h"
#include "timeline-object.h"
struct weston_geometry {
int32_t x, y;
int32_t width, height;
};
struct weston_position {
int32_t x, y;
};
struct weston_size {
int32_t width, height;
};
struct weston_transform {
struct weston_matrix matrix;
struct wl_list link;
};
/** 2D device coordinates normalized to [0, 1] range */
struct weston_point2d_device_normalized {
double x;
double y;
};
struct weston_surface;
struct weston_buffer;
struct shell_surface;
struct weston_seat;
struct weston_output;
struct input_method;
struct weston_pointer;
struct linux_dmabuf_buffer;
struct weston_recorder;
struct weston_pointer_constraint;
enum weston_keyboard_modifier {
MODIFIER_CTRL = (1 << 0),
MODIFIER_ALT = (1 << 1),
MODIFIER_SUPER = (1 << 2),
MODIFIER_SHIFT = (1 << 3),
};
enum weston_keyboard_locks {
WESTON_NUM_LOCK = (1 << 0),
WESTON_CAPS_LOCK = (1 << 1),
};
enum weston_led {
LED_NUM_LOCK = (1 << 0),
LED_CAPS_LOCK = (1 << 1),
LED_SCROLL_LOCK = (1 << 2),
};
enum weston_mode_aspect_ratio {
/** The picture aspect ratio values, for the aspect_ratio field of
* weston_mode. The values here, are taken from
* DRM_MODE_PICTURE_ASPECT_* from drm_mode.h.
*/
WESTON_MODE_PIC_AR_NONE = 0, /* DRM_MODE_PICTURE_ASPECT_NONE */
WESTON_MODE_PIC_AR_4_3 = 1, /* DRM_MODE_PICTURE_ASPECT_4_3 */
WESTON_MODE_PIC_AR_16_9 = 2, /* DRM_MODE_PICTURE_ASPECT_16_9 */
WESTON_MODE_PIC_AR_64_27 = 3, /* DRM_MODE_PICTURE_ASPECT_64_27 */
WESTON_MODE_PIC_AR_256_135 = 4, /* DRM_MODE_PICTURE_ASPECT_256_135*/
};
struct weston_mode {
uint32_t flags;
enum weston_mode_aspect_ratio aspect_ratio;
int32_t width, height;
uint32_t refresh;
struct wl_list link;
};
struct weston_animation {
void (*frame)(struct weston_animation *animation,
struct weston_output *output,
const struct timespec *time);
int frame_counter;
struct wl_list link;
};
enum {
WESTON_SPRING_OVERSHOOT,
WESTON_SPRING_CLAMP,
WESTON_SPRING_BOUNCE
};
struct weston_spring {
double k;
double friction;
double current;
double target;
double previous;
double min, max;
struct timespec timestamp;
uint32_t clip;
};
struct weston_output_zoom {
bool active;
float increment;
float level;
float max_level;
float trans_x, trans_y;
struct {
double x, y;
} current;
struct weston_seat *seat;
struct weston_animation animation_z;
struct weston_spring spring_z;
struct wl_listener motion_listener;
};
/* bit compatible with drm definitions. */
enum dpms_enum {
WESTON_DPMS_ON,
WESTON_DPMS_STANDBY,
WESTON_DPMS_SUSPEND,
WESTON_DPMS_OFF
};
/** Represents a monitor
*
* This object represents a monitor (hardware backends like DRM) or a window
* (windowed nested backends).
*/
struct weston_head {
struct weston_compositor *compositor; /**< owning compositor */
struct wl_list compositor_link; /**< in weston_compositor::head_list */
struct wl_signal destroy_signal; /**< destroy callbacks */
struct weston_output *output; /**< the output driving this head */
struct wl_list output_link; /**< in weston_output::head_list */
struct wl_list resource_list; /**< wl_output protocol objects */
struct wl_global *global; /**< wl_output global */
int32_t mm_width; /**< physical image width in mm */
int32_t mm_height; /**< physical image height in mm */
char *make; /**< monitor manufacturer (PNP ID) */
char *model; /**< monitor model */
char *serial_number; /**< monitor serial */
uint32_t subpixel; /**< enum wl_output_subpixel */
bool connection_internal; /**< embedded monitor (e.g. laptop) */
bool device_changed; /**< monitor information has changed */
char *name; /**< head name, e.g. connector name */
bool connected; /**< is physically connected */
};
struct weston_output {
uint32_t id;
char *name;
/** Matches the lifetime from the user perspective */
struct wl_signal user_destroy_signal;
void *renderer_state;
struct wl_list link;
struct weston_compositor *compositor;
/** From global to output buffer coordinates. */
struct weston_matrix matrix;
/** From output buffer to global coordinates. */
struct weston_matrix inverse_matrix;
struct wl_list animation_list;
int32_t x, y, width, height;
/** Output area in global coordinates, simple rect */
pixman_region32_t region;
pixman_region32_t previous_damage;
/** True if damage has occurred since the last repaint for this output;
* if set, a repaint will eventually occur. */
bool repaint_needed;
/** Used only between repaint_begin and repaint_cancel. */
bool repainted;
/** State of the repaint loop */
enum {
REPAINT_NOT_SCHEDULED = 0, /**< idle; no repaint will occur */
REPAINT_BEGIN_FROM_IDLE, /**< start_repaint_loop scheduled */
REPAINT_SCHEDULED, /**< repaint is scheduled to occur */
REPAINT_AWAITING_COMPLETION, /**< last repaint not yet finished */
} repaint_status;
/** If repaint_status is REPAINT_SCHEDULED, contains the time the
* next repaint should be run */
struct timespec next_repaint;
/** For cancelling the idle_repaint callback on output destruction. */
struct wl_event_source *idle_repaint_source;
struct weston_output_zoom zoom;
int dirty;
struct wl_signal frame_signal;
struct wl_signal destroy_signal; /**< sent when disabled */
int move_x, move_y;
struct timespec frame_time; /* presentation timestamp */
uint64_t msc; /* media stream counter */
int disable_planes;
int destroying;
struct wl_list feedback_list;
uint32_t transform;
int32_t native_scale;
int32_t current_scale;
int32_t original_scale;
struct weston_mode *native_mode;
struct weston_mode *current_mode;
struct weston_mode *original_mode;
struct wl_list mode_list;
struct wl_list head_list; /**< List of driven weston_heads */
void (*start_repaint_loop)(struct weston_output *output);
int (*repaint)(struct weston_output *output,
pixman_region32_t *damage,
void *repaint_data);
void (*destroy)(struct weston_output *output);
void (*assign_planes)(struct weston_output *output, void *repaint_data);
int (*switch_mode)(struct weston_output *output, struct weston_mode *mode);
/* backlight values are on 0-255 range, where higher is brighter */
int32_t backlight_current;
void (*set_backlight)(struct weston_output *output, uint32_t value);
void (*set_dpms)(struct weston_output *output, enum dpms_enum level);
uint16_t gamma_size;
void (*set_gamma)(struct weston_output *output,
uint16_t size,
uint16_t *r,
uint16_t *g,
uint16_t *b);
struct weston_timeline_object timeline;
bool enabled; /**< is in the output_list, not pending list */
int scale;
int (*enable)(struct weston_output *output);
int (*disable)(struct weston_output *output);
/** Attach a head in the backend
*
* @param output The output to attach to.
* @param head The head to attach.
* @return 0 on success, -1 on failure.
*
* Do anything necessary to account for a new head being attached to
* the output, and check any conditions possible. On failure, both
* the head and the output must be left as before the call.
*
* Libweston core will add the head to the head_list after a successful
* call.
*/
int (*attach_head)(struct weston_output *output,
struct weston_head *head);
/** Detach a head in the backend
*
* @param output The output to detach from.
* @param head The head to detach.
*
* Do any clean-up necessary to detach this head from the output.
* The head has already been removed from the output's head_list.
*/
void (*detach_head)(struct weston_output *output,
struct weston_head *head);
};
enum weston_pointer_motion_mask {
WESTON_POINTER_MOTION_ABS = 1 << 0,
WESTON_POINTER_MOTION_REL = 1 << 1,
WESTON_POINTER_MOTION_REL_UNACCEL = 1 << 2,
};
struct weston_pointer_motion_event {
uint32_t mask;
struct timespec time;
double x;
double y;
double dx;
double dy;
double dx_unaccel;
double dy_unaccel;
};
struct weston_pointer_axis_event {
uint32_t axis;
double value;
bool has_discrete;
int32_t discrete;
};
struct weston_pointer_grab;
struct weston_pointer_grab_interface {
void (*focus)(struct weston_pointer_grab *grab);
void (*motion)(struct weston_pointer_grab *grab,
const struct timespec *time,
struct weston_pointer_motion_event *event);
void (*button)(struct weston_pointer_grab *grab,
const struct timespec *time,
uint32_t button, uint32_t state);
void (*axis)(struct weston_pointer_grab *grab,
const struct timespec *time,
struct weston_pointer_axis_event *event);
void (*axis_source)(struct weston_pointer_grab *grab, uint32_t source);
void (*frame)(struct weston_pointer_grab *grab);
void (*cancel)(struct weston_pointer_grab *grab);
};
struct weston_pointer_grab {
const struct weston_pointer_grab_interface *interface;
struct weston_pointer *pointer;
};
struct weston_keyboard_grab;
struct weston_keyboard_grab_interface {
void (*key)(struct weston_keyboard_grab *grab,
const struct timespec *time, uint32_t key, uint32_t state);
void (*modifiers)(struct weston_keyboard_grab *grab, uint32_t serial,
uint32_t mods_depressed, uint32_t mods_latched,
uint32_t mods_locked, uint32_t group);
void (*cancel)(struct weston_keyboard_grab *grab);
};
struct weston_keyboard_grab {
const struct weston_keyboard_grab_interface *interface;
struct weston_keyboard *keyboard;
};
struct weston_touch_grab;
struct weston_touch_grab_interface {
void (*down)(struct weston_touch_grab *grab,
const struct timespec *time,
int touch_id,
wl_fixed_t sx,
wl_fixed_t sy);
void (*up)(struct weston_touch_grab *grab,
const struct timespec *time,
int touch_id);
void (*motion)(struct weston_touch_grab *grab,
const struct timespec *time,
int touch_id,
wl_fixed_t sx,
wl_fixed_t sy);
void (*frame)(struct weston_touch_grab *grab);
void (*cancel)(struct weston_touch_grab *grab);
};
struct weston_touch_grab {
const struct weston_touch_grab_interface *interface;
struct weston_touch *touch;
};
struct weston_data_offer {
struct wl_resource *resource;
struct weston_data_source *source;
struct wl_listener source_destroy_listener;
uint32_t dnd_actions;
enum wl_data_device_manager_dnd_action preferred_dnd_action;
bool in_ask;
};
struct weston_data_source {
struct wl_resource *resource;
struct wl_signal destroy_signal;
struct wl_array mime_types;
struct weston_data_offer *offer;
struct weston_seat *seat;
bool accepted;
bool actions_set;
uint32_t dnd_actions;
enum wl_data_device_manager_dnd_action current_dnd_action;
enum wl_data_device_manager_dnd_action compositor_action;
void (*accept)(struct weston_data_source *source,
uint32_t serial, const char *mime_type);
void (*send)(struct weston_data_source *source,
const char *mime_type, int32_t fd);
void (*cancel)(struct weston_data_source *source);
};
struct weston_pointer_client {
struct wl_list link;
struct wl_client *client;
struct wl_list pointer_resources;
struct wl_list relative_pointer_resources;
};
struct weston_pointer {
struct weston_seat *seat;
struct wl_list pointer_clients;
struct weston_view *focus;
struct weston_pointer_client *focus_client;
uint32_t focus_serial;
struct wl_listener focus_view_listener;
struct wl_listener focus_resource_listener;
struct wl_signal focus_signal;
struct wl_signal motion_signal;
struct wl_signal destroy_signal;
struct weston_view *sprite;
struct wl_listener sprite_destroy_listener;
int32_t hotspot_x, hotspot_y;
struct weston_pointer_grab *grab;
struct weston_pointer_grab default_grab;
wl_fixed_t grab_x, grab_y;
uint32_t grab_button;
uint32_t grab_serial;
struct timespec grab_time;
wl_fixed_t x, y;
wl_fixed_t sx, sy;
uint32_t button_count;
struct wl_listener output_destroy_listener;
struct wl_list timestamps_list;
};
/** libinput style calibration matrix
*
* See https://wayland.freedesktop.org/libinput/doc/latest/absolute_axes.html
* and libinput_device_config_calibration_set_matrix().
*/
struct weston_touch_device_matrix {
float m[6];
};
struct weston_touch_device;
/** Operations for a calibratable touchscreen */
struct weston_touch_device_ops {
/** Get the associated output if existing. */
struct weston_output *(*get_output)(struct weston_touch_device *device);
/** Get the name of the associated head if existing. */
const char *
(*get_calibration_head_name)(struct weston_touch_device *device);
/** Retrieve the current calibration matrix. */
void (*get_calibration)(struct weston_touch_device *device,
struct weston_touch_device_matrix *cal);
/** Set a new calibration matrix. */
void (*set_calibration)(struct weston_touch_device *device,
const struct weston_touch_device_matrix *cal);
};
enum weston_touch_mode {
/** Normal touch event handling */
WESTON_TOUCH_MODE_NORMAL,
/** Prepare moving to WESTON_TOUCH_MODE_CALIB.
*
* Move to WESTON_TOUCH_MODE_CALIB as soon as no touches are down on
* any seat. Until then, all touch events are routed normally.
*/
WESTON_TOUCH_MODE_PREP_CALIB,
/** Calibration mode
*
* Only a single weston_touch_device forwards events to the calibrator
* all other touch device cause a calibrator "wrong device" event to
* be sent.
*/
WESTON_TOUCH_MODE_CALIB,
/** Prepare moving to WESTON_TOUCH_MODE_NORMAL.
*
* Move to WESTON_TOUCH_MODE_NORMAL as soon as no touches are down on
* any seat. Until then, touch events are routed as in
* WESTON_TOUCH_MODE_CALIB except "wrong device" events are not sent.
*/
WESTON_TOUCH_MODE_PREP_NORMAL
};
/** Represents a physical touchscreen input device */
struct weston_touch_device {
char *syspath; /**< unique name */
struct weston_touch *aggregate; /**< weston_touch this is part of */
struct wl_list link; /**< in weston_touch::device_list */
struct wl_signal destroy_signal; /**< destroy notifier */
void *backend_data; /**< backend-specific private */
const struct weston_touch_device_ops *ops;
struct weston_touch_device_matrix saved_calibration;
};
/** Represents a set of touchscreen devices aggregated under a seat */
struct weston_touch {
struct weston_seat *seat;
struct wl_list device_list; /* struct weston_touch_device::link */
struct wl_list resource_list;
struct wl_list focus_resource_list;
struct weston_view *focus;
struct wl_listener focus_view_listener;
struct wl_listener focus_resource_listener;
uint32_t focus_serial;
struct wl_signal focus_signal;
uint32_t num_tp;
struct weston_touch_grab *grab;
struct weston_touch_grab default_grab;
int grab_touch_id;
wl_fixed_t grab_x, grab_y;
uint32_t grab_serial;
struct timespec grab_time;
struct wl_list timestamps_list;
};
void
weston_pointer_motion_to_abs(struct weston_pointer *pointer,
struct weston_pointer_motion_event *event,
wl_fixed_t *x, wl_fixed_t *y);
void
weston_pointer_send_motion(struct weston_pointer *pointer,
const struct timespec *time,
struct weston_pointer_motion_event *event);
bool
weston_pointer_has_focus_resource(struct weston_pointer *pointer);
void
weston_pointer_send_button(struct weston_pointer *pointer,
const struct timespec *time,
uint32_t button, uint32_t state_w);
void
weston_pointer_send_axis(struct weston_pointer *pointer,
const struct timespec *time,
struct weston_pointer_axis_event *event);
void
weston_pointer_send_axis_source(struct weston_pointer *pointer,
uint32_t source);
void
weston_pointer_send_frame(struct weston_pointer *pointer);
void
weston_pointer_set_focus(struct weston_pointer *pointer,
struct weston_view *view,
wl_fixed_t sx, wl_fixed_t sy);
void
weston_pointer_clear_focus(struct weston_pointer *pointer);
void
weston_pointer_start_grab(struct weston_pointer *pointer,
struct weston_pointer_grab *grab);
void
weston_pointer_end_grab(struct weston_pointer *pointer);
void
weston_pointer_clamp(struct weston_pointer *pointer,
wl_fixed_t *fx, wl_fixed_t *fy);
void
weston_pointer_move(struct weston_pointer *pointer,
struct weston_pointer_motion_event *event);
void
weston_pointer_set_default_grab(struct weston_pointer *pointer,
const struct weston_pointer_grab_interface *interface);
void
weston_pointer_constraint_destroy(struct weston_pointer_constraint *constraint);
void
weston_keyboard_set_focus(struct weston_keyboard *keyboard,
struct weston_surface *surface);
void
weston_keyboard_start_grab(struct weston_keyboard *device,
struct weston_keyboard_grab *grab);
void
weston_keyboard_end_grab(struct weston_keyboard *keyboard);
int
/*
* 'mask' and 'value' should be a bitwise mask of one or more
* valued of the weston_keyboard_locks enum.
*/
weston_keyboard_set_locks(struct weston_keyboard *keyboard,
uint32_t mask, uint32_t value);
bool
weston_keyboard_has_focus_resource(struct weston_keyboard *keyboard);
void
weston_keyboard_send_key(struct weston_keyboard *keyboard,
const struct timespec *time, uint32_t key,
enum wl_keyboard_key_state state);
void
weston_keyboard_send_modifiers(struct weston_keyboard *keyboard,
uint32_t serial, uint32_t mods_depressed,
uint32_t mods_latched,
uint32_t mods_locked, uint32_t group);
void
weston_touch_set_focus(struct weston_touch *touch,
struct weston_view *view);
void
weston_touch_start_grab(struct weston_touch *touch,
struct weston_touch_grab *grab);
void
weston_touch_end_grab(struct weston_touch *touch);
bool
weston_touch_has_focus_resource(struct weston_touch *touch);
void
weston_touch_send_down(struct weston_touch *touch, const struct timespec *time,
int touch_id, wl_fixed_t x, wl_fixed_t y);
void
weston_touch_send_up(struct weston_touch *touch, const struct timespec *time,
int touch_id);
void
weston_touch_send_motion(struct weston_touch *touch,
const struct timespec *time, int touch_id,
wl_fixed_t x, wl_fixed_t y);
void
weston_touch_send_frame(struct weston_touch *touch);
struct weston_touch_device *
weston_touch_create_touch_device(struct weston_touch *touch,
const char *syspath,
void *backend_data,
const struct weston_touch_device_ops *ops);
void
weston_touch_device_destroy(struct weston_touch_device *device);
bool
weston_touch_device_can_calibrate(struct weston_touch_device *device);
void
wl_data_device_set_keyboard_focus(struct weston_seat *seat);
int
wl_data_device_manager_init(struct wl_display *display);
void
weston_seat_set_selection(struct weston_seat *seat,
struct weston_data_source *source, uint32_t serial);
void
weston_seat_send_selection(struct weston_seat *seat, struct wl_client *client);
int
weston_pointer_start_drag(struct weston_pointer *pointer,
struct weston_data_source *source,
struct weston_surface *icon,
struct wl_client *client);
int
weston_touch_start_drag(struct weston_touch *touch,
struct weston_data_source *source,
struct weston_surface *icon,
struct wl_client *client);
struct weston_xkb_info {
struct xkb_keymap *keymap;
size_t keymap_size;
char *keymap_string;
int32_t ref_count;
xkb_mod_index_t shift_mod;
xkb_mod_index_t caps_mod;
xkb_mod_index_t ctrl_mod;
xkb_mod_index_t alt_mod;
xkb_mod_index_t mod2_mod;
xkb_mod_index_t mod3_mod;
xkb_mod_index_t super_mod;
xkb_mod_index_t mod5_mod;
xkb_led_index_t num_led;
xkb_led_index_t caps_led;
xkb_led_index_t scroll_led;
};
struct weston_keyboard {
struct weston_seat *seat;
struct wl_list resource_list;
struct wl_list focus_resource_list;
struct weston_surface *focus;
struct wl_listener focus_resource_listener;
uint32_t focus_serial;
struct wl_signal focus_signal;
struct weston_keyboard_grab *grab;
struct weston_keyboard_grab default_grab;
uint32_t grab_key;
uint32_t grab_serial;
struct timespec grab_time;
struct wl_array keys;
struct {
uint32_t mods_depressed;
uint32_t mods_latched;
uint32_t mods_locked;
uint32_t group;
} modifiers;
struct weston_keyboard_grab input_method_grab;
struct wl_resource *input_method_resource;
struct weston_xkb_info *xkb_info;
struct {
struct xkb_state *state;
enum weston_led leds;
} xkb_state;
struct xkb_keymap *pending_keymap;
struct wl_list timestamps_list;
};
struct weston_seat {
struct wl_list base_resource_list;
struct wl_global *global;
struct weston_pointer *pointer_state;
struct weston_keyboard *keyboard_state;
struct weston_touch *touch_state;
int pointer_device_count;
int keyboard_device_count;
int touch_device_count;
struct weston_output *output; /* constraint */
struct wl_signal destroy_signal;
struct wl_signal updated_caps_signal;
struct weston_compositor *compositor;
struct wl_list link;
enum weston_keyboard_modifier modifier_state;
struct weston_surface *saved_kbd_focus;
struct wl_listener saved_kbd_focus_listener;
struct wl_list drag_resource_list;
uint32_t selection_serial;
struct weston_data_source *selection_data_source;
struct wl_listener selection_data_source_listener;
struct wl_signal selection_signal;
void (*led_update)(struct weston_seat *ws, enum weston_led leds);
struct input_method *input_method;
char *seat_name;
};
enum {
WESTON_COMPOSITOR_ACTIVE, /* normal rendering and events */
WESTON_COMPOSITOR_IDLE, /* shell->unlock called on activity */
WESTON_COMPOSITOR_OFFSCREEN, /* no rendering, no frame events */
WESTON_COMPOSITOR_SLEEPING /* same as offscreen, but also set dpms
* to off */
};
struct weston_layer_entry {
struct wl_list link;
struct weston_layer *layer;
};
/**
* Higher value means higher in the stack.
*
* These values are based on well-known concepts in a classic desktop
* environment. Third-party modules based on libweston are encouraged to use
* them to integrate better with other projects.
*
* A fully integrated environment can use any value, based on these or not,
* at their discretion.
*/
enum weston_layer_position {
/*
* Special value to make the layer invisible and still rendered.
* This is used by compositors wanting e.g. minimized surfaces to still
* receive frame callbacks.
*/
WESTON_LAYER_POSITION_HIDDEN = 0x00000000,
/*
* There should always be a background layer with a surface covering
* the visible area.
*
* If the compositor handles the background itself, it should use
* BACKGROUND.
*
* If the compositor supports runtime-loadable modules to set the
* background, it should put a solid color surface at (BACKGROUND - 1)
* and modules must use BACKGROUND.
*/
WESTON_LAYER_POSITION_BACKGROUND = 0x00000002,
/* For "desktop widgets" and applications like conky. */
WESTON_LAYER_POSITION_BOTTOM_UI = 0x30000000,
/* For regular applications, only one layer should have this value
* to ensure proper stacking control. */
WESTON_LAYER_POSITION_NORMAL = 0x50000000,
/* For desktop UI, like panels. */
WESTON_LAYER_POSITION_UI = 0x80000000,
/* For fullscreen applications that should cover UI. */
WESTON_LAYER_POSITION_FULLSCREEN = 0xb0000000,
/* For special UI like on-screen keyboard that fullscreen applications
* will need. */
WESTON_LAYER_POSITION_TOP_UI = 0xe0000000,
/* For the lock surface. */
WESTON_LAYER_POSITION_LOCK = 0xffff0000,
/* Values reserved for libweston internal usage */
WESTON_LAYER_POSITION_CURSOR = 0xfffffffe,
WESTON_LAYER_POSITION_FADE = 0xffffffff,
};
struct weston_layer {
struct weston_compositor *compositor;
struct wl_list link; /* weston_compositor::layer_list */
enum weston_layer_position position;
pixman_box32_t mask;
struct weston_layer_entry view_list;
};
struct weston_plane {
struct weston_compositor *compositor;
pixman_region32_t damage; /**< in global coords */
pixman_region32_t clip;
int32_t x, y;
struct wl_list link;
};
struct weston_renderer {
int (*read_pixels)(struct weston_output *output,
pixman_format_code_t format, void *pixels,
uint32_t x, uint32_t y,
uint32_t width, uint32_t height);
void (*repaint_output)(struct weston_output *output,
pixman_region32_t *output_damage);
void (*flush_damage)(struct weston_surface *surface);
void (*attach)(struct weston_surface *es, struct weston_buffer *buffer);
void (*surface_set_color)(struct weston_surface *surface,
float red, float green,
float blue, float alpha);
void (*destroy)(struct weston_compositor *ec);
/** See weston_surface_get_content_size() */
void (*surface_get_content_size)(struct weston_surface *surface,
int *width, int *height);
/** See weston_surface_copy_content() */
int (*surface_copy_content)(struct weston_surface *surface,
void *target, size_t size,
int src_x, int src_y,
int width, int height);
/** See weston_compositor_import_dmabuf() */
bool (*import_dmabuf)(struct weston_compositor *ec,
struct linux_dmabuf_buffer *buffer);
/** On error sets num_formats to zero */
void (*query_dmabuf_formats)(struct weston_compositor *ec,
int **formats, int *num_formats);
/** On error sets num_modifiers to zero */
void (*query_dmabuf_modifiers)(struct weston_compositor *ec,
int format, uint64_t **modifiers,
int *num_modifiers);
};
enum weston_capability {
/* backend/renderer supports arbitrary rotation */
WESTON_CAP_ROTATION_ANY = 0x0001,
/* screencaptures need to be y-flipped */
WESTON_CAP_CAPTURE_YFLIP = 0x0002,
/* backend/renderer has a separate cursor plane */
WESTON_CAP_CURSOR_PLANE = 0x0004,
/* backend supports setting arbitrary resolutions */
WESTON_CAP_ARBITRARY_MODES = 0x0008,
/* renderer supports weston_view_set_mask() clipping */
WESTON_CAP_VIEW_CLIP_MASK = 0x0010,
};
/* Configuration struct for a backend.
*
* This struct carries the configuration for a backend, and it's
* passed to the backend's init entry point. The backend will
* likely want to subclass this in order to handle backend specific
* data.
*
* NOTE: Alternate designs were proposed (Feb 2016) for using opaque
* structures[1] and for section+key/value getter/setters[2]. The rationale
* for selecting the transparent structure design is based on several
* assumptions[3] which may require re-evaluating the design choice if they
* fail to hold.
*
* 1: https://lists.freedesktop.org/archives/wayland-devel/2016-February/026989.html
* 2: https://lists.freedesktop.org/archives/wayland-devel/2016-February/026929.html
* 3: https://lists.freedesktop.org/archives/wayland-devel/2016-February/027228.html
*/
struct weston_backend_config {
/** Major version for the backend-specific config struct
*
* This version must match exactly what the backend expects, otherwise
* the struct is incompatible.
*/
uint32_t struct_version;
/** Minor version of the backend-specific config struct
*
* This must be set to sizeof(struct backend-specific config).
* If the value here is smaller than what the backend expects, the
* extra config members will assume their default values.
*
* A value greater than what the backend expects is incompatible.
*/
size_t struct_size;
};
struct weston_backend {
void (*destroy)(struct weston_compositor *compositor);
/** Begin a repaint sequence
*
* Provides the backend with explicit markers around repaint
* sequences, which may allow the backend to aggregate state
* application. This call will be bracketed by the repaint_flush (on
* success), or repaint_cancel (when any output in the grouping fails
* repaint).
*
* Returns an opaque pointer, which the backend may use as private
* data referring to the repaint cycle.
*/
void * (*repaint_begin)(struct weston_compositor *compositor);
/** Cancel a repaint sequence
*
* Cancels a repaint sequence, when an error has occurred during
* one output's repaint; see repaint_begin.
*
* @param repaint_data Data returned by repaint_begin
*/
void (*repaint_cancel)(struct weston_compositor *compositor,
void *repaint_data);
/** Conclude a repaint sequence
*
* Called on successful completion of a repaint sequence; see
* repaint_begin.
*
* @param repaint_data Data returned by repaint_begin
*/
void (*repaint_flush)(struct weston_compositor *compositor,
void *repaint_data);
/** Allocate a new output
*
* @param compositor The compositor.
* @param name Name for the new output.
*
* Allocates a new output structure that embeds a weston_output,
* initializes it, and returns the pointer to the weston_output
* member.
*
* Must set weston_output members @c destroy, @c enable and @c disable.
*/
struct weston_output *
(*create_output)(struct weston_compositor *compositor,
const char *name);
};
/** Callback for saving calibration
*
* \param compositor The compositor.
* \param device The physical touch device to save for.
* \param calibration The new calibration from a client.
* \return -1 on failure, 0 on success.
*
* Failure will prevent taking the new calibration into use.
*/
typedef int (*weston_touch_calibration_save_func)(
struct weston_compositor *compositor,
struct weston_touch_device *device,
const struct weston_touch_device_matrix *calibration);
struct weston_touch_calibrator;
struct weston_desktop_xwayland;
struct weston_desktop_xwayland_interface;
struct weston_compositor {
struct wl_signal destroy_signal;
struct wl_display *wl_display;
struct weston_desktop_xwayland *xwayland;
const struct weston_desktop_xwayland_interface *xwayland_interface;
/* surface signals */
struct wl_signal create_surface_signal;
struct wl_signal activate_signal;
struct wl_signal transform_signal;
struct wl_signal kill_signal;
struct wl_signal idle_signal;
struct wl_signal wake_signal;
struct wl_signal show_input_panel_signal;
struct wl_signal hide_input_panel_signal;
struct wl_signal update_input_panel_signal;
struct wl_signal seat_created_signal;
struct wl_signal output_created_signal;
struct wl_signal output_destroyed_signal;
struct wl_signal output_moved_signal;
struct wl_signal output_resized_signal; /* callback argument: resized output */
/* Signal for output changes triggered by configuration from frontend
* or head state changes from backend.
*/
struct wl_signal output_heads_changed_signal; /* arg: weston_output */
struct wl_signal session_signal;
int session_active;
struct weston_layer fade_layer;
struct weston_layer cursor_layer;
struct wl_list pending_output_list;
struct wl_list output_list;
struct wl_list head_list; /* struct weston_head::compositor_link */
struct wl_list seat_list;
struct wl_list layer_list; /* struct weston_layer::link */
struct wl_list view_list; /* struct weston_view::link */
struct wl_list plane_list;
struct wl_list key_binding_list;
struct wl_list modifier_binding_list;
struct wl_list button_binding_list;
struct wl_list touch_binding_list;
struct wl_list axis_binding_list;
struct wl_list debug_binding_list;
uint32_t state;
struct wl_event_source *idle_source;
uint32_t idle_inhibit;
int idle_time; /* timeout, s */
struct wl_event_source *repaint_timer;
const struct weston_pointer_grab_interface *default_pointer_grab;
/* Repaint state. */
struct weston_plane primary_plane;
uint32_t capabilities; /* combination of enum weston_capability */
struct weston_renderer *renderer;
pixman_format_code_t read_format;
struct weston_backend *backend;
struct weston_launcher *launcher;
struct wl_list plugin_api_list; /* struct weston_plugin_api::link */
uint32_t output_id_pool;
struct xkb_rule_names xkb_names;
struct xkb_context *xkb_context;
struct weston_xkb_info *xkb_info;
int32_t kb_repeat_rate;
int32_t kb_repeat_delay;
bool vt_switching;
clockid_t presentation_clock;
int32_t repaint_msec;
unsigned int activate_serial;
struct wl_global *pointer_constraints;
int exit_code;
void *user_data;
void (*exit)(struct weston_compositor *c);
/* Whether to let the compositor run without any input device. */
bool require_input;
/* Signal for a backend to inform a frontend about possible changes
* in head status.
*/
struct wl_signal heads_changed_signal;
struct wl_event_source *heads_changed_source;
/* Touchscreen calibrator support: */
enum weston_touch_mode touch_mode;
struct wl_global *touch_calibration;
weston_touch_calibration_save_func touch_calibration_save;
struct weston_layer calibrator_layer;
struct weston_touch_calibrator *touch_calibrator;
};
struct weston_buffer {
struct wl_resource *resource;
struct wl_signal destroy_signal;
struct wl_listener destroy_listener;
union {
struct wl_shm_buffer *shm_buffer;
void *legacy_buffer;
};
int32_t width, height;
uint32_t busy_count;
int y_inverted;
};
struct weston_buffer_reference {
struct weston_buffer *buffer;
struct wl_listener destroy_listener;
};
struct weston_buffer_viewport {
struct {
/* wl_surface.set_buffer_transform */
uint32_t transform;
/* wl_surface.set_scaling_factor */
int32_t scale;
/*
* If src_width != wl_fixed_from_int(-1),
* then and only then src_* are used.
*/
wl_fixed_t src_x, src_y;
wl_fixed_t src_width, src_height;
} buffer;
struct {
/*
* If width == -1, the size is inferred from the buffer.
*/
int32_t width, height;
} surface;
int changed;
};
struct weston_region {
struct wl_resource *resource;
pixman_region32_t region;
};
/* Using weston_view transformations
*
* To add a transformation to a view, create a struct weston_transform, and
* add it to the list view->geometry.transformation_list. Whenever you
* change the list, anything under view->geometry, or anything in the
* weston_transforms linked into the list, you must call
* weston_view_geometry_dirty().
*
* The order in the list defines the order of transformations. Let the list
* contain the transformation matrices M1, ..., Mn as head to tail. The
* transformation is applied to view-local coordinate vector p as
* P = Mn * ... * M2 * M1 * p
* to produce the global coordinate vector P. The total transform
* Mn * ... * M2 * M1
* is cached in view->transform.matrix, and the inverse of it in
* view->transform.inverse.
*
* The list always contains view->transform.position transformation, which
* is the translation by view->geometry.x and y.
*
* If you want to apply a transformation in local coordinates, add your
* weston_transform to the head of the list. If you want to apply a
* transformation in global coordinates, add it to the tail of the list.
*
* If view->geometry.parent is set, the total transformation of this
* view will be the parent's total transformation and this transformation
* combined:
* Mparent * Mn * ... * M2 * M1
*/
struct weston_view {
struct weston_surface *surface;
struct wl_list surface_link;
struct wl_signal destroy_signal;
struct wl_list link; /* weston_compositor::view_list */
struct weston_layer_entry layer_link; /* part of geometry */
struct weston_plane *plane;
/* For weston_layer inheritance from another view */
struct weston_view *parent_view;
unsigned int click_to_activate_serial;
pixman_region32_t clip; /* See weston_view_damage_below() */
float alpha; /* part of geometry, see below */
void *renderer_state;
/* Surface geometry state, mutable.
* If you change anything, call weston_surface_geometry_dirty().
* That includes the transformations referenced from the list.
*/
struct {
float x, y; /* surface translation on display */
/* struct weston_transform */
struct wl_list transformation_list;
/* managed by weston_surface_set_transform_parent() */
struct weston_view *parent;
struct wl_listener parent_destroy_listener;
struct wl_list child_list; /* geometry.parent_link */
struct wl_list parent_link;
/* managed by weston_view_set_mask() */
bool scissor_enabled;
pixman_region32_t scissor; /* always a simple rect */
} geometry;
/* State derived from geometry state, read-only.
* This is updated by weston_view_update_transform().
*/
struct {
int dirty;
/* Approximations in global coordinates:
* - boundingbox is guaranteed to include the whole view in
* the smallest possible single rectangle.
* - opaque is guaranteed to be fully opaque, though not
* necessarily include all opaque areas.
*/
pixman_region32_t boundingbox;
pixman_region32_t opaque;
/* matrix and inverse are used only if enabled = 1.
* If enabled = 0, use x, y, width, height directly.
*/
int enabled;
struct weston_matrix matrix;
struct weston_matrix inverse;
struct weston_transform position; /* matrix from x, y */
} transform;
/*
* The primary output for this view.
* Used for picking the output for driving internal animations on the
* view, inheriting the primary output for related views in shells, etc.
*/
struct weston_output *output;
struct wl_listener output_destroy_listener;
/*
* A more complete representation of all outputs this surface is
* displayed on.
*/
uint32_t output_mask;
/* Per-surface Presentation feedback flags, controlled by backend. */
uint32_t psf_flags;
bool is_mapped;
};
struct weston_surface_state {
/* wl_surface.attach */
int newly_attached;
struct weston_buffer *buffer;
struct wl_listener buffer_destroy_listener;
int32_t sx;
int32_t sy;
/* wl_surface.damage */
pixman_region32_t damage_surface;
/* wl_surface.damage_buffer */
pixman_region32_t damage_buffer;
/* wl_surface.set_opaque_region */
pixman_region32_t opaque;
/* wl_surface.set_input_region */
pixman_region32_t input;
/* wl_surface.frame */
struct wl_list frame_callback_list;
/* presentation.feedback */
struct wl_list feedback_list;
/* wl_surface.set_buffer_transform */
/* wl_surface.set_scaling_factor */
/* wp_viewport.set_source */
/* wp_viewport.set_destination */
struct weston_buffer_viewport buffer_viewport;
};
struct weston_surface_activation_data {
struct weston_surface *surface;
struct weston_seat *seat;
};
struct weston_pointer_constraint {
struct wl_list link;
struct weston_surface *surface;
struct weston_view *view;
struct wl_resource *resource;
struct weston_pointer_grab grab;
struct weston_pointer *pointer;
uint32_t lifetime;
pixman_region32_t region;
pixman_region32_t region_pending;
bool region_is_pending;
wl_fixed_t hint_x;
wl_fixed_t hint_y;
wl_fixed_t hint_x_pending;
wl_fixed_t hint_y_pending;
bool hint_is_pending;
struct wl_listener pointer_destroy_listener;
struct wl_listener surface_destroy_listener;
struct wl_listener surface_commit_listener;
struct wl_listener surface_activate_listener;
};
struct weston_surface {
struct wl_resource *resource;
struct wl_signal destroy_signal; /* callback argument: this surface */
struct weston_compositor *compositor;
struct wl_signal commit_signal;
/** Damage in local coordinates from the client, for tex upload. */
pixman_region32_t damage;
pixman_region32_t opaque; /* part of geometry, see below */
pixman_region32_t input;
int32_t width, height;
int32_t ref_count;
/* Not for long-term storage. This exists for book-keeping while
* iterating over surfaces and views
*/
bool touched;
void *renderer_state;
struct wl_list views;
/*
* Which output to vsync this surface to.
* Used to determine whether to send or queue frame events, and for
* other client-visible syncing/throttling tied to the output
* repaint cycle.
*/
struct weston_output *output;
/*
* A more complete representation of all outputs this surface is
* displayed on.
*/
uint32_t output_mask;
struct wl_list frame_callback_list;
struct wl_list feedback_list;
struct weston_buffer_reference buffer_ref;
struct weston_buffer_viewport buffer_viewport;
int32_t width_from_buffer; /* before applying viewport */
int32_t height_from_buffer;
bool keep_buffer; /* for backends to prevent early release */
/* wp_viewport resource for this surface */
struct wl_resource *viewport_resource;
/* All the pending state, that wl_surface.commit will apply. */
struct weston_surface_state pending;
/* Matrices representating of the full transformation between
* buffer and surface coordinates. These matrices are updated
* using the weston_surface_build_buffer_matrix function. */
struct weston_matrix buffer_to_surface_matrix;
struct weston_matrix surface_to_buffer_matrix;
/*
* If non-NULL, this function will be called on
* wl_surface::commit after a new buffer has been set up for
* this surface. The integer params are the sx and sy
* parameters supplied to wl_surface::attach.
*/
void (*committed)(struct weston_surface *es, int32_t sx, int32_t sy);
void *committed_private;
int (*get_label)(struct weston_surface *surface, char *buf, size_t len);
/* Parent's list of its sub-surfaces, weston_subsurface:parent_link.
* Contains also the parent itself as a dummy weston_subsurface,
* if the list is not empty.
*/
struct wl_list subsurface_list; /* weston_subsurface::parent_link */
struct wl_list subsurface_list_pending; /* ...::parent_link_pending */
/*
* For tracking protocol role assignments. Different roles may
* have the same configure hook, e.g. in shell.c. Configure hook
* may get reset, this will not.
* XXX: map configure functions 1:1 to roles, and never reset it,
* and replace role_name with configure.
*/
const char *role_name;
struct weston_timeline_object timeline;
bool is_mapped;
/* An list of per seat pointer constraints. */
struct wl_list pointer_constraints;
};
struct weston_subsurface {
struct wl_resource *resource;
/* guaranteed to be valid and non-NULL */
struct weston_surface *surface;
struct wl_listener surface_destroy_listener;
/* can be NULL */
struct weston_surface *parent;
struct wl_listener parent_destroy_listener;
struct wl_list parent_link;
struct wl_list parent_link_pending;
struct {
int32_t x;
int32_t y;
int set;
} position;
int has_cached_data;
struct weston_surface_state cached;
struct weston_buffer_reference cached_buffer_ref;
/* Sub-surface has been reordered; need to apply damage. */
bool reordered;
int synchronized;
/* Used for constructing the view tree */
struct wl_list unused_views;
};
enum weston_key_state_update {
STATE_UPDATE_AUTOMATIC,
STATE_UPDATE_NONE,
};
enum weston_activate_flag {
WESTON_ACTIVATE_FLAG_NONE = 0,
WESTON_ACTIVATE_FLAG_CONFIGURE = 1 << 0,
WESTON_ACTIVATE_FLAG_CLICKED = 1 << 1,
};
void
weston_version(int *major, int *minor, int *micro);
void
weston_view_set_output(struct weston_view *view, struct weston_output *output);
void
weston_view_update_transform(struct weston_view *view);
void
weston_view_geometry_dirty(struct weston_view *view);
void
weston_view_to_global_fixed(struct weston_view *view,
wl_fixed_t sx, wl_fixed_t sy,
wl_fixed_t *x, wl_fixed_t *y);
void
weston_view_to_global_float(struct weston_view *view,
float sx, float sy, float *x, float *y);
void
weston_view_from_global_float(struct weston_view *view,
float x, float y, float *vx, float *vy);
void
weston_view_from_global(struct weston_view *view,
int32_t x, int32_t y, int32_t *vx, int32_t *vy);
void
weston_view_from_global_fixed(struct weston_view *view,
wl_fixed_t x, wl_fixed_t y,
wl_fixed_t *vx, wl_fixed_t *vy);
void
weston_surface_to_buffer_float(struct weston_surface *surface,
float x, float y, float *bx, float *by);
pixman_box32_t
weston_surface_to_buffer_rect(struct weston_surface *surface,
pixman_box32_t rect);
void
weston_surface_to_buffer_region(struct weston_surface *surface,
pixman_region32_t *surface_region,
pixman_region32_t *buffer_region);
void
weston_spring_init(struct weston_spring *spring,
double k, double current, double target);
void
weston_spring_update(struct weston_spring *spring, const struct timespec *time);
int
weston_spring_done(struct weston_spring *spring);
void
weston_view_activate(struct weston_view *view,
struct weston_seat *seat,
uint32_t flags);
void
notify_motion(struct weston_seat *seat, const struct timespec *time,
struct weston_pointer_motion_event *event);
void
notify_motion_absolute(struct weston_seat *seat, const struct timespec *time,
double x, double y);
void
notify_button(struct weston_seat *seat, const struct timespec *time,
int32_t button, enum wl_pointer_button_state state);
void
notify_axis(struct weston_seat *seat, const struct timespec *time,
struct weston_pointer_axis_event *event);
void
notify_axis_source(struct weston_seat *seat, uint32_t source);
void
notify_pointer_frame(struct weston_seat *seat);
void
notify_key(struct weston_seat *seat, const struct timespec *time, uint32_t key,
enum wl_keyboard_key_state state,
enum weston_key_state_update update_state);
void
notify_modifiers(struct weston_seat *seat, uint32_t serial);
void
notify_pointer_focus(struct weston_seat *seat, struct weston_output *output,
double x, double y);
void
notify_keyboard_focus_in(struct weston_seat *seat, struct wl_array *keys,
enum weston_key_state_update update_state);
void
notify_keyboard_focus_out(struct weston_seat *seat);
void
notify_touch_normalized(struct weston_touch_device *device,
const struct timespec *time,
int touch_id,
double x, double y,
const struct weston_point2d_device_normalized *norm,
int touch_type);
/** Feed in touch down, motion, and up events, non-calibratable device.
*
* @sa notify_touch_cal
*/
static inline void
notify_touch(struct weston_touch_device *device, const struct timespec *time,
int touch_id, double x, double y, int touch_type)
{
notify_touch_normalized(device, time, touch_id, x, y, NULL, touch_type);
}
void
notify_touch_frame(struct weston_touch_device *device);
void
notify_touch_cancel(struct weston_touch_device *device);
void
weston_compositor_set_touch_mode_normal(struct weston_compositor *compositor);
void
weston_compositor_set_touch_mode_calib(struct weston_compositor *compositor);
void
touch_calibrator_mode_changed(struct weston_compositor *compositor);
void
notify_touch_calibrator(struct weston_touch_device *device,
const struct timespec *time, int32_t slot,
const struct weston_point2d_device_normalized *norm,
int touch_type);
void
notify_touch_calibrator_frame(struct weston_touch_device *device);
void
notify_touch_calibrator_cancel(struct weston_touch_device *device);
void
weston_layer_entry_insert(struct weston_layer_entry *list,
struct weston_layer_entry *entry);
void
weston_layer_entry_remove(struct weston_layer_entry *entry);
void
weston_layer_init(struct weston_layer *layer,
struct weston_compositor *compositor);
void
weston_layer_set_position(struct weston_layer *layer,
enum weston_layer_position position);
void
weston_layer_unset_position(struct weston_layer *layer);
void
weston_layer_set_mask(struct weston_layer *layer, int x, int y, int width, int height);
void
weston_layer_set_mask_infinite(struct weston_layer *layer);
void
weston_plane_init(struct weston_plane *plane,
struct weston_compositor *ec,
int32_t x, int32_t y);
void
weston_plane_release(struct weston_plane *plane);
void
weston_compositor_stack_plane(struct weston_compositor *ec,
struct weston_plane *plane,
struct weston_plane *above);
/* An invalid flag in presented_flags to catch logic errors. */
#define WP_PRESENTATION_FEEDBACK_INVALID (1U << 31)
void
weston_output_finish_frame(struct weston_output *output,
const struct timespec *stamp,
uint32_t presented_flags);
void
weston_output_schedule_repaint(struct weston_output *output);
void
weston_output_damage(struct weston_output *output);
void
weston_compositor_schedule_repaint(struct weston_compositor *compositor);
void
weston_compositor_fade(struct weston_compositor *compositor, float tint);
void
weston_compositor_damage_all(struct weston_compositor *compositor);
void
weston_compositor_unlock(struct weston_compositor *compositor);
void
weston_compositor_wake(struct weston_compositor *compositor);
void
weston_compositor_offscreen(struct weston_compositor *compositor);
void
weston_compositor_sleep(struct weston_compositor *compositor);
struct weston_view *
weston_compositor_pick_view(struct weston_compositor *compositor,
wl_fixed_t x, wl_fixed_t y,
wl_fixed_t *sx, wl_fixed_t *sy);
struct weston_binding;
typedef void (*weston_key_binding_handler_t)(struct weston_keyboard *keyboard,
const struct timespec *time,
uint32_t key,
void *data);
struct weston_binding *
weston_compositor_add_key_binding(struct weston_compositor *compositor,
uint32_t key,
enum weston_keyboard_modifier modifier,
weston_key_binding_handler_t binding,
void *data);
typedef void (*weston_modifier_binding_handler_t)(struct weston_keyboard *keyboard,
enum weston_keyboard_modifier modifier,
void *data);
struct weston_binding *
weston_compositor_add_modifier_binding(struct weston_compositor *compositor,
enum weston_keyboard_modifier modifier,
weston_modifier_binding_handler_t binding,
void *data);
typedef void (*weston_button_binding_handler_t)(struct weston_pointer *pointer,
const struct timespec *time,
uint32_t button,
void *data);
struct weston_binding *
weston_compositor_add_button_binding(struct weston_compositor *compositor,
uint32_t button,
enum weston_keyboard_modifier modifier,
weston_button_binding_handler_t binding,
void *data);
typedef void (*weston_touch_binding_handler_t)(struct weston_touch *touch,
const struct timespec *time,
void *data);
struct weston_binding *
weston_compositor_add_touch_binding(struct weston_compositor *compositor,
enum weston_keyboard_modifier modifier,
weston_touch_binding_handler_t binding,
void *data);
typedef void (*weston_axis_binding_handler_t)(struct weston_pointer *pointer,
const struct timespec *time,
struct weston_pointer_axis_event *event,
void *data);
struct weston_binding *
weston_compositor_add_axis_binding(struct weston_compositor *compositor,
uint32_t axis,
enum weston_keyboard_modifier modifier,
weston_axis_binding_handler_t binding,
void *data);
struct weston_binding *
weston_compositor_add_debug_binding(struct weston_compositor *compositor,
uint32_t key,
weston_key_binding_handler_t binding,
void *data);
void
weston_binding_destroy(struct weston_binding *binding);
void
weston_install_debug_key_binding(struct weston_compositor *compositor,
uint32_t mod);
void
weston_binding_list_destroy_all(struct wl_list *list);
void
weston_compositor_run_key_binding(struct weston_compositor *compositor,
struct weston_keyboard *keyboard,
const struct timespec *time,
uint32_t key,
enum wl_keyboard_key_state state);
void
weston_compositor_run_modifier_binding(struct weston_compositor *compositor,
struct weston_keyboard *keyboard,
enum weston_keyboard_modifier modifier,
enum wl_keyboard_key_state state);
void
weston_compositor_run_button_binding(struct weston_compositor *compositor,
struct weston_pointer *pointer,
const struct timespec *time,
uint32_t button,
enum wl_pointer_button_state value);
void
weston_compositor_run_touch_binding(struct weston_compositor *compositor,
struct weston_touch *touch,
const struct timespec *time,
int touch_type);
int
weston_compositor_run_axis_binding(struct weston_compositor *compositor,
struct weston_pointer *pointer,
const struct timespec *time,
struct weston_pointer_axis_event *event);
int
weston_compositor_run_debug_binding(struct weston_compositor *compositor,
struct weston_keyboard *keyboard,
const struct timespec *time,
uint32_t key,
enum wl_keyboard_key_state state);
void
weston_compositor_set_default_pointer_grab(struct weston_compositor *compositor,
const struct weston_pointer_grab_interface *interface);
int
weston_environment_get_fd(const char *env);
struct weston_surface *
weston_surface_create(struct weston_compositor *compositor);
struct weston_view *
weston_view_create(struct weston_surface *surface);
void
weston_view_destroy(struct weston_view *view);
void
weston_view_set_position(struct weston_view *view,
float x, float y);
void
weston_view_set_transform_parent(struct weston_view *view,
struct weston_view *parent);
void
weston_view_set_mask(struct weston_view *view,
int x, int y, int width, int height);
void
weston_view_set_mask_infinite(struct weston_view *view);
bool
weston_view_is_mapped(struct weston_view *view);
void
weston_view_schedule_repaint(struct weston_view *view);
bool
weston_surface_is_mapped(struct weston_surface *surface);
void
weston_surface_set_size(struct weston_surface *surface,
int32_t width, int32_t height);
void
weston_surface_schedule_repaint(struct weston_surface *surface);
void
weston_surface_damage(struct weston_surface *surface);
void
weston_view_damage_below(struct weston_view *view);
void
weston_view_move_to_plane(struct weston_view *view,
struct weston_plane *plane);
void
weston_view_unmap(struct weston_view *view);
void
weston_surface_unmap(struct weston_surface *surface);
struct weston_surface *
weston_surface_get_main_surface(struct weston_surface *surface);
int
weston_surface_set_role(struct weston_surface *surface,
const char *role_name,
struct wl_resource *error_resource,
uint32_t error_code);
const char *
weston_surface_get_role(struct weston_surface *surface);
void
weston_surface_set_label_func(struct weston_surface *surface,
int (*desc)(struct weston_surface *,
char *, size_t));
void
weston_surface_get_content_size(struct weston_surface *surface,
int *width, int *height);
struct weston_geometry
weston_surface_get_bounding_box(struct weston_surface *surface);
int
weston_surface_copy_content(struct weston_surface *surface,
void *target, size_t size,
int src_x, int src_y,
int width, int height);
struct weston_buffer *
weston_buffer_from_resource(struct wl_resource *resource);
void
weston_buffer_reference(struct weston_buffer_reference *ref,
struct weston_buffer *buffer);
void
weston_compositor_get_time(struct timespec *time);
void
weston_compositor_destroy(struct weston_compositor *ec);
struct weston_compositor *
weston_compositor_create(struct wl_display *display, void *user_data);
enum weston_compositor_backend {
WESTON_BACKEND_DRM,
WESTON_BACKEND_FBDEV,
WESTON_BACKEND_HEADLESS,
WESTON_BACKEND_RDP,
WESTON_BACKEND_WAYLAND,
WESTON_BACKEND_X11,
};
int
weston_compositor_load_backend(struct weston_compositor *compositor,
enum weston_compositor_backend backend,
struct weston_backend_config *config_base);
void
weston_compositor_exit(struct weston_compositor *ec);
void *
weston_compositor_get_user_data(struct weston_compositor *compositor);
int
weston_compositor_set_presentation_clock(struct weston_compositor *compositor,
clockid_t clk_id);
int
weston_compositor_set_presentation_clock_software(
struct weston_compositor *compositor);
void
weston_compositor_read_presentation_clock(
const struct weston_compositor *compositor,
struct timespec *ts);
bool
weston_compositor_import_dmabuf(struct weston_compositor *compositor,
struct linux_dmabuf_buffer *buffer);
void
weston_compositor_shutdown(struct weston_compositor *ec);
void
weston_compositor_exit_with_code(struct weston_compositor *compositor,
int exit_code);
void
weston_output_init_zoom(struct weston_output *output);
void
weston_output_update_zoom(struct weston_output *output);
void
weston_output_activate_zoom(struct weston_output *output,
struct weston_seat *seat);
void
weston_output_move(struct weston_output *output, int x, int y);
void
weston_output_add_destroy_listener(struct weston_output *output,
struct wl_listener *listener);
struct wl_listener *
weston_output_get_destroy_listener(struct weston_output *output,
wl_notify_func_t notify);
void
weston_output_release(struct weston_output *output);
void
weston_output_transform_coordinate(struct weston_output *output,
double device_x, double device_y,
double *x, double *y);
void
weston_seat_init(struct weston_seat *seat, struct weston_compositor *ec,
const char *seat_name);
void
weston_seat_init_pointer(struct weston_seat *seat);
void
weston_seat_release_pointer(struct weston_seat *seat);
int
weston_seat_init_keyboard(struct weston_seat *seat, struct xkb_keymap *keymap);
void
weston_seat_release_keyboard(struct weston_seat *seat);
void
weston_seat_init_touch(struct weston_seat *seat);
void
weston_seat_release_touch(struct weston_seat *seat);
void
weston_seat_repick(struct weston_seat *seat);
void
weston_seat_update_keymap(struct weston_seat *seat, struct xkb_keymap *keymap);
void
weston_seat_release(struct weston_seat *seat);
int
weston_compositor_set_xkb_rule_names(struct weston_compositor *ec,
struct xkb_rule_names *names);
void
weston_compositor_xkb_destroy(struct weston_compositor *ec);
/* String literal of spaces, the same width as the timestamp. */
#define STAMP_SPACE " "
typedef int (*log_func_t)(const char *fmt, va_list ap);
void
weston_log_set_handler(log_func_t log, log_func_t cont);
int
weston_vlog(const char *fmt, va_list ap);
int
weston_vlog_continue(const char *fmt, va_list ap);
int
weston_log(const char *fmt, ...)
__attribute__ ((format (printf, 1, 2)));
int
weston_log_continue(const char *fmt, ...)
__attribute__ ((format (printf, 1, 2)));
enum {
TTY_ENTER_VT,
TTY_LEAVE_VT
};
struct tty *
tty_create(struct weston_compositor *compositor, int tty_nr);
void
tty_destroy(struct tty *tty);
void
tty_reset(struct tty *tty);
int
tty_activate_vt(struct tty *tty, int vt);
enum weston_screenshooter_outcome {
WESTON_SCREENSHOOTER_SUCCESS,
WESTON_SCREENSHOOTER_NO_MEMORY,
WESTON_SCREENSHOOTER_BAD_BUFFER
};
typedef void (*weston_screenshooter_done_func_t)(void *data,
enum weston_screenshooter_outcome outcome);
int
weston_screenshooter_shoot(struct weston_output *output, struct weston_buffer *buffer,
weston_screenshooter_done_func_t done, void *data);
struct weston_recorder *
weston_recorder_start(struct weston_output *output, const char *filename);
void
weston_recorder_stop(struct weston_recorder *recorder);
struct clipboard *
clipboard_create(struct weston_seat *seat);
struct weston_view_animation;
typedef void (*weston_view_animation_done_func_t)(struct weston_view_animation *animation, void *data);
void
weston_view_animation_destroy(struct weston_view_animation *animation);
struct weston_view_animation *
weston_zoom_run(struct weston_view *view, float start, float stop,
weston_view_animation_done_func_t done, void *data);
struct weston_view_animation *
weston_fade_run(struct weston_view *view,
float start, float end, float k,
weston_view_animation_done_func_t done, void *data);
struct weston_view_animation *
weston_move_scale_run(struct weston_view *view, int dx, int dy,
float start, float end, bool reverse,
weston_view_animation_done_func_t done, void *data);
struct weston_view_animation *
weston_move_run(struct weston_view *view, int dx, int dy,
float start, float end, bool reverse,
weston_view_animation_done_func_t done, void *data);
void
weston_fade_update(struct weston_view_animation *fade, float target);
struct weston_view_animation *
weston_stable_fade_run(struct weston_view *front_view, float start,
struct weston_view *back_view, float end,
weston_view_animation_done_func_t done, void *data);
struct weston_view_animation *
weston_slide_run(struct weston_view *view, float start, float stop,
weston_view_animation_done_func_t done, void *data);
void
weston_surface_set_color(struct weston_surface *surface,
float red, float green, float blue, float alpha);
void
weston_surface_destroy(struct weston_surface *surface);
int
weston_output_mode_set_native(struct weston_output *output,
struct weston_mode *mode,
int32_t scale);
int
weston_output_mode_switch_to_temporary(struct weston_output *output,
struct weston_mode *mode,
int32_t scale);
int
weston_output_mode_switch_to_native(struct weston_output *output);
int
noop_renderer_init(struct weston_compositor *ec);
int
weston_input_init(struct weston_compositor *compositor);
int
weston_backend_init(struct weston_compositor *c,
struct weston_backend_config *config_base);
int
weston_module_init(struct weston_compositor *compositor);
void
weston_transformed_coord(int width, int height,
enum wl_output_transform transform,
int32_t scale,
float sx, float sy, float *bx, float *by);
pixman_box32_t
weston_transformed_rect(int width, int height,
enum wl_output_transform transform,
int32_t scale,
pixman_box32_t rect);
void
weston_matrix_transform_region(pixman_region32_t *dest,
struct weston_matrix *matrix,
pixman_region32_t *src);
void
weston_transformed_region(int width, int height,
enum wl_output_transform transform,
int32_t scale,
pixman_region32_t *src, pixman_region32_t *dest);
void *
weston_load_module(const char *name, const char *entrypoint);
size_t
weston_module_path_from_env(const char *name, char *path, size_t path_len);
int
weston_parse_transform(const char *transform, uint32_t *out);
const char *
weston_transform_to_string(uint32_t output_transform);
struct weston_keyboard *
weston_seat_get_keyboard(struct weston_seat *seat);
struct weston_pointer *
weston_seat_get_pointer(struct weston_seat *seat);
struct weston_touch *
weston_seat_get_touch(struct weston_seat *seat);
void
weston_seat_set_keyboard_focus(struct weston_seat *seat,
struct weston_surface *surface);
void
weston_keyboard_send_keymap(struct weston_keyboard *kbd,
struct wl_resource *resource);
int
weston_compositor_load_xwayland(struct weston_compositor *compositor);
void
weston_head_init(struct weston_head *head, const char *name);
void
weston_head_release(struct weston_head *head);
void
weston_compositor_add_head(struct weston_compositor *compositor,
struct weston_head *head);
void
weston_head_set_monitor_strings(struct weston_head *head,
const char *make,
const char *model,
const char *serialno);
void
weston_head_set_physical_size(struct weston_head *head,
int32_t mm_width, int32_t mm_height);
void
weston_head_set_subpixel(struct weston_head *head,
enum wl_output_subpixel sp);
void
weston_head_set_connection_status(struct weston_head *head, bool connected);
void
weston_head_set_internal(struct weston_head *head);
bool
weston_head_is_connected(struct weston_head *head);
bool
weston_head_is_enabled(struct weston_head *head);
bool
weston_head_is_device_changed(struct weston_head *head);
void
weston_head_reset_device_changed(struct weston_head *head);
const char *
weston_head_get_name(struct weston_head *head);
struct weston_output *
weston_head_get_output(struct weston_head *head);
void
weston_head_detach(struct weston_head *head);
void
weston_head_add_destroy_listener(struct weston_head *head,
struct wl_listener *listener);
struct wl_listener *
weston_head_get_destroy_listener(struct weston_head *head,
wl_notify_func_t notify);
struct weston_head *
weston_compositor_iterate_heads(struct weston_compositor *compositor,
struct weston_head *iter);
void
weston_compositor_add_heads_changed_listener(struct weston_compositor *compositor,
struct wl_listener *listener);
struct weston_output *
weston_compositor_find_output_by_name(struct weston_compositor *compositor,
const char *name);
struct weston_output *
weston_compositor_create_output(struct weston_compositor *compositor,
const char *name);
struct weston_output *
weston_compositor_create_output_with_head(struct weston_compositor *compositor,
struct weston_head *head);
void
weston_output_destroy(struct weston_output *output);
int
weston_output_attach_head(struct weston_output *output,
struct weston_head *head);
struct weston_head *
weston_output_iterate_heads(struct weston_output *output,
struct weston_head *iter);
void
weston_output_set_scale(struct weston_output *output,
int32_t scale);
void
weston_output_set_transform(struct weston_output *output,
uint32_t transform);
void
weston_output_init(struct weston_output *output,
struct weston_compositor *compositor,
const char *name);
void
weston_compositor_add_pending_output(struct weston_output *output,
struct weston_compositor *compositor);
int
weston_output_enable(struct weston_output *output);
void
weston_output_disable(struct weston_output *output);
void
weston_compositor_flush_heads_changed(struct weston_compositor *compositor);
struct weston_head *
weston_head_from_resource(struct wl_resource *resource);
struct weston_head *
weston_output_get_first_head(struct weston_output *output);
int
weston_compositor_enable_touch_calibrator(struct weston_compositor *compositor,
weston_touch_calibration_save_func save);
#ifdef __cplusplus
}
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink