mirrors/labwc
1
0
Fork 0
mirror of https://github.com/labwc/labwc.git synced 2025-10-29 05:40:24 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

include: add config/types.h

Browse source
This commit is contained in:
John Lindgren 2025-08-17 16:01:50 -04:00 • committed by Hiroaki Yamamoto
parent 6dea8c0dcc
commit 9d49d19cd2
54 changed files with 414 additions and 368 deletions
Download patch file Download diff file Expand all files Collapse all files

32
src/action.c
View file

@ -15,7 +15,9 @@
#include "common/parse-bool.h"
#include "common/spawn.h"
#include "common/string-helpers.h"
#include "config/rcxml.h"
#include "debug.h"
#include "input/keyboard.h"
#include "labwc.h"
#include "magnifier.h"
#include "menu/menu.h"
@ -24,9 +26,9 @@
#include "output-virtual.h"
#include "regions.h"
#include "ssd.h"
#include "theme.h"
#include "view.h"
#include "workspaces.h"
#include "input/keyboard.h"
enum action_arg_type {
LAB_ACTION_ARG_STR = 0,
@ -345,8 +347,8 @@ action_arg_from_xml_node(struct action *action, const char *nodename, const char
if (!strcmp(argument, "direction")) {
bool tiled = (action->type == ACTION_TYPE_TOGGLE_SNAP_TO_EDGE
|| action->type == ACTION_TYPE_SNAP_TO_EDGE);
enum view_edge edge = view_edge_parse(content, tiled, /*any*/ false);
if (edge == VIEW_EDGE_INVALID) {
enum lab_edge edge = view_edge_parse(content, tiled, /*any*/ false);
if (edge == LAB_EDGE_INVALID) {
wlr_log(WLR_ERROR, "Invalid argument for action %s: '%s' (%s)",
action_names[action->type], argument, content);
} else {
@ -389,7 +391,7 @@ action_arg_from_xml_node(struct action *action, const char *nodename, const char
break;
case ACTION_TYPE_SET_DECORATIONS:
if (!strcmp(argument, "decorations")) {
enum ssd_mode mode = ssd_mode_parse(content);
enum lab_ssd_mode mode = ssd_mode_parse(content);
if (mode != LAB_SSD_MODE_INVALID) {
action_arg_add_int(action, argument, mode);
} else {
@ -453,9 +455,9 @@ action_arg_from_xml_node(struct action *action, const char *nodename, const char
goto cleanup;
}
if (!strcmp(argument, "direction")) {
enum view_edge edge = view_edge_parse(content,
enum lab_edge edge = view_edge_parse(content,
/*tiled*/ false, /*any*/ false);
if (edge == VIEW_EDGE_INVALID) {
if (edge == LAB_EDGE_INVALID) {
wlr_log(WLR_ERROR, "Invalid argument for action %s: '%s' (%s)",
action_names[action->type], argument, content);
} else {
@ -477,7 +479,7 @@ action_arg_from_xml_node(struct action *action, const char *nodename, const char
break;
case ACTION_TYPE_AUTO_PLACE:
if (!strcmp(argument, "policy")) {
enum view_placement_policy policy =
enum lab_placement_policy policy =
view_placement_parse(content);
if (policy == LAB_PLACE_INVALID) {
wlr_log(WLR_ERROR, "Invalid argument for action %s: '%s' (%s)",
@ -913,8 +915,8 @@ get_target_output(struct output *output, struct server *server,
if (output_name) {
target = output_from_name(server, output_name);
} else {
enum view_edge edge =
action_get_int(action, "direction", VIEW_EDGE_INVALID);
enum lab_edge edge =
action_get_int(action, "direction", LAB_EDGE_INVALID);
bool wrap = action_get_bool(action, "wrap", false);
target = output_get_adjacent(output, edge, wrap);
}
@ -1003,7 +1005,7 @@ run_action(struct view *view, struct server *server, struct action *action,
case ACTION_TYPE_MOVE_TO_EDGE:
if (view) {
/* Config parsing makes sure that direction is a valid direction */
enum view_edge edge = action_get_int(action, "direction", 0);
enum lab_edge edge = action_get_int(action, "direction", 0);
bool snap_to_windows = action_get_bool(action, "snapWindows", true);
view_move_to_edge(view, edge, snap_to_windows);
}
@ -1012,7 +1014,7 @@ run_action(struct view *view, struct server *server, struct action *action,
case ACTION_TYPE_SNAP_TO_EDGE:
if (view) {
/* Config parsing makes sure that direction is a valid direction */
enum view_edge edge = action_get_int(action, "direction", 0);
enum lab_edge edge = action_get_int(action, "direction", 0);
if (action->type == ACTION_TYPE_TOGGLE_SNAP_TO_EDGE
&& view->maximized == VIEW_AXIS_NONE
&& !view->fullscreen
@ -1030,14 +1032,14 @@ run_action(struct view *view, struct server *server, struct action *action,
case ACTION_TYPE_GROW_TO_EDGE:
if (view) {
/* Config parsing makes sure that direction is a valid direction */
enum view_edge edge = action_get_int(action, "direction", 0);
enum lab_edge edge = action_get_int(action, "direction", 0);
view_grow_to_edge(view, edge);
}
break;
case ACTION_TYPE_SHRINK_TO_EDGE:
if (view) {
/* Config parsing makes sure that direction is a valid direction */
enum view_edge edge = action_get_int(action, "direction", 0);
enum lab_edge edge = action_get_int(action, "direction", 0);
view_shrink_to_edge(view, edge);
}
break;
@ -1095,7 +1097,7 @@ run_action(struct view *view, struct server *server, struct action *action,
break;
case ACTION_TYPE_SET_DECORATIONS:
if (view) {
enum ssd_mode mode = action_get_int(action,
enum lab_ssd_mode mode = action_get_int(action,
"decorations", LAB_SSD_MODE_FULL);
bool force_ssd = action_get_bool(action,
"forceSSD", false);
@ -1378,7 +1380,7 @@ run_action(struct view *view, struct server *server, struct action *action,
}
case ACTION_TYPE_AUTO_PLACE:
if (view) {
enum view_placement_policy policy =
enum lab_placement_policy policy =
action_get_int(action, "policy", LAB_PLACE_AUTOMATIC);
view_place_by_policy(view,
/* allow_cursor */ true, policy);

1
src/common/dir.c
View file

@ -15,6 +15,7 @@
#include "common/list.h"
#include "common/mem.h"
#include "common/string-helpers.h"
#include "config/rcxml.h"
#include "labwc.h"
struct dir {

10
src/common/direction.c
View file

@ -5,19 +5,19 @@
#include "view.h"
bool
direction_from_view_edge(enum view_edge edge, enum wlr_direction *direction)
direction_from_edge(enum lab_edge edge, enum wlr_direction *direction)
{
switch (edge) {
case VIEW_EDGE_LEFT:
case LAB_EDGE_LEFT:
*direction = WLR_DIRECTION_LEFT;
return true;
case VIEW_EDGE_RIGHT:
case LAB_EDGE_RIGHT:
*direction = WLR_DIRECTION_RIGHT;
return true;
case VIEW_EDGE_UP:
case LAB_EDGE_UP:
*direction = WLR_DIRECTION_UP;
return true;
case VIEW_EDGE_DOWN:
case LAB_EDGE_DOWN:
*direction = WLR_DIRECTION_DOWN;
return true;
default:

6
src/common/parse-bool.c
View file

@ -3,8 +3,8 @@
#include <strings.h>
#include <wlr/util/log.h>
enum three_state
parse_three_state(const char *str)
enum lab_tristate
parse_tristate(const char *str)
{
if (!str) {
goto error_not_a_boolean;
@ -33,7 +33,7 @@ error_not_a_boolean:
int
parse_bool(const char *str, int default_value)
{
enum three_state val = parse_three_state(str);
enum lab_tristate val = parse_tristate(str);
if (val == LAB_STATE_UNSPECIFIED) {
return default_value;
}

43
src/config/rcxml.c
View file

@ -24,13 +24,14 @@
#include "common/parse-bool.h"
#include "common/parse-double.h"
#include "common/string-helpers.h"
#include "common/three-state.h"
#include "common/xml.h"
#include "config/default-bindings.h"
#include "config/keybind.h"
#include "config/libinput.h"
#include "config/mousebind.h"
#include "config/tablet.h"
#include "config/tablet-tool.h"
#include "config/touch.h"
#include "labwc.h"
#include "osd.h"
#include "regions.h"
@ -62,33 +63,33 @@ parse_window_type(const char *type)
return -1;
}
if (!strcasecmp(type, "desktop")) {
return NET_WM_WINDOW_TYPE_DESKTOP;
return LAB_WINDOW_TYPE_DESKTOP;
} else if (!strcasecmp(type, "dock")) {
return NET_WM_WINDOW_TYPE_DOCK;
return LAB_WINDOW_TYPE_DOCK;
} else if (!strcasecmp(type, "toolbar")) {
return NET_WM_WINDOW_TYPE_TOOLBAR;
return LAB_WINDOW_TYPE_TOOLBAR;
} else if (!strcasecmp(type, "menu")) {
return NET_WM_WINDOW_TYPE_MENU;
return LAB_WINDOW_TYPE_MENU;
} else if (!strcasecmp(type, "utility")) {
return NET_WM_WINDOW_TYPE_UTILITY;
return LAB_WINDOW_TYPE_UTILITY;
} else if (!strcasecmp(type, "splash")) {
return NET_WM_WINDOW_TYPE_SPLASH;
return LAB_WINDOW_TYPE_SPLASH;
} else if (!strcasecmp(type, "dialog")) {
return NET_WM_WINDOW_TYPE_DIALOG;
return LAB_WINDOW_TYPE_DIALOG;
} else if (!strcasecmp(type, "dropdown_menu")) {
return NET_WM_WINDOW_TYPE_DROPDOWN_MENU;
return LAB_WINDOW_TYPE_DROPDOWN_MENU;
} else if (!strcasecmp(type, "popup_menu")) {
return NET_WM_WINDOW_TYPE_POPUP_MENU;
return LAB_WINDOW_TYPE_POPUP_MENU;
} else if (!strcasecmp(type, "tooltip")) {
return NET_WM_WINDOW_TYPE_TOOLTIP;
return LAB_WINDOW_TYPE_TOOLTIP;
} else if (!strcasecmp(type, "notification")) {
return NET_WM_WINDOW_TYPE_NOTIFICATION;
return LAB_WINDOW_TYPE_NOTIFICATION;
} else if (!strcasecmp(type, "combo")) {
return NET_WM_WINDOW_TYPE_COMBO;
return LAB_WINDOW_TYPE_COMBO;
} else if (!strcasecmp(type, "dnd")) {
return NET_WM_WINDOW_TYPE_DND;
return LAB_WINDOW_TYPE_DND;
} else if (!strcasecmp(type, "normal")) {
return NET_WM_WINDOW_TYPE_NORMAL;
return LAB_WINDOW_TYPE_NORMAL;
} else {
return -1;
}
@ -433,15 +434,15 @@ fill_action_query(struct action *action, xmlNode *node, struct view_query *query
} else if (!strcasecmp(key, "sandboxAppId")) {
xstrdup_replace(query->sandbox_app_id, content);
} else if (!strcasecmp(key, "shaded")) {
query->shaded = parse_three_state(content);
query->shaded = parse_tristate(content);
} else if (!strcasecmp(key, "maximized")) {
query->maximized = view_axis_parse(content);
} else if (!strcasecmp(key, "iconified")) {
query->iconified = parse_three_state(content);
query->iconified = parse_tristate(content);
} else if (!strcasecmp(key, "focused")) {
query->focused = parse_three_state(content);
query->focused = parse_tristate(content);
} else if (!strcasecmp(key, "omnipresent")) {
query->omnipresent = parse_three_state(content);
query->omnipresent = parse_tristate(content);
} else if (!strcasecmp(key, "tiled")) {
query->tiled = view_edge_parse(content,
/*tiled*/ true, /*any*/ true);
@ -1108,7 +1109,7 @@ entry(xmlNode *node, char *nodename, char *content)
} else if (!strcasecmp(nodename, "primarySelection.core")) {
set_bool(content, &rc.primary_selection);
} else if (!strcmp(nodename, "policy.placement")) {
enum view_placement_policy policy = view_placement_parse(content);
enum lab_placement_policy policy = view_placement_parse(content);
if (policy != LAB_PLACE_INVALID) {
rc.placement_policy = policy;
}
@ -1401,7 +1402,7 @@ rcxml_init(void)
rc.tablet.rotation = 0;
rc.tablet.box = (struct wlr_fbox){0};
tablet_load_default_button_mappings();
rc.tablet_tool.motion = LAB_TABLET_MOTION_ABSOLUTE;
rc.tablet_tool.motion = LAB_MOTION_ABSOLUTE;
rc.tablet_tool.relative_motion_sensitivity = 1.0;
rc.repeat_rate = 25;

1
src/config/session.c
View file

@ -19,6 +19,7 @@
#include "common/parse-bool.h"
#include "common/spawn.h"
#include "common/string-helpers.h"
#include "config/rcxml.h"
#include "labwc.h"
static const char *const env_vars[] = {

8
src/config/tablet-tool.c
View file

@ -4,14 +4,14 @@
#include <strings.h>
#include <wlr/util/log.h>
enum motion
enum lab_motion
tablet_parse_motion(const char *name)
{
if (!strcasecmp(name, "Absolute")) {
return LAB_TABLET_MOTION_ABSOLUTE;
return LAB_MOTION_ABSOLUTE;
} else if (!strcasecmp(name, "Relative")) {
return LAB_TABLET_MOTION_RELATIVE;
return LAB_MOTION_RELATIVE;
}
wlr_log(WLR_ERROR, "Invalid value for tablet motion: %s", name);
return LAB_TABLET_MOTION_ABSOLUTE;
return LAB_MOTION_ABSOLUTE;
}

2
src/config/tablet.c
View file

@ -21,7 +21,7 @@ tablet_get_dbl_if_positive(const char *content, const char *name)
return value;
}
enum rotation
enum lab_rotation
tablet_parse_rotation(int value)
{
switch (value) {

1
src/debug.c
View file

@ -1,5 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
#include "debug.h"
#include <stdlib.h>
#include <wlr/types/wlr_layer_shell_v1.h>
#include <wlr/types/wlr_scene.h>
#include "common/lab-scene-rect.h"

1
src/decorations/kde-deco.c
View file

@ -4,6 +4,7 @@
#include <wlr/types/wlr_xdg_shell.h>
#include "common/list.h"
#include "common/mem.h"
#include "config/rcxml.h"
#include "decorations.h"
#include "labwc.h"
#include "view.h"

1
src/decorations/xdg-deco.c
View file

@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-only
#include <wlr/types/wlr_xdg_decoration_v1.h>
#include "common/mem.h"
#include "config/rcxml.h"
#include "decorations.h"
#include "labwc.h"
#include "view.h"

1
src/desktop-entry.c
View file

@ -10,6 +10,7 @@
#include "common/macros.h"
#include "common/mem.h"
#include "common/string-helpers.h"
#include "config/rcxml.h"
#include "img/img.h"
#include "labwc.h"

1
src/dnd.c
View file

@ -4,6 +4,7 @@
#include <wlr/types/wlr_data_device.h>
#include <wlr/types/wlr_scene.h>
#include <wlr/util/log.h>
#include "config/rcxml.h"
#include "input/cursor.h"
#include "labwc.h" /* for struct seat */
#include "view.h"

1
src/input/cursor.c
View file

@ -22,6 +22,7 @@
#include "common/scene-helpers.h"
#include "common/surface-helpers.h"
#include "config/mousebind.h"
#include "config/rcxml.h"
#include "dnd.h"
#include "idle.h"
#include "input/gestures.h"

2
src/input/keyboard.c
View file

@ -9,8 +9,8 @@
#include <wlr/types/wlr_keyboard_group.h>
#include "action.h"
#include "common/macros.h"
#include "common/three-state.h"
#include "config/keybind.h"
#include "config/rcxml.h"
#include "idle.h"
#include "input/ime.h"
#include "input/key-state.h"

1
src/input/tablet-pad.c
View file

@ -10,6 +10,7 @@
#include "common/macros.h"
#include "common/mem.h"
#include "config/rcxml.h"
#include "config/tablet.h"
#include "input/cursor.h"
#include "input/tablet.h"
#include "labwc.h"

23
src/input/tablet.c
View file

@ -12,6 +12,7 @@
#include "common/scene-helpers.h"
#include "config/rcxml.h"
#include "config/mousebind.h"
#include "config/tablet.h"
#include "input/cursor.h"
#include "input/tablet-pad.h"
#include "labwc.h"
@ -92,8 +93,8 @@ tablet_tool_create(struct seat *seat,
return tool;
}
static enum motion
tool_motion_mode(enum motion motion, struct wlr_tablet_tool *tool)
static enum lab_motion
tool_motion_mode(enum lab_motion motion, struct wlr_tablet_tool *tool)
{
/*
* Absolute positioning doesn't make sense
@ -102,7 +103,7 @@ tool_motion_mode(enum motion motion, struct wlr_tablet_tool *tool)
switch (tool->type) {
case WLR_TABLET_TOOL_TYPE_MOUSE:
case WLR_TABLET_TOOL_TYPE_LENS:
return LAB_TABLET_MOTION_RELATIVE;
return LAB_MOTION_RELATIVE;
default:
return motion;
}
@ -137,7 +138,7 @@ adjust_for_tablet_area(double tablet_width, double tablet_height,
}
static void
adjust_for_rotation(enum rotation rotation, double *x, double *y)
adjust_for_rotation(enum lab_rotation rotation, double *x, double *y)
{
double tmp;
switch (rotation) {
@ -161,7 +162,7 @@ adjust_for_rotation(enum rotation rotation, double *x, double *y)
}
static void
adjust_for_rotation_relative(enum rotation rotation, double *dx, double *dy)
adjust_for_rotation_relative(enum lab_rotation rotation, double *dx, double *dy)
{
double tmp;
switch (rotation) {
@ -220,11 +221,11 @@ tablet_get_coords(struct drawing_tablet *tablet, struct drawing_tablet_tool *too
/* initialize here to avoid a maybe-uninitialized compiler warning */
double lx = -1, ly = -1;
switch (tool->motion_mode) {
case LAB_TABLET_MOTION_ABSOLUTE:
case LAB_MOTION_ABSOLUTE:
wlr_cursor_absolute_to_layout_coords(tablet->seat->cursor,
tablet->wlr_input_device, *x, *y, &lx, &ly);
break;
case LAB_TABLET_MOTION_RELATIVE:
case LAB_MOTION_RELATIVE:
/*
* Deltas dx,dy will be directly passed into wlr_cursor_move,
* so we can add those directly here to determine our future
@ -262,11 +263,11 @@ notify_motion(struct drawing_tablet *tablet, struct drawing_tablet_tool *tool,
}
switch (tool->motion_mode) {
case LAB_TABLET_MOTION_ABSOLUTE:
case LAB_MOTION_ABSOLUTE:
wlr_cursor_warp_absolute(tablet->seat->cursor,
tablet->wlr_input_device, x, y);
break;
case LAB_TABLET_MOTION_RELATIVE:
case LAB_MOTION_RELATIVE:
wlr_cursor_move(tablet->seat->cursor,
tablet->wlr_input_device, dx, dy);
break;
@ -500,12 +501,12 @@ handle_tablet_tool_axis(struct wl_listener *listener, void *data)
}
switch (tool->motion_mode) {
case LAB_TABLET_MOTION_ABSOLUTE:
case LAB_MOTION_ABSOLUTE:
cursor_emulate_move_absolute(tablet->seat,
&ev->tablet->base,
x, y, ev->time_msec);
break;
case LAB_TABLET_MOTION_RELATIVE:
case LAB_MOTION_RELATIVE:
cursor_emulate_move(tablet->seat,
&ev->tablet->base,
dx, dy, ev->time_msec);

7
src/input/touch.c
View file

@ -5,13 +5,16 @@
#include <wlr/types/wlr_seat.h>
#include <wlr/types/wlr_touch.h>
#include <linux/input-event-codes.h>
#include "action.h"
#include "common/macros.h"
#include "common/mem.h"
#include "common/scene-helpers.h"
#include "config/mousebind.h"
#include "config/rcxml.h"
#include "config/touch.h"
#include "idle.h"
#include "labwc.h"
#include "config/mousebind.h"
#include "action.h"
#include "ssd.h"
/* Holds layout -> surface offsets to report motion events in relative coords */
struct touch_point {

33
src/interactive.c
View file

@ -1,5 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
#include <assert.h>
#include "config/rcxml.h"
#include "edges.h"
#include "input/keyboard.h"
#include "labwc.h"
@ -166,11 +167,11 @@ interactive_begin(struct view *view, enum input_mode mode, uint32_t edges)
bool
edge_from_cursor(struct seat *seat, struct output **dest_output,
enum view_edge *edge1, enum view_edge *edge2)
enum lab_edge *edge1, enum lab_edge *edge2)
{
*dest_output = NULL;
*edge1 = VIEW_EDGE_INVALID;
*edge2 = VIEW_EDGE_INVALID;
*edge1 = LAB_EDGE_INVALID;
*edge2 = LAB_EDGE_INVALID;
if (!view_is_floating(seat->server->grabbed_view)) {
return false;
@ -201,28 +202,28 @@ edge_from_cursor(struct seat *seat, struct output **dest_output,
int right = area->x + area->width - cursor_x;
if (top < rc.snap_edge_range) {
*edge1 = VIEW_EDGE_UP;
*edge1 = LAB_EDGE_UP;
} else if (bottom < rc.snap_edge_range) {
*edge1 = VIEW_EDGE_DOWN;
*edge1 = LAB_EDGE_DOWN;
} else if (left < rc.snap_edge_range) {
*edge1 = VIEW_EDGE_LEFT;
*edge1 = LAB_EDGE_LEFT;
} else if (right < rc.snap_edge_range) {
*edge1 = VIEW_EDGE_RIGHT;
*edge1 = LAB_EDGE_RIGHT;
} else {
return false;
}
if (*edge1 == VIEW_EDGE_UP || *edge1 == VIEW_EDGE_DOWN) {
if (*edge1 == LAB_EDGE_UP || *edge1 == LAB_EDGE_DOWN) {
if (left < rc.snap_edge_corner_range) {
*edge2 = VIEW_EDGE_LEFT;
*edge2 = LAB_EDGE_LEFT;
} else if (right < rc.snap_edge_corner_range) {
*edge2 = VIEW_EDGE_RIGHT;
*edge2 = LAB_EDGE_RIGHT;
}
} else if (*edge1 == VIEW_EDGE_LEFT || *edge1 == VIEW_EDGE_RIGHT) {
} else if (*edge1 == LAB_EDGE_LEFT || *edge1 == LAB_EDGE_RIGHT) {
if (top < rc.snap_edge_corner_range) {
*edge2 = VIEW_EDGE_UP;
*edge2 = LAB_EDGE_UP;
} else if (bottom < rc.snap_edge_corner_range) {
*edge2 = VIEW_EDGE_DOWN;
*edge2 = LAB_EDGE_DOWN;
}
}
@ -234,18 +235,18 @@ static bool
snap_to_edge(struct view *view)
{
struct output *output;
enum view_edge edge1, edge2;
enum lab_edge edge1, edge2;
if (!edge_from_cursor(&view->server->seat, &output, &edge1, &edge2)) {
return false;
}
enum view_edge edge = edge1 | edge2;
enum lab_edge edge = edge1 | edge2;
view_set_output(view, output);
/*
* Don't store natural geometry here (it was
* stored already in interactive_begin())
*/
if (edge == VIEW_EDGE_UP && rc.snap_top_maximize) {
if (edge == LAB_EDGE_UP && rc.snap_top_maximize) {
/* <topMaximize> */
view_maximize(view, VIEW_AXIS_BOTH,
/*store_natural_geometry*/ false);

1
src/magnifier.c
View file

@ -8,6 +8,7 @@
#include <wlr/types/wlr_scene.h>
#include <wlr/util/transform.h>
#include "common/box.h"
#include "config/rcxml.h"
#include "labwc.h"
#include "output.h"
#include "theme.h"

1
src/main.c
View file

@ -7,6 +7,7 @@
#include "common/fd-util.h"
#include "common/font.h"
#include "common/spawn.h"
#include "config/rcxml.h"
#include "config/session.h"
#include "labwc.h"
#include "theme.h"

1
src/menu/menu.c
View file

@ -26,6 +26,7 @@
#include "common/spawn.h"
#include "common/string-helpers.h"
#include "common/xml.h"
#include "config/rcxml.h"
#include "labwc.h"
#include "output.h"
#include "workspaces.h"

5
src/output.c
View file

@ -27,6 +27,7 @@
#include "common/macros.h"
#include "common/mem.h"
#include "common/scene-helpers.h"
#include "config/rcxml.h"
#include "labwc.h"
#include "layers.h"
#include "node.h"
@ -977,7 +978,7 @@ output_nearest_to_cursor(struct server *server)
}
struct output *
output_get_adjacent(struct output *output, enum view_edge edge, bool wrap)
output_get_adjacent(struct output *output, enum lab_edge edge, bool wrap)
{
if (!output_is_usable(output)) {
wlr_log(WLR_ERROR,
@ -986,7 +987,7 @@ output_get_adjacent(struct output *output, enum view_edge edge, bool wrap)
}
enum wlr_direction direction;
if (!direction_from_view_edge(edge, &direction)) {
if (!direction_from_edge(edge, &direction)) {
return NULL;
}

17
src/overlay.c
View file

@ -4,6 +4,7 @@
#include <wlr/types/wlr_scene.h>
#include "common/direction.h"
#include "common/lab-scene-rect.h"
#include "config/rcxml.h"
#include "labwc.h"
#include "output.h"
#include "view.h"
@ -96,7 +97,7 @@ inactivate_overlay(struct overlay *overlay)
&overlay->edge_rect.tree->node, false);
}
overlay->active.region = NULL;
overlay->active.edge = VIEW_EDGE_INVALID;
overlay->active.edge = LAB_EDGE_INVALID;
overlay->active.output = NULL;
if (overlay->timer) {
wl_event_source_timer_update(overlay->timer, 0);
@ -117,9 +118,9 @@ show_region_overlay(struct seat *seat, struct region *region)
}
static struct wlr_box
get_edge_snap_box(enum view_edge edge, struct output *output)
get_edge_snap_box(enum lab_edge edge, struct output *output)
{
if (edge == VIEW_EDGE_UP && rc.snap_top_maximize) {
if (edge == LAB_EDGE_UP && rc.snap_top_maximize) {
return output_usable_area_in_layout_coords(output);
} else {
return view_get_edge_snap_box(NULL, output, edge);
@ -130,7 +131,7 @@ static int
handle_edge_overlay_timeout(void *data)
{
struct seat *seat = data;
assert(seat->overlay.active.edge != VIEW_EDGE_INVALID
assert(seat->overlay.active.edge != LAB_EDGE_INVALID
&& seat->overlay.active.output);
struct wlr_box box = get_edge_snap_box(seat->overlay.active.edge,
seat->overlay.active.output);
@ -140,10 +141,10 @@ handle_edge_overlay_timeout(void *data)
static bool
edge_has_adjacent_output_from_cursor(struct seat *seat, struct output *output,
enum view_edge edge)
enum lab_edge edge)
{
enum wlr_direction dir;
if (!direction_from_view_edge(edge, &dir)) {
if (!direction_from_edge(edge, &dir)) {
return false;
}
return wlr_output_layout_adjacent_output(
@ -152,7 +153,7 @@ edge_has_adjacent_output_from_cursor(struct seat *seat, struct output *output,
}
static void
show_edge_overlay(struct seat *seat, enum view_edge edge1, enum view_edge edge2,
show_edge_overlay(struct seat *seat, enum lab_edge edge1, enum lab_edge edge2,
struct output *output)
{
if (!rc.snap_overlay_enabled) {
@ -205,7 +206,7 @@ overlay_update(struct seat *seat)
/* Edge-snapping overlay */
struct output *output;
enum view_edge edge1, edge2;
enum lab_edge edge1, edge2;
if (edge_from_cursor(seat, &output, &edge1, &edge2)) {
show_edge_overlay(seat, edge1, edge2, output);
return;

1
src/placement.c
View file

@ -4,6 +4,7 @@
#include <limits.h>
#include <stdbool.h>
#include "common/mem.h"
#include "config/rcxml.h"
#include "labwc.h"
#include "output.h"
#include "ssd.h"

1
src/regions.c
View file

@ -11,6 +11,7 @@
#include <wlr/util/log.h>
#include "common/list.h"
#include "common/mem.h"
#include "config/rcxml.h"
#include "input/keyboard.h"
#include "labwc.h"
#include "output.h"

4
src/resize-outlines.c
View file

@ -3,8 +3,10 @@
#include "resize-outlines.h"
#include <wlr/types/wlr_scene.h>
#include "common/lab-scene-rect.h"
#include "ssd.h"
#include "labwc.h"
#include "resize-indicator.h"
#include "ssd.h"
#include "theme.h"
bool
resize_outlines_enabled(struct view *view)

3
src/seat.c
View file

@ -16,6 +16,9 @@
#include <wlr/util/log.h>
#include "common/macros.h"
#include "common/mem.h"
#include "config/libinput.h"
#include "config/rcxml.h"
#include "config/touch.h"
#include "input/ime.h"
#include "input/tablet.h"
#include "input/tablet-pad.h"

31
src/snap.c
View file

@ -3,6 +3,7 @@
#include <assert.h>
#include <wlr/util/box.h>
#include "common/border.h"
#include "config/rcxml.h"
#include "edges.h"
#include "labwc.h"
#include "output.h"
@ -50,7 +51,7 @@ check_edge(int *next, struct edge current, struct edge target,
}
void
snap_move_to_edge(struct view *view, enum view_edge direction,
snap_move_to_edge(struct view *view, enum lab_edge direction,
bool snap_to_windows, int *dx, int *dy)
{
assert(view);
@ -79,26 +80,26 @@ snap_move_to_edge(struct view *view, enum view_edge direction,
* needs no further consideration.
*/
switch (direction) {
case VIEW_EDGE_LEFT:
case LAB_EDGE_LEFT:
target.x = usable.x + ssd.left + rc.gap;
if (target.x >= view->pending.x) {
return;
}
break;
case VIEW_EDGE_RIGHT:
case LAB_EDGE_RIGHT:
target.x = usable.x + usable.width
- rc.gap - target.width - ssd.right;
if (target.x <= view->pending.x) {
return;
}
break;
case VIEW_EDGE_UP:
case LAB_EDGE_UP:
target.y = usable.y + ssd.top + rc.gap;
if (target.y >= view->pending.y) {
return;
}
break;
case VIEW_EDGE_DOWN:
case LAB_EDGE_DOWN:
target.y = usable.y + usable.height - rc.gap - ssd.bottom
- view_effective_height(view, /* use_pending */ true);
if (target.y <= view->pending.y) {
@ -133,7 +134,7 @@ snap_move_to_edge(struct view *view, enum view_edge direction,
void
snap_grow_to_next_edge(struct view *view,
enum view_edge direction, struct wlr_box *geo)
enum lab_edge direction, struct wlr_box *geo)
{
assert(view);
assert(!view->shaded);
@ -152,22 +153,22 @@ snap_grow_to_next_edge(struct view *view,
/* First try to grow the view to the relevant edge of its output. */
switch (direction) {
case VIEW_EDGE_LEFT:
case LAB_EDGE_LEFT:
geo->x = usable.x + ssd.left + rc.gap;
geo->width = view->pending.x + view->pending.width - geo->x;
resize_edges = WLR_EDGE_LEFT;
break;
case VIEW_EDGE_RIGHT:
case LAB_EDGE_RIGHT:
geo->width = usable.x + usable.width
- rc.gap - ssd.right - view->pending.x;
resize_edges = WLR_EDGE_RIGHT;
break;
case VIEW_EDGE_UP:
case LAB_EDGE_UP:
geo->y = usable.y + ssd.top + rc.gap;
geo->height = view->pending.y + view->pending.height - geo->y;
resize_edges = WLR_EDGE_TOP;
break;
case VIEW_EDGE_DOWN:
case LAB_EDGE_DOWN:
geo->height = usable.y + usable.height
- rc.gap - ssd.bottom - view->pending.y;
resize_edges = WLR_EDGE_BOTTOM;
@ -213,7 +214,7 @@ snap_grow_to_next_edge(struct view *view,
void
snap_shrink_to_next_edge(struct view *view,
enum view_edge direction, struct wlr_box *geo)
enum lab_edge direction, struct wlr_box *geo)
{
assert(view);
assert(!view->shaded);
@ -228,21 +229,21 @@ snap_shrink_to_next_edge(struct view *view,
* minimum size requirements.
*/
switch (direction) {
case VIEW_EDGE_RIGHT:
case LAB_EDGE_RIGHT:
geo->width = MAX(geo->width / 2, min_width);
geo->x = view->pending.x + view->pending.width - geo->width;
resize_edges = WLR_EDGE_LEFT;
break;
case VIEW_EDGE_LEFT:
case LAB_EDGE_LEFT:
geo->width = MAX(geo->width / 2, min_width);
resize_edges = WLR_EDGE_RIGHT;
break;
case VIEW_EDGE_DOWN:
case LAB_EDGE_DOWN:
geo->height = MAX(geo->height / 2, LAB_MIN_VIEW_HEIGHT);
geo->y = view->pending.y + view->pending.height - geo->height;
resize_edges = WLR_EDGE_TOP;
break;
case VIEW_EDGE_UP:
case LAB_EDGE_UP:
geo->height = MAX(geo->height / 2, LAB_MIN_VIEW_HEIGHT);
resize_edges = WLR_EDGE_BOTTOM;
break;

2
src/ssd/resize-indicator.c
View file

@ -5,9 +5,11 @@
#include <wlr/util/log.h>
#include "common/macros.h"
#include "common/scaled-font-buffer.h"
#include "config/rcxml.h"
#include "labwc.h"
#include "resize-indicator.h"
#include "resize-outlines.h"
#include "theme.h"
#include "view.h"
static void

1
src/ssd/ssd-part.c
View file

@ -7,6 +7,7 @@
#include "common/mem.h"
#include "common/scaled-icon-buffer.h"
#include "common/scaled-img-buffer.h"
#include "config/rcxml.h"
#include "labwc.h"
#include "node.h"
#include "ssd-internal.h"

5
src/ssd/ssd-shadow.c
View file

@ -1,13 +1,14 @@
// SPDX-License-Identifier: GPL-2.0-only
#include <assert.h>
#include <cairo.h>
#include <wlr/types/wlr_scene.h>
#include "labwc.h"
#include "buffer.h"
#include "config/rcxml.h"
#include "labwc.h"
#include "ssd-internal.h"
#include "theme.h"
#include "view.h"
#include <cairo.h>
#define FOR_EACH_STATE(ssd, tmp) FOR_EACH(tmp, \
&(ssd)->shadow.active, \

2
src/ssd/ssd-titlebar.c
View file

@ -5,13 +5,13 @@
#include <string.h>
#include <wlr/render/pixman.h>
#include "buffer.h"
#include "config.h"
#include "common/mem.h"
#include "common/scaled-font-buffer.h"
#include "common/scaled-icon-buffer.h"
#include "common/scaled-img-buffer.h"
#include "common/scene-helpers.h"
#include "common/string-helpers.h"
#include "config/rcxml.h"
#include "desktop-entry.h"
#include "img/img.h"
#include "labwc.h"

3
src/ssd/ssd.c
View file

@ -11,6 +11,7 @@
#include <wlr/types/wlr_scene.h>
#include "common/mem.h"
#include "common/scene-helpers.h"
#include "config/rcxml.h"
#include "labwc.h"
#include "ssd-internal.h"
#include "theme.h"
@ -408,7 +409,7 @@ ssd_part_contains(enum ssd_part_type whole, enum ssd_part_type candidate)
return false;
}
enum ssd_mode
enum lab_ssd_mode
ssd_mode_parse(const char *mode)
{
if (!mode) {

108
src/view.c
View file

@ -14,6 +14,7 @@
#include "common/match.h"
#include "common/mem.h"
#include "common/scene-helpers.h"
#include "config/rcxml.h"
#include "foreign-toplevel/foreign.h"
#include "input/keyboard.h"
#include "labwc.h"
@ -28,6 +29,7 @@
#include "snap-constraints.h"
#include "snap.h"
#include "ssd.h"
#include "theme.h"
#include "window-rules.h"
#include "wlr/util/log.h"
#include "workspaces.h"
@ -96,7 +98,7 @@ view_query_free(struct view_query *query)
}
static bool
query_tristate_match(enum three_state desired, bool actual)
query_tristate_match(enum lab_tristate desired, bool actual)
{
switch (desired) {
case LAB_STATE_ENABLED:
@ -169,11 +171,11 @@ view_matches_query(struct view *view, struct view_query *query)
return false;
}
if (query->tiled == VIEW_EDGE_ANY) {
if (query->tiled == LAB_EDGE_ANY) {
if (!view->tiled) {
return false;
}
} else if (query->tiled != VIEW_EDGE_INVALID) {
} else if (query->tiled != LAB_EDGE_INVALID) {
if (query->tiled != view->tiled) {
return false;
}
@ -204,7 +206,7 @@ view_matches_query(struct view *view, struct view_query *query)
}
}
enum ssd_mode decor = view_get_ssd_mode(view);
enum lab_ssd_mode decor = view_get_ssd_mode(view);
if (query->decoration != LAB_SSD_MODE_INVALID && query->decoration != decor) {
return false;
}
@ -216,11 +218,11 @@ view_matches_query(struct view *view, struct view_query *query)
return false;
}
if (!strcasecmp(query->monitor, "left") &&
output_get_adjacent(current, VIEW_EDGE_LEFT, false) != view->output) {
output_get_adjacent(current, LAB_EDGE_LEFT, false) != view->output) {
return false;
}
if (!strcasecmp(query->monitor, "right") &&
output_get_adjacent(current, VIEW_EDGE_RIGHT, false) != view->output) {
output_get_adjacent(current, LAB_EDGE_RIGHT, false) != view->output) {
return false;
}
if (output_from_name(view->server, query->monitor) != view->output) {
@ -385,7 +387,7 @@ view_wants_focus(struct view *view)
}
bool
view_contains_window_type(struct view *view, enum window_type window_type)
view_contains_window_type(struct view *view, enum lab_window_type window_type)
{
assert(view);
if (view->impl->contains_window_type) {
@ -427,28 +429,28 @@ view_offer_focus(struct view *view)
* They may be called repeatably during output layout changes.
*/
enum view_edge
view_edge_invert(enum view_edge edge)
enum lab_edge
view_edge_invert(enum lab_edge edge)
{
switch (edge) {
case VIEW_EDGE_LEFT:
return VIEW_EDGE_RIGHT;
case VIEW_EDGE_RIGHT:
return VIEW_EDGE_LEFT;
case VIEW_EDGE_UP:
return VIEW_EDGE_DOWN;
case VIEW_EDGE_DOWN:
return VIEW_EDGE_UP;
case VIEW_EDGE_CENTER:
case VIEW_EDGE_INVALID:
case LAB_EDGE_LEFT:
return LAB_EDGE_RIGHT;
case LAB_EDGE_RIGHT:
return LAB_EDGE_LEFT;
case LAB_EDGE_UP:
return LAB_EDGE_DOWN;
case LAB_EDGE_DOWN:
return LAB_EDGE_UP;
case LAB_EDGE_CENTER:
case LAB_EDGE_INVALID:
default:
return VIEW_EDGE_INVALID;
return LAB_EDGE_INVALID;
}
}
struct wlr_box
view_get_edge_snap_box(struct view *view, struct output *output,
enum view_edge edge)
enum lab_edge edge)
{
struct wlr_box usable = output_usable_area_in_layout_coords(output);
int x1 = rc.gap;
@ -456,16 +458,16 @@ view_get_edge_snap_box(struct view *view, struct output *output,
int x2 = usable.width - rc.gap;
int y2 = usable.height - rc.gap;
if (edge & VIEW_EDGE_RIGHT) {
if (edge & LAB_EDGE_RIGHT) {
x1 = (usable.width + rc.gap) / 2;
}
if (edge & VIEW_EDGE_LEFT) {
if (edge & LAB_EDGE_LEFT) {
x2 = (usable.width - rc.gap) / 2;
}
if (edge & VIEW_EDGE_DOWN) {
if (edge & LAB_EDGE_DOWN) {
y1 = (usable.height + rc.gap) / 2;
}
if (edge & VIEW_EDGE_UP) {
if (edge & LAB_EDGE_UP) {
y2 = (usable.height - rc.gap) / 2;
}
@ -1115,7 +1117,7 @@ view_cascade(struct view *view)
void
view_place_by_policy(struct view *view, bool allow_cursor,
enum view_placement_policy policy)
enum lab_placement_policy policy)
{
if (allow_cursor && policy == LAB_PLACE_CURSOR) {
view_move_to_cursor(view);
@ -1458,7 +1460,7 @@ void
view_set_untiled(struct view *view)
{
assert(view);
view->tiled = VIEW_EDGE_INVALID;
view->tiled = LAB_EDGE_INVALID;
view->tiled_region = NULL;
zfree(view->tiled_region_evacuate);
view_notify_tiled(view);
@ -1569,7 +1571,7 @@ view_wants_decorations(struct view *view)
}
void
view_set_decorations(struct view *view, enum ssd_mode mode, bool force_ssd)
view_set_decorations(struct view *view, enum lab_ssd_mode mode, bool force_ssd)
{
assert(view);
@ -1584,7 +1586,7 @@ view_toggle_decorations(struct view *view)
{
assert(view);
enum ssd_mode mode = view_get_ssd_mode(view);
enum lab_ssd_mode mode = view_get_ssd_mode(view);
if (rc.ssd_keep_border && mode == LAB_SSD_MODE_FULL) {
view_set_ssd_mode(view, LAB_SSD_MODE_BORDER);
} else if (mode != LAB_SSD_MODE_NONE) {
@ -1674,7 +1676,7 @@ undecorate(struct view *view)
view->ssd = NULL;
}
enum ssd_mode
enum lab_ssd_mode
view_get_ssd_mode(struct view *view)
{
assert(view);
@ -1689,7 +1691,7 @@ view_get_ssd_mode(struct view *view)
}
void
view_set_ssd_mode(struct view *view, enum ssd_mode mode)
view_set_ssd_mode(struct view *view, enum lab_ssd_mode mode)
{
assert(view);
@ -1974,7 +1976,7 @@ shift_view_to_usable_1d(int size,
}
void
view_move_to_edge(struct view *view, enum view_edge direction, bool snap_to_windows)
view_move_to_edge(struct view *view, enum lab_edge direction, bool snap_to_windows)
{
assert(view);
if (!output_is_usable(view->output)) {
@ -2020,16 +2022,16 @@ view_move_to_edge(struct view *view, enum view_edge direction, bool snap_to_wind
/* Compute the new position in the direction of motion */
direction = view_edge_invert(direction);
switch (direction) {
case VIEW_EDGE_LEFT:
case LAB_EDGE_LEFT:
destination_x = left;
break;
case VIEW_EDGE_RIGHT:
case LAB_EDGE_RIGHT:
destination_x = right - view->pending.width;
break;
case VIEW_EDGE_UP:
case LAB_EDGE_UP:
destination_y = top;
break;
case VIEW_EDGE_DOWN:
case LAB_EDGE_DOWN:
destination_y = bottom
- view_effective_height(view, /* use_pending */ true);
break;
@ -2057,7 +2059,7 @@ view_move_to_edge(struct view *view, enum view_edge direction, bool snap_to_wind
}
void
view_grow_to_edge(struct view *view, enum view_edge direction)
view_grow_to_edge(struct view *view, enum lab_edge direction)
{
assert(view);
/* TODO: allow grow to edge if maximized along the other axis */
@ -2078,7 +2080,7 @@ view_grow_to_edge(struct view *view, enum view_edge direction)
}
void
view_shrink_to_edge(struct view *view, enum view_edge direction)
view_shrink_to_edge(struct view *view, enum lab_edge direction)
{
assert(view);
@ -2118,46 +2120,46 @@ view_axis_parse(const char *direction)
}
}
enum view_edge
enum lab_edge
view_edge_parse(const char *direction, bool tiled, bool any)
{
if (!direction) {
return VIEW_EDGE_INVALID;
return LAB_EDGE_INVALID;
}
if (!strcasecmp(direction, "left")) {
return VIEW_EDGE_LEFT;
return LAB_EDGE_LEFT;
} else if (!strcasecmp(direction, "up")) {
return VIEW_EDGE_UP;
return LAB_EDGE_UP;
} else if (!strcasecmp(direction, "right")) {
return VIEW_EDGE_RIGHT;
return LAB_EDGE_RIGHT;
} else if (!strcasecmp(direction, "down")) {
return VIEW_EDGE_DOWN;
return LAB_EDGE_DOWN;
}
if (any) {
if (!strcasecmp(direction, "any")) {
return VIEW_EDGE_ANY;
return LAB_EDGE_ANY;
}
}
if (tiled) {
if (!strcasecmp(direction, "center")) {
return VIEW_EDGE_CENTER;
return LAB_EDGE_CENTER;
} else if (!strcasecmp(direction, "up-left")) {
return VIEW_EDGE_UPLEFT;
return LAB_EDGE_UPLEFT;
} else if (!strcasecmp(direction, "up-right")) {
return VIEW_EDGE_UPRIGHT;
return LAB_EDGE_UPRIGHT;
} else if (!strcasecmp(direction, "down-left")) {
return VIEW_EDGE_DOWNLEFT;
return LAB_EDGE_DOWNLEFT;
} else if (!strcasecmp(direction, "down-right")) {
return VIEW_EDGE_DOWNRIGHT;
return LAB_EDGE_DOWNRIGHT;
}
}
return VIEW_EDGE_INVALID;
return LAB_EDGE_INVALID;
}
enum view_placement_policy
enum lab_placement_policy
view_placement_parse(const char *policy)
{
if (!policy) {
@ -2178,7 +2180,7 @@ view_placement_parse(const char *policy)
}
void
view_snap_to_edge(struct view *view, enum view_edge edge,
view_snap_to_edge(struct view *view, enum lab_edge edge,
bool across_outputs, bool store_natural_geometry)
{
assert(view);

2
src/workspaces.c
View file

@ -14,11 +14,13 @@
#include "common/graphic-helpers.h"
#include "common/list.h"
#include "common/mem.h"
#include "config/rcxml.h"
#include "input/keyboard.h"
#include "labwc.h"
#include "output.h"
#include "protocols/cosmic-workspaces.h"
#include "protocols/ext-workspace.h"
#include "theme.h"
#include "view.h"
#define COSMIC_WORKSPACES_VERSION 1

25
src/xdg.c
View file

@ -9,6 +9,7 @@
#include "common/array.h"
#include "common/macros.h"
#include "common/mem.h"
#include "config/rcxml.h"
#include "decorations.h"
#include "foreign-toplevel/foreign.h"
#include "labwc.h"
@ -66,7 +67,7 @@ xdg_toplevel_view_get_size_hints(struct view *view)
static bool
xdg_toplevel_view_contains_window_type(struct view *view,
enum window_type window_type)
enum lab_window_type window_type)
{
assert(view);
@ -78,9 +79,9 @@ xdg_toplevel_view_contains_window_type(struct view *view,
|| toplevel->parent;
switch (window_type) {
case NET_WM_WINDOW_TYPE_NORMAL:
case LAB_WINDOW_TYPE_NORMAL:
return !is_dialog;
case NET_WM_WINDOW_TYPE_DIALOG:
case LAB_WINDOW_TYPE_DIALOG:
return is_dialog;
default:
return false;
@ -663,31 +664,31 @@ xdg_toplevel_view_notify_tiled(struct view *view)
*/
if (want_edge) {
switch (view->tiled) {
case VIEW_EDGE_LEFT:
case LAB_EDGE_LEFT:
edge = WLR_EDGE_LEFT | WLR_EDGE_TOP | WLR_EDGE_BOTTOM;
break;
case VIEW_EDGE_RIGHT:
case LAB_EDGE_RIGHT:
edge = WLR_EDGE_RIGHT | WLR_EDGE_TOP | WLR_EDGE_BOTTOM;
break;
case VIEW_EDGE_UP:
case LAB_EDGE_UP:
edge = WLR_EDGE_TOP | WLR_EDGE_LEFT | WLR_EDGE_RIGHT;
break;
case VIEW_EDGE_DOWN:
case LAB_EDGE_DOWN:
edge = WLR_EDGE_BOTTOM | WLR_EDGE_LEFT | WLR_EDGE_RIGHT;
break;
case VIEW_EDGE_UPLEFT:
case LAB_EDGE_UPLEFT:
edge = WLR_EDGE_TOP | WLR_EDGE_LEFT;
break;
case VIEW_EDGE_UPRIGHT:
case LAB_EDGE_UPRIGHT:
edge = WLR_EDGE_TOP | WLR_EDGE_RIGHT;
break;
case VIEW_EDGE_DOWNLEFT:
case LAB_EDGE_DOWNLEFT:
edge = WLR_EDGE_BOTTOM | WLR_EDGE_LEFT;
break;
case VIEW_EDGE_DOWNRIGHT:
case LAB_EDGE_DOWNRIGHT:
edge = WLR_EDGE_BOTTOM | WLR_EDGE_RIGHT;
break;
/* TODO: VIEW_EDGE_CENTER? */
/* TODO: LAB_EDGE_CENTER? */
default:
edge = WLR_EDGE_NONE;
}

34
src/xwayland.c
View file

@ -41,40 +41,40 @@ static void xwayland_view_unmap(struct view *view, bool client_request);
static bool
xwayland_view_contains_window_type(struct view *view,
enum window_type window_type)
enum lab_window_type window_type)
{
/* Compile-time check that the enum types match */
static_assert(NET_WM_WINDOW_TYPE_DESKTOP ==
static_assert(LAB_WINDOW_TYPE_DESKTOP ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_DESKTOP
&& NET_WM_WINDOW_TYPE_DOCK ==
&& LAB_WINDOW_TYPE_DOCK ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_DOCK
&& NET_WM_WINDOW_TYPE_TOOLBAR ==
&& LAB_WINDOW_TYPE_TOOLBAR ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_TOOLBAR
&& NET_WM_WINDOW_TYPE_MENU ==
&& LAB_WINDOW_TYPE_MENU ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_MENU
&& NET_WM_WINDOW_TYPE_UTILITY ==
&& LAB_WINDOW_TYPE_UTILITY ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_UTILITY
&& NET_WM_WINDOW_TYPE_SPLASH ==
&& LAB_WINDOW_TYPE_SPLASH ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_SPLASH
&& NET_WM_WINDOW_TYPE_DIALOG ==
&& LAB_WINDOW_TYPE_DIALOG ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_DIALOG
&& NET_WM_WINDOW_TYPE_DROPDOWN_MENU ==
&& LAB_WINDOW_TYPE_DROPDOWN_MENU ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_DROPDOWN_MENU
&& NET_WM_WINDOW_TYPE_POPUP_MENU ==
&& LAB_WINDOW_TYPE_POPUP_MENU ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_POPUP_MENU
&& NET_WM_WINDOW_TYPE_TOOLTIP ==
&& LAB_WINDOW_TYPE_TOOLTIP ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_TOOLTIP
&& NET_WM_WINDOW_TYPE_NOTIFICATION ==
&& LAB_WINDOW_TYPE_NOTIFICATION ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_NOTIFICATION
&& NET_WM_WINDOW_TYPE_COMBO ==
&& LAB_WINDOW_TYPE_COMBO ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_COMBO
&& NET_WM_WINDOW_TYPE_DND ==
&& LAB_WINDOW_TYPE_DND ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_DND
&& NET_WM_WINDOW_TYPE_NORMAL ==
&& LAB_WINDOW_TYPE_NORMAL ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_NORMAL
&& WINDOW_TYPE_LEN ==
&& LAB_WINDOW_TYPE_LEN ==
(int)WLR_XWAYLAND_NET_WM_WINDOW_TYPE_NORMAL + 1,
"enum window_type does not match wlr_xwayland_net_wm_window_type");
"lab_window_type does not match wlr_xwayland_net_wm_window_type");
assert(view);
struct wlr_xwayland_surface *surface = xwayland_surface_from_view(view);