mirror of
https://github.com/labwc/labwc.git
synced 2025-11-02 09:01:47 -05:00
Add .clang-format and apply
This commit is contained in:
Johan Malm
parent
23a07aaed9
commit
7732869870
8 changed files with 513 additions and 293 deletions
245
main.c
245
main.c
|
|
@ -6,10 +6,11 @@
|
|||
#include <wlr/types/wlr_gamma_control_v1.h>
|
||||
#include <wlr/types/wlr_primary_selection_v1.h>
|
||||
|
||||
static struct view *last_toplevel(struct server *server) {
|
||||
static struct view *last_toplevel(struct server *server)
|
||||
{
|
||||
struct view *view;
|
||||
|
||||
wl_list_for_each_reverse(view, &server->views, link) {
|
||||
wl_list_for_each_reverse (view, &server->views, link) {
|
||||
if (!view->been_mapped) {
|
||||
continue;
|
||||
}
|
||||
|
|
@ -21,7 +22,8 @@ static struct view *last_toplevel(struct server *server) {
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static void view_focus_last_toplevel(struct 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;
|
||||
|
|
@ -30,25 +32,26 @@ static void view_focus_last_toplevel(struct server *server) {
|
|||
focus_view(view, view->surface);
|
||||
}
|
||||
|
||||
static void keyboard_handle_modifiers(
|
||||
struct wl_listener *listener, void *data) {
|
||||
static void keyboard_handle_modifiers(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 keyboard *keyboard =
|
||||
wl_container_of(listener, keyboard, modifiers);
|
||||
/*
|
||||
* A seat can only have one keyboard, but this is a limitation of the
|
||||
* Wayland protocol - not wlroots. We assign all connected keyboards to the
|
||||
* same seat. You can swap out the underlying wlr_keyboard like this and
|
||||
* wlr_seat handles this transparently.
|
||||
* Wayland protocol - not wlroots. We assign all connected keyboards to
|
||||
* the same seat. You can swap out the underlying wlr_keyboard like this
|
||||
* and wlr_seat handles this transparently.
|
||||
*/
|
||||
wlr_seat_set_keyboard(keyboard->server->seat, keyboard->device);
|
||||
/* Send modifiers to the client. */
|
||||
wlr_seat_keyboard_notify_modifiers(keyboard->server->seat,
|
||||
&keyboard->device->keyboard->modifiers);
|
||||
wlr_seat_keyboard_notify_modifiers(
|
||||
keyboard->server->seat, &keyboard->device->keyboard->modifiers);
|
||||
}
|
||||
|
||||
static void xdg_debug_show_one_view(struct 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:
|
||||
|
|
@ -63,32 +66,30 @@ static void xdg_debug_show_one_view(struct view *view) {
|
|||
}
|
||||
fprintf(stderr, " %p %s", (void *)view,
|
||||
view->xdg_surface->toplevel->app_id);
|
||||
fprintf(stderr, " {%d, %d, %d, %d}\n",
|
||||
view->xdg_surface->geometry.x,
|
||||
fprintf(stderr, " {%d, %d, %d, %d}\n", view->xdg_surface->geometry.x,
|
||||
view->xdg_surface->geometry.y,
|
||||
view->xdg_surface->geometry.height,
|
||||
view->xdg_surface->geometry.width);
|
||||
}
|
||||
|
||||
static void xwl_debug_show_one_view(struct view *view) {
|
||||
static void xwl_debug_show_one_view(struct view *view)
|
||||
{
|
||||
fprintf(stderr, "XWL ");
|
||||
if (!view->been_mapped) {
|
||||
fprintf(stderr, "- ");
|
||||
} else {
|
||||
fprintf(stderr, "%d ", xwl_nr_parents(view));
|
||||
}
|
||||
fprintf(stderr, " %d ", wl_list_length(&view->xwayland_surface->children));
|
||||
fprintf(stderr, " %d ",
|
||||
wl_list_length(&view->xwayland_surface->children));
|
||||
if (view->mapped) {
|
||||
fprintf(stderr, "Y");
|
||||
} else {
|
||||
fprintf(stderr, "-");
|
||||
}
|
||||
fprintf(stderr, " %p %s {%d,%d,%d,%d}\n",
|
||||
(void *)view,
|
||||
view->xwayland_surface->class,
|
||||
view->xwayland_surface->x,
|
||||
view->xwayland_surface->y,
|
||||
view->xwayland_surface->width,
|
||||
fprintf(stderr, " %p %s {%d,%d,%d,%d}\n", (void *)view,
|
||||
view->xwayland_surface->class, view->xwayland_surface->x,
|
||||
view->xwayland_surface->y, view->xwayland_surface->width,
|
||||
view->xwayland_surface->height);
|
||||
/*
|
||||
* Other variables to consider printing:
|
||||
|
|
@ -104,27 +105,30 @@ static void xwl_debug_show_one_view(struct view *view) {
|
|||
*/
|
||||
}
|
||||
|
||||
static void debug_show_one_view(struct 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 server *server) {
|
||||
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");
|
||||
wl_list_for_each_reverse(view, &server->views, link)
|
||||
wl_list_for_each_reverse (view, &server->views, link)
|
||||
debug_show_one_view(view);
|
||||
}
|
||||
|
||||
static bool handle_keybinding(struct 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
|
||||
* processing.
|
||||
* processing keys, rather than passing them on to the client for its
|
||||
* own processing.
|
||||
*
|
||||
* This function assumes Alt is held down.
|
||||
*/
|
||||
|
|
@ -142,8 +146,8 @@ static bool handle_keybinding(struct server *server, xkb_keysym_t sym) {
|
|||
}
|
||||
break;
|
||||
case XKB_KEY_F6:
|
||||
begin_interactive(first_toplevel(server),
|
||||
TINYWL_CURSOR_MOVE, 0);
|
||||
begin_interactive(first_toplevel(server), TINYWL_CURSOR_MOVE,
|
||||
0);
|
||||
break;
|
||||
case XKB_KEY_F12:
|
||||
debug_show_views(server);
|
||||
|
|
@ -154,11 +158,10 @@ static bool handle_keybinding(struct server *server, xkb_keysym_t sym) {
|
|||
return true;
|
||||
}
|
||||
|
||||
static void keyboard_handle_key(
|
||||
struct wl_listener *listener, void *data) {
|
||||
static void keyboard_handle_key(struct wl_listener *listener, void *data)
|
||||
{
|
||||
/* This event is raised when a key is pressed or released. */
|
||||
struct keyboard *keyboard =
|
||||
wl_container_of(listener, keyboard, key);
|
||||
struct keyboard *keyboard = wl_container_of(listener, keyboard, key);
|
||||
struct server *server = keyboard->server;
|
||||
struct wlr_event_keyboard_key *event = data;
|
||||
struct wlr_seat *seat = server->seat;
|
||||
|
|
@ -168,13 +171,14 @@ static void keyboard_handle_key(
|
|||
/* Get a list of keysyms based on the keymap for this keyboard */
|
||||
const xkb_keysym_t *syms;
|
||||
int nsyms = xkb_state_key_get_syms(
|
||||
keyboard->device->keyboard->xkb_state, keycode, &syms);
|
||||
keyboard->device->keyboard->xkb_state, keycode, &syms);
|
||||
|
||||
bool handled = false;
|
||||
uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard->device->keyboard);
|
||||
uint32_t modifiers =
|
||||
wlr_keyboard_get_modifiers(keyboard->device->keyboard);
|
||||
if ((modifiers & WLR_MODIFIER_ALT) && event->state == WLR_KEY_PRESSED) {
|
||||
/* If alt is held down and this button was _pressed_, we attempt to
|
||||
* process it as a compositor keybinding. */
|
||||
/* If alt is held down and this button was _pressed_, we attempt
|
||||
* to process it as a compositor keybinding. */
|
||||
for (int i = 0; i < nsyms; i++) {
|
||||
handled = handle_keybinding(server, syms[i]);
|
||||
}
|
||||
|
|
@ -184,14 +188,14 @@ static void keyboard_handle_key(
|
|||
/* Otherwise, we pass it along to the client. */
|
||||
wlr_seat_set_keyboard(seat, keyboard->device);
|
||||
wlr_seat_keyboard_notify_key(seat, event->time_msec,
|
||||
event->keycode, event->state);
|
||||
event->keycode, event->state);
|
||||
}
|
||||
}
|
||||
|
||||
static void server_new_keyboard(struct server *server,
|
||||
struct wlr_input_device *device) {
|
||||
struct keyboard *keyboard =
|
||||
calloc(1, sizeof(struct keyboard));
|
||||
struct wlr_input_device *device)
|
||||
{
|
||||
struct keyboard *keyboard = calloc(1, sizeof(struct keyboard));
|
||||
keyboard->server = server;
|
||||
keyboard->device = device;
|
||||
|
||||
|
|
@ -199,8 +203,8 @@ static void server_new_keyboard(struct server *server,
|
|||
* assumes the defaults (e.g. layout = "us"). */
|
||||
struct xkb_rule_names rules = { 0 };
|
||||
struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
|
||||
struct xkb_keymap *keymap = xkb_map_new_from_names(context, &rules,
|
||||
XKB_KEYMAP_COMPILE_NO_FLAGS);
|
||||
struct xkb_keymap *keymap = xkb_map_new_from_names(
|
||||
context, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
|
||||
|
||||
wlr_keyboard_set_keymap(device->keyboard, keymap);
|
||||
xkb_keymap_unref(keymap);
|
||||
|
|
@ -209,7 +213,8 @@ static void server_new_keyboard(struct server *server,
|
|||
|
||||
/* Here we set up listeners for keyboard events. */
|
||||
keyboard->modifiers.notify = keyboard_handle_modifiers;
|
||||
wl_signal_add(&device->keyboard->events.modifiers, &keyboard->modifiers);
|
||||
wl_signal_add(&device->keyboard->events.modifiers,
|
||||
&keyboard->modifiers);
|
||||
keyboard->key.notify = keyboard_handle_key;
|
||||
wl_signal_add(&device->keyboard->events.key, &keyboard->key);
|
||||
|
||||
|
|
@ -220,19 +225,20 @@ static void server_new_keyboard(struct 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
|
||||
* opportunity to do libinput configuration on the device to set
|
||||
* acceleration, etc. */
|
||||
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 opportunity to do libinput configuration on the
|
||||
* device to set acceleration, etc. */
|
||||
wlr_cursor_attach_input_device(server->cursor, device);
|
||||
}
|
||||
|
||||
static void server_new_input(struct wl_listener *listener, void *data) {
|
||||
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 server *server =
|
||||
wl_container_of(listener, server, new_input);
|
||||
struct server *server = wl_container_of(listener, server, new_input);
|
||||
struct wlr_input_device *device = data;
|
||||
switch (device->type) {
|
||||
case WLR_INPUT_DEVICE_KEYBOARD:
|
||||
|
|
@ -245,8 +251,9 @@ static void server_new_input(struct wl_listener *listener, void *data) {
|
|||
break;
|
||||
}
|
||||
/* We need to let the wlr_seat know what our capabilities are, which is
|
||||
* communiciated to the client. In TinyWL we always have a cursor, even if
|
||||
* there are no pointer devices, so we always include that capability. */
|
||||
* communiciated to the client. In TinyWL we always have a cursor, even
|
||||
* if there are no pointer devices, so we always include that
|
||||
* capability. */
|
||||
uint32_t caps = WL_SEAT_CAPABILITY_POINTER;
|
||||
if (!wl_list_empty(&server->keyboards)) {
|
||||
caps |= WL_SEAT_CAPABILITY_KEYBOARD;
|
||||
|
|
@ -254,26 +261,29 @@ static void server_new_input(struct wl_listener *listener, void *data) {
|
|||
wlr_seat_set_capabilities(server->seat, caps);
|
||||
}
|
||||
|
||||
static void seat_request_cursor(struct wl_listener *listener, void *data) {
|
||||
struct server *server = wl_container_of(
|
||||
listener, server, request_cursor);
|
||||
/* This event is rasied by the seat when a client provides a cursor image */
|
||||
static void seat_request_cursor(struct wl_listener *listener, void *data)
|
||||
{
|
||||
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;
|
||||
struct wlr_seat_client *focused_client =
|
||||
server->seat->pointer_state.focused_client;
|
||||
/* This can be sent by any client, so we check to make sure this one is
|
||||
* actually has pointer focus first. */
|
||||
if (focused_client == event->seat_client) {
|
||||
/* Once we've vetted the client, we can tell the cursor to use the
|
||||
* provided surface as the cursor image. It will set the hardware cursor
|
||||
* on the output that it's currently on and continue to do so as the
|
||||
* cursor moves between outputs. */
|
||||
/* Once we've vetted the client, we can tell the cursor to use
|
||||
* the provided surface as the cursor image. It will set the
|
||||
* hardware cursor on the output that it's currently on and
|
||||
* continue to do so as the cursor moves between outputs. */
|
||||
wlr_cursor_set_surface(server->cursor, event->surface,
|
||||
event->hotspot_x, event->hotspot_y);
|
||||
event->hotspot_x, event->hotspot_y);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
wlr_log_init(WLR_ERROR, NULL);
|
||||
char *startup_cmd = NULL;
|
||||
|
||||
|
|
@ -297,27 +307,30 @@ int main(int argc, char *argv[]) {
|
|||
/* 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();
|
||||
/* The backend is a wlroots feature which abstracts the underlying input and
|
||||
* output hardware. The autocreate option will choose the most suitable
|
||||
* backend based on the current environment, such as opening an X11 window
|
||||
* if an X11 server is running. The NULL argument here optionally allows you
|
||||
* to pass in a custom renderer if wlr_renderer doesn't meet your needs. The
|
||||
* backend uses the renderer, for example, to fall back to software cursors
|
||||
* if the backend does not support hardware cursors (some older GPUs
|
||||
* don't). */
|
||||
/* The backend is a wlroots feature which abstracts the underlying input
|
||||
* and output hardware. The autocreate option will choose the most
|
||||
* suitable backend based on the current environment, such as opening an
|
||||
* X11 window if an X11 server is running. The NULL argument here
|
||||
* optionally allows you to pass in a custom renderer if wlr_renderer
|
||||
* doesn't meet your needs. The backend uses the renderer, for example,
|
||||
* to fall back to software cursors if the backend does not support
|
||||
* hardware cursors (some older GPUs don't). */
|
||||
server.backend = wlr_backend_autocreate(server.wl_display, NULL);
|
||||
|
||||
/* If we don't provide a renderer, autocreate makes a GLES2 renderer for us.
|
||||
* The renderer is responsible for defining the various pixel formats it
|
||||
* supports for shared memory, this configures that for clients. */
|
||||
/* If we don't provide a renderer, autocreate makes a GLES2 renderer for
|
||||
* us. The renderer is responsible for defining the various pixel
|
||||
* formats it supports for shared memory, this configures that for
|
||||
* clients. */
|
||||
server.renderer = wlr_backend_get_renderer(server.backend);
|
||||
wlr_renderer_init_wl_display(server.renderer, server.wl_display);
|
||||
|
||||
/* This creates some hands-off wlroots interfaces. The compositor is
|
||||
* necessary for clients to allocate surfaces and the data device manager
|
||||
* handles the clipboard. Each of these wlroots interfaces has room for you
|
||||
* to dig your fingers in and play with their behavior if you want. */
|
||||
server.compositor = wlr_compositor_create(server.wl_display, server.renderer);
|
||||
* necessary for clients to allocate surfaces and the data device
|
||||
* manager handles the clipboard. Each of these wlroots interfaces has
|
||||
* room for you to dig your fingers in and play with their behavior if
|
||||
* you want. */
|
||||
server.compositor =
|
||||
wlr_compositor_create(server.wl_display, server.renderer);
|
||||
wlr_data_device_manager_create(server.wl_display);
|
||||
|
||||
wlr_export_dmabuf_manager_v1_create(server.wl_display);
|
||||
|
|
@ -330,15 +343,15 @@ int main(int argc, char *argv[]) {
|
|||
* arrangement of screens in a physical layout. */
|
||||
server.output_layout = wlr_output_layout_create();
|
||||
|
||||
/* Configure a listener to be notified when new outputs are available on the
|
||||
* backend. */
|
||||
/* Configure a listener to be notified when new outputs are available on
|
||||
* the backend. */
|
||||
wl_list_init(&server.outputs);
|
||||
server.new_output.notify = server_new_output;
|
||||
wl_signal_add(&server.backend->events.new_output, &server.new_output);
|
||||
|
||||
/* Set up our list of views and the xdg-shell. The xdg-shell is a Wayland
|
||||
* protocol which is used for application windows. For more detail on
|
||||
* shells, refer to my article:
|
||||
/* Set up our list of views and the xdg-shell. The xdg-shell is a
|
||||
* Wayland protocol which is used for application windows. For more
|
||||
* detail on shells, refer to my article:
|
||||
*
|
||||
* https://drewdevault.com/2018/07/29/Wayland-shells.html
|
||||
*/
|
||||
|
|
@ -346,7 +359,7 @@ int main(int argc, char *argv[]) {
|
|||
server.xdg_shell = wlr_xdg_shell_create(server.wl_display);
|
||||
server.new_xdg_surface.notify = xdg_surface_new;
|
||||
wl_signal_add(&server.xdg_shell->events.new_surface,
|
||||
&server.new_xdg_surface);
|
||||
&server.new_xdg_surface);
|
||||
|
||||
/*
|
||||
* Creates a cursor, which is a wlroots utility for tracking the cursor
|
||||
|
|
@ -356,22 +369,23 @@ int main(int argc, char *argv[]) {
|
|||
wlr_cursor_attach_output_layout(server.cursor, server.output_layout);
|
||||
|
||||
/*
|
||||
* wlr_cursor *only* displays an image on screen. It does not move around
|
||||
* when the pointer moves. However, we can attach input devices to it, and
|
||||
* it will generate aggregate events for all of them. In these events, we
|
||||
* can choose how we want to process them, forwarding them to clients and
|
||||
* moving the cursor around. More detail on this process is described in my
|
||||
* input handling blog post:
|
||||
* wlr_cursor *only* displays an image on screen. It does not move
|
||||
* around when the pointer moves. However, we can attach input devices
|
||||
* to it, and it will generate aggregate events for all of them. In
|
||||
* these events, we can choose how we want to process them, forwarding
|
||||
* them to clients and moving the cursor around. More detail on this
|
||||
* process is described in my input handling blog post:
|
||||
*
|
||||
* https://drewdevault.com/2018/07/17/Input-handling-in-wlroots.html
|
||||
*
|
||||
* And more comments are sprinkled throughout the notify functions above.
|
||||
* And more comments are sprinkled throughout the notify functions
|
||||
* above.
|
||||
*/
|
||||
server.cursor_motion.notify = server_cursor_motion;
|
||||
wl_signal_add(&server.cursor->events.motion, &server.cursor_motion);
|
||||
server.cursor_motion_absolute.notify = server_cursor_motion_absolute;
|
||||
wl_signal_add(&server.cursor->events.motion_absolute,
|
||||
&server.cursor_motion_absolute);
|
||||
&server.cursor_motion_absolute);
|
||||
server.cursor_button.notify = server_cursor_button;
|
||||
wl_signal_add(&server.cursor->events.button, &server.cursor_button);
|
||||
server.cursor_axis.notify = server_cursor_axis;
|
||||
|
|
@ -382,8 +396,8 @@ int main(int argc, char *argv[]) {
|
|||
/*
|
||||
* Configures a seat, which is a single "seat" at which a user sits and
|
||||
* operates the computer. This conceptually includes up to one keyboard,
|
||||
* pointer, touch, and drawing tablet device. We also rig up a listener to
|
||||
* let us know when new input devices are available on the backend.
|
||||
* pointer, touch, and drawing tablet device. We also rig up a listener
|
||||
* to let us know when new input devices are available on the backend.
|
||||
*/
|
||||
wl_list_init(&server.keyboards);
|
||||
server.new_input.notify = server_new_input;
|
||||
|
|
@ -391,7 +405,7 @@ int main(int argc, char *argv[]) {
|
|||
server.seat = wlr_seat_create(server.wl_display, "seat0");
|
||||
server.request_cursor.notify = seat_request_cursor;
|
||||
wl_signal_add(&server.seat->events.request_set_cursor,
|
||||
&server.request_cursor);
|
||||
&server.request_cursor);
|
||||
|
||||
/* Add a Unix socket to the Wayland display. */
|
||||
const char *socket = wl_display_add_socket_auto(server.wl_display);
|
||||
|
|
@ -400,46 +414,53 @@ int main(int argc, char *argv[]) {
|
|||
return 1;
|
||||
}
|
||||
|
||||
/* Start the backend. This will enumerate outputs and inputs, become the DRM
|
||||
* master, etc */
|
||||
/* Start the backend. This will enumerate outputs and inputs, become the
|
||||
* DRM master, etc */
|
||||
if (!wlr_backend_start(server.backend)) {
|
||||
wlr_backend_destroy(server.backend);
|
||||
wl_display_destroy(server.wl_display);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Set the WAYLAND_DISPLAY environment variable to our socket and run the
|
||||
* startup command if requested. */
|
||||
/* Set the WAYLAND_DISPLAY environment variable to our socket and run
|
||||
* the startup command if requested. */
|
||||
setenv("WAYLAND_DISPLAY", socket, true);
|
||||
|
||||
wl_display_init_shm(server.wl_display);
|
||||
|
||||
/* Init xwayland */
|
||||
server.xwayland = wlr_xwayland_create(server.wl_display, server.compositor, false);
|
||||
server.xwayland = wlr_xwayland_create(server.wl_display,
|
||||
server.compositor, false);
|
||||
server.new_xwayland_surface.notify = xwl_surface_new;
|
||||
wl_signal_add(&server.xwayland->events.new_surface, &server.new_xwayland_surface);
|
||||
wl_signal_add(&server.xwayland->events.new_surface,
|
||||
&server.new_xwayland_surface);
|
||||
setenv("DISPLAY", server.xwayland->display_name, true);
|
||||
wlr_xwayland_set_seat(server.xwayland, server.seat);
|
||||
|
||||
/* Creates an xcursor manager, another wlroots utility which loads up
|
||||
* Xcursor themes to source cursor images from and makes sure that cursor
|
||||
* images are available at all scale factors on the screen (necessary for
|
||||
* HiDPI support). We add a cursor theme at scale factor 1 to begin with. */
|
||||
server.cursor_mgr = wlr_xcursor_manager_create(XCURSOR_DEFAULT, XCURSOR_SIZE);
|
||||
* Xcursor themes to source cursor images from and makes sure that
|
||||
* cursor images are available at all scale factors on the screen
|
||||
* (necessary for
|
||||
* HiDPI support). We add a cursor theme at scale factor 1 to begin
|
||||
* with. */
|
||||
server.cursor_mgr =
|
||||
wlr_xcursor_manager_create(XCURSOR_DEFAULT, XCURSOR_SIZE);
|
||||
wlr_xcursor_manager_load(server.cursor_mgr, 1);
|
||||
|
||||
struct wlr_xcursor *xcursor =
|
||||
wlr_xcursor_manager_get_xcursor(server.cursor_mgr, XCURSOR_DEFAULT, 1);
|
||||
struct wlr_xcursor *xcursor = wlr_xcursor_manager_get_xcursor(
|
||||
server.cursor_mgr, XCURSOR_DEFAULT, 1);
|
||||
if (xcursor) {
|
||||
struct wlr_xcursor_image *image = xcursor->images[0];
|
||||
wlr_xwayland_set_cursor(server.xwayland, image->buffer,
|
||||
image->width * 4, image->width, image->height,
|
||||
image->hotspot_x, image->hotspot_y);
|
||||
image->width * 4, image->width,
|
||||
image->height, image->hotspot_x,
|
||||
image->hotspot_y);
|
||||
}
|
||||
|
||||
if (startup_cmd) {
|
||||
if (fork() == 0) {
|
||||
execl("/bin/sh", "/bin/sh", "-c", startup_cmd, (void *)NULL);
|
||||
execl("/bin/sh", "/bin/sh", "-c", startup_cmd,
|
||||
(void *)NULL);
|
||||
}
|
||||
}
|
||||
/* Run the Wayland event loop. This does not return until you exit the
|
||||
|
|
@ -447,7 +468,7 @@ int main(int argc, char *argv[]) {
|
|||
* loop configuration to listen to libinput events, DRM events, generate
|
||||
* frame events at the refresh rate, and so on. */
|
||||
wlr_log(WLR_INFO, "Running Wayland compositor on WAYLAND_DISPLAY=%s",
|
||||
socket);
|
||||
socket);
|
||||
wl_display_run(server.wl_display);
|
||||
|
||||
/* Once wl_display_run returns, we shut down the server. */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue