#define XWL_WINDOW_BORDER (3)
/* For brevity's sake, struct members are annotated where they are used. */
-enum tinywl_cursor_mode {
+enum cursor_mode {
TINYWL_CURSOR_PASSTHROUGH,
TINYWL_CURSOR_MOVE,
TINYWL_CURSOR_RESIZE,
};
-struct tinywl_server {
+struct server {
struct wl_display *wl_display;
struct wlr_backend *backend;
struct wlr_renderer *renderer;
struct wl_listener new_input;
struct wl_listener request_cursor;
struct wl_list keyboards;
- enum tinywl_cursor_mode cursor_mode;
- struct tinywl_view *grabbed_view;
+ enum cursor_mode cursor_mode;
+ struct view *grabbed_view;
double grab_x, grab_y;
int grab_width, grab_height;
uint32_t resize_edges;
struct wl_listener new_output;
};
-struct tinywl_output {
+struct output {
struct wl_list link;
- struct tinywl_server *server;
+ struct server *server;
struct wlr_output *wlr_output;
struct wl_listener frame;
};
LAB_XWAYLAND_VIEW
};
-struct tinywl_view {
+struct view {
enum view_type type;
struct wl_list link;
- struct tinywl_server *server;
+ struct server *server;
struct wlr_xdg_surface *xdg_surface;
struct wlr_xwayland_surface *xwayland_surface;
struct wlr_surface *surface;
int x, y;
};
-struct tinywl_keyboard {
+struct keyboard {
struct wl_list link;
- struct tinywl_server *server;
+ struct server *server;
struct wlr_input_device *device;
struct wl_listener modifiers;
void xdg_toplevel_request_resize(struct wl_listener *listener, void *data);
void xdg_surface_new(struct wl_listener *listener, void *data);
-int xwl_nr_parents(struct tinywl_view *view);
+int xwl_nr_parents(struct view *view);
void xwl_surface_map(struct wl_listener *listener, void *data);
void xwl_surface_unmap(struct wl_listener *listener, void *data);
void xwl_surface_destroy(struct wl_listener *listener, void *data);
void xwl_surface_configure(struct wl_listener *listener, void *data);
void xwl_surface_new(struct wl_listener *listener, void *data);
-void focus_view(struct tinywl_view *view, struct wlr_surface *surface);
-void view_focus_next_toplevel(struct tinywl_server *server);
-void begin_interactive(struct tinywl_view *view, enum tinywl_cursor_mode mode, uint32_t edges);
-bool is_toplevel(struct tinywl_view *view);
-struct tinywl_view *desktop_view_at(struct tinywl_server *server, double lx, double ly,
+void focus_view(struct view *view, struct wlr_surface *surface);
+void view_focus_next_toplevel(struct server *server);
+void begin_interactive(struct view *view, enum cursor_mode mode, uint32_t edges);
+bool is_toplevel(struct view *view);
+struct view *desktop_view_at(struct server *server, double lx, double ly,
struct wlr_surface **surface, double *sx, double *sy);
/* TODO: try to refactor to remove from header file */
-struct tinywl_view *first_toplevel(struct tinywl_server *server);
+struct view *first_toplevel(struct server *server);
void server_cursor_motion(struct wl_listener *listener, void *data);
void server_cursor_motion_absolute(struct wl_listener *listener, void *data);
#include <wlr/types/wlr_gamma_control_v1.h>
#include <wlr/types/wlr_primary_selection_v1.h>
-static struct tinywl_view *last_toplevel(struct tinywl_server *server) {
- struct tinywl_view *view;
+static struct view *last_toplevel(struct server *server) {
+ struct view *view;
wl_list_for_each_reverse(view, &server->views, link) {
if (!view->been_mapped) {
return NULL;
}
-static void view_focus_last_toplevel(struct tinywl_server *server) {
+static void view_focus_last_toplevel(struct server *server) {
/* TODO: write view_nr_toplevel_views() */
if (wl_list_length(&server->views) < 2) {
return;
}
- struct tinywl_view *view = last_toplevel(server);
+ struct view *view = last_toplevel(server);
focus_view(view, view->surface);
}
struct wl_listener *listener, void *data) {
/* This event is raised when a modifier key, such as shift or alt, is
* pressed. We simply communicate this to the client. */
- struct tinywl_keyboard *keyboard =
+ struct keyboard *keyboard =
wl_container_of(listener, keyboard, modifiers);
/*
* A seat can only have one keyboard, but this is a limitation of the
&keyboard->device->keyboard->modifiers);
}
-static void xdg_debug_show_one_view(struct tinywl_view *view) {
+static void xdg_debug_show_one_view(struct view *view) {
fprintf(stderr, "XDG ");
switch (view->xdg_surface->role) {
case WLR_XDG_SURFACE_ROLE_NONE:
view->xdg_surface->geometry.width);
}
-static void xwl_debug_show_one_view(struct tinywl_view *view) {
+static void xwl_debug_show_one_view(struct view *view) {
fprintf(stderr, "XWL ");
if (!view->been_mapped) {
fprintf(stderr, "- ");
*/
}
-static void debug_show_one_view(struct tinywl_view *view) {
+static void debug_show_one_view(struct view *view) {
if (view->type == LAB_XDG_SHELL_VIEW)
xdg_debug_show_one_view(view);
else if (view->type == LAB_XWAYLAND_VIEW)
xwl_debug_show_one_view(view);
}
-static void debug_show_views(struct tinywl_server *server) {
- struct tinywl_view *view;
+static void debug_show_views(struct server *server) {
+ struct view *view;
fprintf(stderr, "---\n");
fprintf(stderr, "TYPE NR_PNT NR_CLD MAPPED VIEW-POINTER NAME\n");
debug_show_one_view(view);
}
-static bool handle_keybinding(struct tinywl_server *server, xkb_keysym_t sym) {
+static bool handle_keybinding(struct server *server, xkb_keysym_t sym) {
/*
* Here we handle compositor keybindings. This is when the compositor is
* processing keys, rather than passing them on to the client for its own
static void keyboard_handle_key(
struct wl_listener *listener, void *data) {
/* This event is raised when a key is pressed or released. */
- struct tinywl_keyboard *keyboard =
+ struct keyboard *keyboard =
wl_container_of(listener, keyboard, key);
- struct tinywl_server *server = keyboard->server;
+ struct server *server = keyboard->server;
struct wlr_event_keyboard_key *event = data;
struct wlr_seat *seat = server->seat;
}
}
-static void server_new_keyboard(struct tinywl_server *server,
+static void server_new_keyboard(struct server *server,
struct wlr_input_device *device) {
- struct tinywl_keyboard *keyboard =
- calloc(1, sizeof(struct tinywl_keyboard));
+ struct keyboard *keyboard =
+ calloc(1, sizeof(struct keyboard));
keyboard->server = server;
keyboard->device = device;
wl_list_insert(&server->keyboards, &keyboard->link);
}
-static void server_new_pointer(struct tinywl_server *server,
+static void server_new_pointer(struct server *server,
struct wlr_input_device *device) {
/* We don't do anything special with pointers. All of our pointer handling
* is proxied through wlr_cursor. On another compositor, you might take this
static void server_new_input(struct wl_listener *listener, void *data) {
/* This event is raised by the backend when a new input device becomes
* available. */
- struct tinywl_server *server =
+ struct server *server =
wl_container_of(listener, server, new_input);
struct wlr_input_device *device = data;
switch (device->type) {
}
static void seat_request_cursor(struct wl_listener *listener, void *data) {
- struct tinywl_server *server = wl_container_of(
+ struct server *server = wl_container_of(
listener, server, request_cursor);
/* This event is rasied by the seat when a client provides a cursor image */
struct wlr_seat_pointer_request_set_cursor_event *event = data;
return 0;
}
- struct tinywl_server server;
+ struct server server;
/* The Wayland display is managed by libwayland. It handles accepting
* clients from the Unix socket, manging Wayland globals, and so on. */
server.wl_display = wl_display_create();
struct render_data {
struct wlr_output *output;
struct wlr_renderer *renderer;
- struct tinywl_view *view;
+ struct view *view;
struct timespec *when;
};
-static void render_decorations(struct wlr_output *output, struct tinywl_view *view) {
+static void render_decorations(struct wlr_output *output, struct view *view) {
if (!view->surface)
return;
if (view->type != LAB_XWAYLAND_VIEW)
int sx, int sy, void *data) {
/* This function is called for every surface that needs to be rendered. */
struct render_data *rdata = data;
- struct tinywl_view *view = rdata->view;
+ struct view *view = rdata->view;
struct wlr_output *output = rdata->output;
/* We first obtain a wlr_texture, which is a GPU resource. wlroots
void output_frame(struct wl_listener *listener, void *data) {
/* This function is called every time an output is ready to display a frame,
* generally at the output's refresh rate (e.g. 60Hz). */
- struct tinywl_output *output =
+ struct output *output =
wl_container_of(listener, output, frame);
struct wlr_renderer *renderer = output->server->renderer;
/* Each subsequent window we render is rendered on top of the last. Because
* our view list is ordered front-to-back, we iterate over it backwards. */
- struct tinywl_view *view;
+ struct view *view;
wl_list_for_each_reverse(view, &output->server->views, link) {
if (!view->mapped) {
/* An unmapped view should not be rendered. */
#include "labwc.h"
-static void process_cursor_move(struct tinywl_server *server, uint32_t time)
+static void process_cursor_move(struct server *server, uint32_t time)
{
/* Move the grabbed view to the new position. */
server->grabbed_view->x = server->cursor->x - server->grab_x;
server->grabbed_view->y = server->cursor->y - server->grab_y;
}
-static void process_cursor_resize(struct tinywl_server *server, uint32_t time)
+static void process_cursor_resize(struct server *server, uint32_t time)
{
/*
* Resizing the grabbed view can be a little bit complicated, because we
* you'd wait for the client to prepare a buffer at the new size, then
* commit any movement that was prepared.
*/
- struct tinywl_view *view = server->grabbed_view;
+ struct view *view = server->grabbed_view;
double dx = server->cursor->x - server->grab_x;
double dy = server->cursor->y - server->grab_y;
double x = view->x;
wlr_xdg_toplevel_set_size(view->xdg_surface, width, height);
}
-static void process_cursor_motion(struct tinywl_server *server, uint32_t time)
+static void process_cursor_motion(struct server *server, uint32_t time)
{
/* If the mode is non-passthrough, delegate to those functions. */
if (server->cursor_mode == TINYWL_CURSOR_MOVE) {
double sx, sy;
struct wlr_seat *seat = server->seat;
struct wlr_surface *surface = NULL;
- struct tinywl_view *view = desktop_view_at(server,
+ struct view *view = desktop_view_at(server,
server->cursor->x, server->cursor->y, &surface, &sx, &sy);
if (!view) {
/* If there's no view under the cursor, set the cursor image to a
{
/* This event is forwarded by the cursor when a pointer emits a _relative_
* pointer motion event (i.e. a delta) */
- struct tinywl_server *server =
+ struct server *server =
wl_container_of(listener, server, cursor_motion);
struct wlr_event_pointer_motion *event = data;
/* The cursor doesn't move unless we tell it to. The cursor automatically
* move the mouse over the window. You could enter the window from any edge,
* so we have to warp the mouse there. There is also some hardware which
* emits these events. */
- struct tinywl_server *server =
+ struct server *server =
wl_container_of(listener, server, cursor_motion_absolute);
struct wlr_event_pointer_motion_absolute *event = data;
wlr_cursor_warp_absolute(server->cursor, event->device, event->x, event->y);
{
/* This event is forwarded by the cursor when a pointer emits a button
* event. */
- struct tinywl_server *server =
+ struct server *server =
wl_container_of(listener, server, cursor_button);
struct wlr_event_pointer_button *event = data;
/* Notify the client with pointer focus that a button press has occurred */
event->time_msec, event->button, event->state);
double sx, sy;
struct wlr_surface *surface;
- struct tinywl_view *view = desktop_view_at(server,
+ struct view *view = desktop_view_at(server,
server->cursor->x, server->cursor->y, &surface, &sx, &sy);
if (event->state == WLR_BUTTON_RELEASED) {
/* If you released any buttons, we exit interactive move/resize mode. */
void server_cursor_axis(struct wl_listener *listener, void *data) {
/* This event is forwarded by the cursor when a pointer emits an axis event,
* for example when you move the scroll wheel. */
- struct tinywl_server *server =
+ struct server *server =
wl_container_of(listener, server, cursor_axis);
struct wlr_event_pointer_axis *event = data;
/* Notify the client with pointer focus of the axis event. */
* event. Frame events are sent after regular pointer events to group
* multiple events together. For instance, two axis events may happen at the
* same time, in which case a frame event won't be sent in between. */
- struct tinywl_server *server =
+ struct server *server =
wl_container_of(listener, server, cursor_frame);
/* Notify the client with pointer focus of the frame event. */
wlr_seat_pointer_notify_frame(server->seat);
{
/* This event is rasied by the backend when a new output (aka a display or
* monitor) becomes available. */
- struct tinywl_server *server =
+ struct server *server =
wl_container_of(listener, server, new_output);
struct wlr_output *wlr_output = data;
}
/* Allocates and configures our state for this output */
- struct tinywl_output *output =
- calloc(1, sizeof(struct tinywl_output));
+ struct output *output =
+ calloc(1, sizeof(struct output));
output->wlr_output = wlr_output;
output->server = server;
/* Sets up a listener for the frame notify event. */
#include "labwc.h"
-static void activate_view(struct tinywl_view *view) {
+static void activate_view(struct view *view) {
if (view->type == LAB_XDG_SHELL_VIEW) {
wlr_xdg_toplevel_set_activated(view->xdg_surface, true);
} else if (view->type == LAB_XWAYLAND_VIEW) {
}
}
-static void move_to_front(struct tinywl_view *view) {
+static void move_to_front(struct view *view) {
wl_list_remove(&view->link);
wl_list_insert(&view->server->views, &view->link);
}
-void focus_view(struct tinywl_view *view, struct wlr_surface *surface) {
+void focus_view(struct view *view, struct wlr_surface *surface) {
/* Note: this function only deals with keyboard focus. */
if (view == NULL) {
return;
}
- struct tinywl_server *server = view->server;
+ struct server *server = view->server;
struct wlr_seat *seat = server->seat;
struct wlr_surface *prev_surface;
keyboard->num_keycodes, &keyboard->modifiers);
}
-static struct tinywl_view *next_toplevel(struct tinywl_view *current)
+static struct view *next_toplevel(struct view *current)
{
- struct tinywl_view *tmp = current;
+ struct view *tmp = current;
do {
tmp = wl_container_of(tmp->link.next, tmp, link);
return tmp;
}
-void view_focus_next_toplevel(struct tinywl_server *server) {
- struct tinywl_view *view;
+void view_focus_next_toplevel(struct server *server) {
+ struct view *view;
view = first_toplevel(server);
view = next_toplevel(view);
focus_view(view, view->surface);
}
-void begin_interactive(struct tinywl_view *view,
- enum tinywl_cursor_mode mode, uint32_t edges) {
+void begin_interactive(struct view *view,
+ enum cursor_mode mode, uint32_t edges) {
/* This function sets up an interactive move or resize operation, where the
* compositor stops propegating pointer events to clients and instead
* consumes them itself, to move or resize windows. */
- struct tinywl_server *server = view->server;
+ struct server *server = view->server;
struct wlr_surface *focused_surface =
server->seat->pointer_state.focused_surface;
if (view->surface != focused_surface) {
server->resize_edges = edges;
}
-bool is_toplevel(struct tinywl_view *view) {
+bool is_toplevel(struct view *view) {
switch (view->type) {
case LAB_XWAYLAND_VIEW:
return xwl_nr_parents(view) > 0 ? false : true;
return false;
}
-struct tinywl_view *first_toplevel(struct tinywl_server *server) {
- struct tinywl_view *view;
+struct view *first_toplevel(struct server *server) {
+ struct view *view;
wl_list_for_each(view, &server->views, link) {
if (!view->been_mapped) {
return NULL;
}
-static bool view_at(struct tinywl_view *view,
+static bool view_at(struct view *view,
double lx, double ly, struct wlr_surface **surface,
double *sx, double *sy) {
/*
return false;
}
-struct tinywl_view *desktop_view_at(struct tinywl_server *server, double lx, double ly,
+struct view *desktop_view_at(struct server *server, double lx, double ly,
struct wlr_surface **surface, double *sx, double *sy) {
/* This iterates over all of our surfaces and attempts to find one under the
* cursor. This relies on server->views being ordered from top-to-bottom. */
- struct tinywl_view *view;
+ struct view *view;
wl_list_for_each(view, &server->views, link) {
if (view_at(view, lx, ly, surface, sx, sy)) {
return view;
void xdg_surface_map(struct wl_listener *listener, void *data)
{
/* Called when the surface is mapped, or ready to display on-screen. */
- struct tinywl_view *view = wl_container_of(listener, view, map);
+ struct view *view = wl_container_of(listener, view, map);
view->mapped = true;
view->been_mapped = true;
view->surface = view->xdg_surface->surface;
void xdg_surface_unmap(struct wl_listener *listener, void *data)
{
- struct tinywl_view *view = wl_container_of(listener, view, unmap);
+ struct view *view = wl_container_of(listener, view, unmap);
view->mapped = false;
view_focus_next_toplevel(view->server);
}
void xdg_surface_destroy(struct wl_listener *listener, void *data)
{
- struct tinywl_view *view = wl_container_of(listener, view, destroy);
+ struct view *view = wl_container_of(listener, view, destroy);
wl_list_remove(&view->link);
free(view);
}
* decorations. Note that a more sophisticated compositor should check the
* provied serial against a list of button press serials sent to this
* client, to prevent the client from requesting this whenever they want. */
- struct tinywl_view *view = wl_container_of(listener, view, request_move);
+ struct view *view = wl_container_of(listener, view, request_move);
begin_interactive(view, TINYWL_CURSOR_MOVE, 0);
}
* provied serial against a list of button press serials sent to this
* client, to prevent the client from requesting this whenever they want. */
struct wlr_xdg_toplevel_resize_event *event = data;
- struct tinywl_view *view = wl_container_of(listener, view, request_resize);
+ struct view *view = wl_container_of(listener, view, request_resize);
begin_interactive(view, TINYWL_CURSOR_RESIZE, event->edges);
}
void xdg_surface_new(struct wl_listener *listener, void *data)
{
- struct tinywl_server *server =
+ struct server *server =
wl_container_of(listener, server, new_xdg_surface);
struct wlr_xdg_surface *xdg_surface = data;
if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL) {
return;
}
- struct tinywl_view *view =
- calloc(1, sizeof(struct tinywl_view));
+ struct view *view =
+ calloc(1, sizeof(struct view));
view->server = server;
view->type = LAB_XDG_SHELL_VIEW;
view->xdg_surface = xdg_surface;
#include "labwc.h"
-int xwl_nr_parents(struct tinywl_view *view) {
+int xwl_nr_parents(struct view *view) {
struct wlr_xwayland_surface *s = view->xwayland_surface;
int i = 0;
}
void xwl_surface_map(struct wl_listener *listener, void *data) {
- struct tinywl_view *view = wl_container_of(listener, view, map);
+ struct view *view = wl_container_of(listener, view, map);
view->mapped = true;
view->been_mapped = true;
view->x = view->xwayland_surface->x;
}
void xwl_surface_unmap(struct wl_listener *listener, void *data) {
- struct tinywl_view *view = wl_container_of(listener, view, unmap);
+ struct view *view = wl_container_of(listener, view, unmap);
view->mapped = false;
if (is_toplevel(view))
view_focus_next_toplevel(view->server);
}
void xwl_surface_destroy(struct wl_listener *listener, void *data) {
- struct tinywl_view *view = wl_container_of(listener, view, destroy);
+ struct view *view = wl_container_of(listener, view, destroy);
wl_list_remove(&view->link);
free(view);
}
void xwl_surface_configure(struct wl_listener *listener, void *data) {
- struct tinywl_view *view = wl_container_of(listener, view, request_configure);
+ struct view *view = wl_container_of(listener, view, request_configure);
struct wlr_xwayland_surface_configure_event *event = data;
wlr_xwayland_surface_configure(view->xwayland_surface, event->x, event->y,
event->width, event->height);
}
void xwl_surface_new(struct wl_listener *listener, void *data) {
- struct tinywl_server *server =
+ struct server *server =
wl_container_of(listener, server, new_xwayland_surface);
struct wlr_xwayland_surface *xwayland_surface = data;
wlr_xwayland_surface_ping(xwayland_surface);
- struct tinywl_view *view = calloc(1, sizeof(struct tinywl_view));
+ struct view *view = calloc(1, sizeof(struct view));
view->server = server;
view->type = LAB_XWAYLAND_VIEW;
view->xwayland_surface = xwayland_surface;
projects / proto / labwc.git / commitdiff