#define LABWC_DIRECTION_H
#include <wlr/types/wlr_output_layout.h>
-#include "view.h"
+#include "config/types.h"
-bool direction_from_view_edge(enum view_edge edge, enum wlr_direction *direction);
+bool direction_from_edge(enum lab_edge edge, enum wlr_direction *direction);
enum wlr_direction direction_get_opposite(enum wlr_direction direction);
#endif /* LABWC_DIRECTION_H */
/* SPDX-License-Identifier: GPL-2.0-only */
#ifndef LABWC_PARSE_BOOL_H
#define LABWC_PARSE_BOOL_H
+
#include <stdbool.h>
-#include "common/three-state.h"
+#include "config/types.h"
/**
- * parse_three_state() - Parse boolean value of string as a three-state enum.
+ * parse_tristate() - Parse boolean value of string as a three-state enum.
* @string: String to interpret. This check is case-insensitive.
*
* Return: LAB_STATE_DISABLED for false; LAB_STATE_ENABLED for true;
* LAB_STATE_UNSPECIFIED for non-boolean
*/
-enum three_state parse_three_state(const char *str);
+enum lab_tristate parse_tristate(const char *str);
/**
* parse_bool() - Parse boolean value of string.
+++ /dev/null
-/* SPDX-License-Identifier: GPL-2.0-only */
-#ifndef LABWC_THREE_STATE_H
-#define LABWC_THREE_STATE_H
-
-enum three_state {
- LAB_STATE_UNSPECIFIED = 0,
- LAB_STATE_ENABLED,
- LAB_STATE_DISABLED
-};
-
-#endif /* LABWC_THREE_STATE_H */
#define LABWC_RCXML_H
#include <stdbool.h>
-#include <stdio.h>
#include <wayland-server-core.h>
+#include <wlr/util/box.h>
#include <libxml/tree.h>
#include "common/border.h"
#include "common/buf.h"
#include "common/font.h"
-#include "common/three-state.h"
-#include "config/touch.h"
-#include "config/tablet.h"
-#include "config/tablet-tool.h"
-#include "config/libinput.h"
-#include "resize-indicator.h"
+#include "config/types.h"
#include "ssd.h"
-#include "theme.h"
-
-enum view_placement_policy {
- LAB_PLACE_INVALID = 0,
- LAB_PLACE_CENTER,
- LAB_PLACE_CURSOR,
- LAB_PLACE_AUTOMATIC,
- LAB_PLACE_CASCADE,
-};
+
+#define BUTTON_MAP_MAX 16
enum adaptive_sync_mode {
LAB_ADAPTIVE_SYNC_DISABLED,
LAB_ADAPTIVE_SYNC_FULLSCREEN,
};
+enum resize_indicator_mode {
+ LAB_RESIZE_INDICATOR_NEVER = 0,
+ LAB_RESIZE_INDICATOR_ALWAYS,
+ LAB_RESIZE_INDICATOR_NON_PIXEL
+};
+
enum tearing_mode {
LAB_TEARING_DISABLED = 0,
LAB_TEARING_ENABLED,
(LAB_TILING_EVENTS_REGION | LAB_TILING_EVENTS_EDGE),
};
+struct button_map_entry {
+ uint32_t from;
+ uint32_t to;
+};
+
struct title_button {
enum ssd_part_type type;
struct wl_list link;
enum tearing_mode allow_tearing;
bool auto_enable_outputs;
bool reuse_output_mode;
- enum view_placement_policy placement_policy;
+ enum lab_placement_policy placement_policy;
bool xwayland_persistence;
bool primary_selection;
int placement_cascade_offset_x;
/* keyboard */
int repeat_rate;
int repeat_delay;
- enum three_state kb_numlock_enable;
+ enum lab_tristate kb_numlock_enable;
bool kb_layout_per_window;
struct wl_list keybinds; /* struct keybind.link */
bool force_mouse_emulation;
char *output_name;
struct wlr_fbox box;
- enum rotation rotation;
+ enum lab_rotation rotation;
uint16_t button_map_count;
struct button_map_entry button_map[BUTTON_MAP_MAX];
} tablet;
struct tablet_tool_config {
- enum motion motion;
+ enum lab_motion motion;
double relative_motion_sensitivity;
} tablet_tool;
#ifndef LABWC_TABLET_TOOL_CONFIG_H
#define LABWC_TABLET_TOOL_CONFIG_H
-#include <stdint.h>
+#include "config/types.h"
-enum motion {
- LAB_TABLET_MOTION_ABSOLUTE = 0,
- LAB_TABLET_MOTION_RELATIVE,
-};
-
-enum motion tablet_parse_motion(const char *name);
+enum lab_motion tablet_parse_motion(const char *name);
#endif /* LABWC_TABLET_TOOL_CONFIG_H */
#define LABWC_TABLET_CONFIG_H
#include <stdint.h>
-
-enum rotation {
- LAB_ROTATE_NONE = 0,
- LAB_ROTATE_90,
- LAB_ROTATE_180,
- LAB_ROTATE_270,
-};
-
-#define BUTTON_MAP_MAX 16
-struct button_map_entry {
- uint32_t from;
- uint32_t to;
-};
+#include "config/types.h"
double tablet_get_dbl_if_positive(const char *content, const char *name);
-enum rotation tablet_parse_rotation(int value);
+enum lab_rotation tablet_parse_rotation(int value);
uint32_t tablet_button_from_str(const char *button);
void tablet_button_mapping_add(uint32_t from, uint32_t to);
void tablet_load_default_button_mappings(void);
--- /dev/null
+/* SPDX-License-Identifier: GPL-2.0-only */
+#ifndef LABWC_CONFIG_TYPES_H
+#define LABWC_CONFIG_TYPES_H
+
+/*
+ * Shared (basic) types related to user configuration.
+ *
+ * Please try to keep dependencies on other headers minimal,
+ * since config/types.h gets included in many source files.
+ *
+ * For the full config struct, see config/rcxml.h.
+ */
+
+/**
+ * Edges to which a view can be snapped. "Any" is used as
+ * a catch-all for every valid edge in order to simplify certain
+ * types of conditionals, but it is only valid for a selection
+ * of options in rc.xml.
+ */
+enum lab_edge {
+ LAB_EDGE_INVALID = 0,
+
+ LAB_EDGE_LEFT = (1 << 0),
+ LAB_EDGE_RIGHT = (1 << 1),
+ LAB_EDGE_UP = (1 << 2),
+ LAB_EDGE_DOWN = (1 << 3),
+ LAB_EDGE_CENTER = (1 << 4),
+ LAB_EDGE_ANY = (1 << 5),
+
+ LAB_EDGE_UPLEFT = (LAB_EDGE_UP | LAB_EDGE_LEFT),
+ LAB_EDGE_UPRIGHT = (LAB_EDGE_UP | LAB_EDGE_RIGHT),
+ LAB_EDGE_DOWNLEFT = (LAB_EDGE_DOWN | LAB_EDGE_LEFT),
+ LAB_EDGE_DOWNRIGHT = (LAB_EDGE_DOWN | LAB_EDGE_RIGHT),
+};
+
+enum lab_motion {
+ LAB_MOTION_ABSOLUTE = 0,
+ LAB_MOTION_RELATIVE,
+};
+
+enum lab_placement_policy {
+ LAB_PLACE_INVALID = 0,
+ LAB_PLACE_CENTER,
+ LAB_PLACE_CURSOR,
+ LAB_PLACE_AUTOMATIC,
+ LAB_PLACE_CASCADE,
+};
+
+enum lab_rotation {
+ LAB_ROTATE_NONE = 0,
+ LAB_ROTATE_90,
+ LAB_ROTATE_180,
+ LAB_ROTATE_270,
+};
+
+enum lab_ssd_mode {
+ LAB_SSD_MODE_INVALID,
+ LAB_SSD_MODE_NONE,
+ LAB_SSD_MODE_BORDER,
+ LAB_SSD_MODE_FULL,
+};
+
+enum lab_tristate {
+ LAB_STATE_UNSPECIFIED = 0,
+ LAB_STATE_ENABLED,
+ LAB_STATE_DISABLED
+};
+
+/* All criteria is applied in AND logic */
+enum lab_view_criteria {
+ /* No filter -> all focusable views */
+ LAB_VIEW_CRITERIA_NONE = 0,
+
+ /*
+ * Includes always-on-top views, e.g.
+ * what is visible on the current workspace
+ */
+ LAB_VIEW_CRITERIA_CURRENT_WORKSPACE = 1 << 0,
+
+ /* Positive criteria */
+ LAB_VIEW_CRITERIA_FULLSCREEN = 1 << 1,
+ LAB_VIEW_CRITERIA_ALWAYS_ON_TOP = 1 << 2,
+ LAB_VIEW_CRITERIA_ROOT_TOPLEVEL = 1 << 3,
+
+ /* Negative criteria */
+ LAB_VIEW_CRITERIA_NO_ALWAYS_ON_TOP = 1 << 6,
+ LAB_VIEW_CRITERIA_NO_SKIP_WINDOW_SWITCHER = 1 << 7,
+ LAB_VIEW_CRITERIA_NO_OMNIPRESENT = 1 << 8,
+};
+
+/*
+ * Window types are based on the NET_WM constants from X11. See:
+ * https://specifications.freedesktop.org/wm-spec/1.4/ar01s05.html#id-1.6.7
+ *
+ * The enum constants are intended to match wlr_xwayland_net_wm_window_type.
+ * Redefining the same constants here may seem redundant, but is necessary
+ * to make them available even in builds with xwayland support disabled.
+ */
+enum lab_window_type {
+ LAB_WINDOW_TYPE_DESKTOP = 0,
+ LAB_WINDOW_TYPE_DOCK,
+ LAB_WINDOW_TYPE_TOOLBAR,
+ LAB_WINDOW_TYPE_MENU,
+ LAB_WINDOW_TYPE_UTILITY,
+ LAB_WINDOW_TYPE_SPLASH,
+ LAB_WINDOW_TYPE_DIALOG,
+ LAB_WINDOW_TYPE_DROPDOWN_MENU,
+ LAB_WINDOW_TYPE_POPUP_MENU,
+ LAB_WINDOW_TYPE_TOOLTIP,
+ LAB_WINDOW_TYPE_NOTIFICATION,
+ LAB_WINDOW_TYPE_COMBO,
+ LAB_WINDOW_TYPE_DND,
+ LAB_WINDOW_TYPE_NORMAL,
+
+ LAB_WINDOW_TYPE_LEN
+};
+
+#endif /* LABWC_CONFIG_TYPES_H */
*/
bool force_mouse_emulation;
- enum motion motion_mode;
+ enum lab_motion motion_mode;
double x, y, dx, dy;
double distance;
double pressure;
* Returns the edge to snap a window to.
* For example, if the output-relative cursor position (x,y) fulfills
* x <= (<snapping><cornerRange>) and y <= (<snapping><range>),
- * then edge1=VIEW_EDGE_UP and edge2=VIEW_EDGE_LEFT.
+ * then edge1=LAB_EDGE_UP and edge2=LAB_EDGE_LEFT.
* The value of (edge1|edge2) can be passed to view_snap_to_edge().
*/
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);
void handle_tearing_new_object(struct wl_listener *listener, void *data);
#include <wlr/types/wlr_output.h>
-enum view_edge;
+enum lab_edge;
#define LAB_NR_LAYERS (4)
* reference instead.
*/
struct output *output_get_adjacent(struct output *output,
- enum view_edge edge, bool wrap);
+ enum lab_edge edge, bool wrap);
bool output_is_usable(struct output *output);
void output_update_usable_area(struct output *output);
struct region *region;
/* Snap-to-edge overlay */
- enum view_edge edge;
+ enum lab_edge edge;
struct output *output;
} active;
struct server;
struct view;
-enum resize_indicator_mode {
- LAB_RESIZE_INDICATOR_NEVER = 0,
- LAB_RESIZE_INDICATOR_ALWAYS,
- LAB_RESIZE_INDICATOR_NON_PIXEL
-};
-
void resize_indicator_reconfigure(struct server *server);
void resize_indicator_show(struct view *view);
void resize_indicator_update(struct view *view);
struct wlr_box;
void snap_move_to_edge(struct view *view,
- enum view_edge direction, bool snap_to_windows, int *dx, int *dy);
+ enum lab_edge direction, bool snap_to_windows, int *dx, int *dy);
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);
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);
void snap_invalidate_edge_cache(struct view *view);
void snap_update_cache_geometry(struct view *view);
#include <wlr/util/box.h>
#include "common/macros.h"
#include "ssd.h"
+#include "theme.h"
#include "view.h"
#define FOR_EACH(tmp, ...) \
LAB_SSD_END_MARKER
};
-enum ssd_mode {
- LAB_SSD_MODE_INVALID,
- LAB_SSD_MODE_NONE,
- LAB_SSD_MODE_BORDER,
- LAB_SSD_MODE_FULL,
-};
-
/* Forward declare arguments */
struct ssd;
struct ssd_button;
struct wlr_scene_node *node, struct wlr_cursor *cursor);
uint32_t ssd_resize_edges(enum ssd_part_type type);
bool ssd_part_contains(enum ssd_part_type whole, enum ssd_part_type candidate);
-enum ssd_mode ssd_mode_parse(const char *mode);
+enum lab_ssd_mode ssd_mode_parse(const char *mode);
/* TODO: clean up / update */
struct border ssd_thickness(struct view *view);
#ifndef LABWC_VIEW_H
#define LABWC_VIEW_H
-#include "config/rcxml.h"
-#include "config.h"
-#include "ssd.h"
#include <stdbool.h>
#include <stdint.h>
#include <wayland-util.h>
#include <wlr/util/box.h>
#include <xkbcommon/xkbcommon.h>
-#include "common/three-state.h"
+#include "config.h"
+#include "config/types.h"
#define LAB_MIN_VIEW_HEIGHT 60
VIEW_AXIS_INVALID = (1 << 2),
};
-/**
- * Edges to which a view can be snapped to. "All" is used as
- * a catchall for every valid edge in order to simplify certain
- * types of conditionals, but it is only valid for a selection
- * of options in rc.xml.
- */
-enum view_edge {
- VIEW_EDGE_INVALID = 0,
-
- VIEW_EDGE_LEFT = (1 << 0),
- VIEW_EDGE_RIGHT = (1 << 1),
- VIEW_EDGE_UP = (1 << 2),
- VIEW_EDGE_DOWN = (1 << 3),
- VIEW_EDGE_CENTER = (1 << 4),
- VIEW_EDGE_ANY = (1 << 5),
- VIEW_EDGE_UPLEFT = (VIEW_EDGE_UP | VIEW_EDGE_LEFT),
- VIEW_EDGE_UPRIGHT = (VIEW_EDGE_UP | VIEW_EDGE_RIGHT),
- VIEW_EDGE_DOWNLEFT = (VIEW_EDGE_DOWN | VIEW_EDGE_LEFT),
- VIEW_EDGE_DOWNRIGHT = (VIEW_EDGE_DOWN | VIEW_EDGE_RIGHT),
-};
-
enum view_wants_focus {
/* View does not want focus */
VIEW_WANTS_FOCUS_NEVER = 0,
VIEW_WANTS_FOCUS_UNLIKELY,
};
-/*
- * Window types are based on the NET_WM constants from X11. See:
- * https://specifications.freedesktop.org/wm-spec/1.4/ar01s05.html#id-1.6.7
- *
- * The enum constants are intended to match wlr_xwayland_net_wm_window_type.
- * Redefining the same constants here may seem redundant, but is necessary
- * to make them available even in builds with xwayland support disabled.
- */
-enum window_type {
- NET_WM_WINDOW_TYPE_DESKTOP = 0,
- NET_WM_WINDOW_TYPE_DOCK,
- NET_WM_WINDOW_TYPE_TOOLBAR,
- NET_WM_WINDOW_TYPE_MENU,
- NET_WM_WINDOW_TYPE_UTILITY,
- NET_WM_WINDOW_TYPE_SPLASH,
- NET_WM_WINDOW_TYPE_DIALOG,
- NET_WM_WINDOW_TYPE_DROPDOWN_MENU,
- NET_WM_WINDOW_TYPE_POPUP_MENU,
- NET_WM_WINDOW_TYPE_TOOLTIP,
- NET_WM_WINDOW_TYPE_NOTIFICATION,
- NET_WM_WINDOW_TYPE_COMBO,
- NET_WM_WINDOW_TYPE_DND,
- NET_WM_WINDOW_TYPE_NORMAL,
-
- WINDOW_TYPE_LEN
-};
-
struct view;
struct wlr_surface;
struct foreign_toplevel;
bool (*has_strut_partial)(struct view *self);
/* returns true if view declared itself a window type */
bool (*contains_window_type)(struct view *view,
- enum window_type window_type);
+ enum lab_window_type window_type);
/* returns the client pid that this view belongs to */
pid_t (*get_pid)(struct view *view);
};
enum view_axis maximized;
bool fullscreen;
bool tearing_hint;
- enum three_state force_tearing;
+ enum lab_tristate force_tearing;
bool visible_on_all_workspaces;
- enum view_edge tiled;
+ enum lab_edge tiled;
uint32_t edges_visible; /* enum wlr_edges bitset */
bool inhibits_keybinds; /* also inhibits mousebinds */
xkb_layout_index_t keyboard_layout;
int window_type;
char *sandbox_engine;
char *sandbox_app_id;
- enum three_state shaded;
+ enum lab_tristate shaded;
enum view_axis maximized;
- enum three_state iconified;
- enum three_state focused;
- enum three_state omnipresent;
- enum view_edge tiled;
+ enum lab_tristate iconified;
+ enum lab_tristate focused;
+ enum lab_tristate omnipresent;
+ enum lab_edge tiled;
char *tiled_region;
char *desktop;
- enum ssd_mode decoration;
+ enum lab_ssd_mode decoration;
char *monitor;
};
struct wl_listener new_popup;
};
-/* All criteria is applied in AND logic */
-enum lab_view_criteria {
- /* No filter -> all focusable views */
- LAB_VIEW_CRITERIA_NONE = 0,
-
- /*
- * Includes always-on-top views, e.g.
- * what is visible on the current workspace
- */
- LAB_VIEW_CRITERIA_CURRENT_WORKSPACE = 1 << 0,
-
- /* Positive criteria */
- LAB_VIEW_CRITERIA_FULLSCREEN = 1 << 1,
- LAB_VIEW_CRITERIA_ALWAYS_ON_TOP = 1 << 2,
- LAB_VIEW_CRITERIA_ROOT_TOPLEVEL = 1 << 3,
-
- /* Negative criteria */
- LAB_VIEW_CRITERIA_NO_ALWAYS_ON_TOP = 1 << 6,
- LAB_VIEW_CRITERIA_NO_SKIP_WINDOW_SWITCHER = 1 << 7,
- LAB_VIEW_CRITERIA_NO_OMNIPRESENT = 1 << 8,
-};
-
/**
* view_from_wlr_surface() - returns the view associated with a
* wlr_surface, or NULL if the surface has no associated view.
enum lab_view_criteria criteria);
enum view_wants_focus view_wants_focus(struct view *view);
-bool view_contains_window_type(struct view *view, enum window_type window_type);
+bool view_contains_window_type(struct view *view, enum lab_window_type window_type);
/**
* view_edge_invert() - select the opposite of a provided edge
*
- * VIEW_EDGE_CENTER and VIEW_EDGE_INVALID both map to VIEW_EDGE_INVALID.
+ * LAB_EDGE_CENTER and LAB_EDGE_INVALID both map to LAB_EDGE_INVALID.
*
* @edge: edge to be inverted
*/
-enum view_edge view_edge_invert(enum view_edge edge);
+enum lab_edge view_edge_invert(enum lab_edge edge);
/* If view is NULL, the size of SSD is not considered */
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 view_get_region_snap_box(struct view *view, struct region *region);
/**
void view_offer_focus(struct view *view);
struct wlr_box view_get_edge_snap_box(struct view *view, struct output *output,
- enum view_edge edge);
+ enum lab_edge edge);
void mappable_connect(struct mappable *mappable, struct wlr_surface *surface,
wl_notify_func_t notify_map, wl_notify_func_t notify_unmap);
* @policy: placement policy to apply
*/
void view_place_by_policy(struct view *view, bool allow_cursor,
- enum view_placement_policy policy);
+ enum lab_placement_policy policy);
void view_constrain_size_to_that_of_usable_area(struct view *view);
void view_restore_to(struct view *view, struct wlr_box geometry);
bool view_is_tiled_and_notify_tiled(struct view *view);
bool view_is_floating(struct view *view);
void view_move_to_workspace(struct view *view, struct workspace *workspace);
-enum ssd_mode view_get_ssd_mode(struct view *view);
-void view_set_ssd_mode(struct view *view, enum ssd_mode mode);
-void view_set_decorations(struct view *view, enum ssd_mode mode, bool force_ssd);
+enum lab_ssd_mode view_get_ssd_mode(struct view *view);
+void view_set_ssd_mode(struct view *view, enum lab_ssd_mode mode);
+void view_set_decorations(struct view *view, enum lab_ssd_mode mode, bool force_ssd);
void view_toggle_fullscreen(struct view *view);
void view_invalidate_last_layout_geometry(struct view *view);
void view_adjust_for_layout_change(struct view *view);
-void view_move_to_edge(struct view *view, enum view_edge direction, bool snap_to_windows);
-void view_grow_to_edge(struct view *view, enum view_edge direction);
-void view_shrink_to_edge(struct view *view, enum view_edge direction);
-void view_snap_to_edge(struct view *view, enum view_edge direction,
+void view_move_to_edge(struct view *view, enum lab_edge direction, bool snap_to_windows);
+void view_grow_to_edge(struct view *view, enum lab_edge direction);
+void view_shrink_to_edge(struct view *view, enum lab_edge direction);
+void view_snap_to_edge(struct view *view, enum lab_edge direction,
bool across_outputs, bool store_natural_geometry);
void view_snap_to_region(struct view *view, struct region *region, bool store_natural_geometry);
void view_move_to_output(struct view *view, struct output *output);
void view_destroy(struct view *view);
enum view_axis view_axis_parse(const char *direction);
-enum view_edge view_edge_parse(const char *direction, bool tiled, bool any);
-enum view_placement_policy view_placement_parse(const char *policy);
+enum lab_edge view_edge_parse(const char *direction, bool tiled, bool any);
+enum lab_placement_policy view_placement_parse(const char *policy);
/* xdg.c */
struct wlr_xdg_surface *xdg_surface_from_view(struct view *view);
#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"
#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,
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 {
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 {
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 {
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)",
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);
}
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);
}
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
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;
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);
}
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);
#include "common/list.h"
#include "common/mem.h"
#include "common/string-helpers.h"
+#include "config/rcxml.h"
#include "labwc.h"
struct dir {
#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:
#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;
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;
}
#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"
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;
}
} 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);
} 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;
}
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;
#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[] = {
#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;
}
return value;
}
-enum rotation
+enum lab_rotation
tablet_parse_rotation(int value)
{
switch (value) {
// 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"
#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"
// 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"
#include "common/macros.h"
#include "common/mem.h"
#include "common/string-helpers.h"
+#include "config/rcxml.h"
#include "img/img.h"
#include "labwc.h"
#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"
#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"
#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"
#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"
#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"
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
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;
}
}
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) {
}
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) {
/* 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
}
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;
}
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);
#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 {
// SPDX-License-Identifier: GPL-2.0-only
#include <assert.h>
+#include "config/rcxml.h"
#include "edges.h"
#include "input/keyboard.h"
#include "labwc.h"
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;
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;
}
}
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);
#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"
#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"
#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"
#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"
}
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,
}
enum wlr_direction direction;
- if (!direction_from_view_edge(edge, &direction)) {
+ if (!direction_from_edge(edge, &direction)) {
return NULL;
}
#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"
&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);
}
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);
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);
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(
}
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) {
/* 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;
#include <limits.h>
#include <stdbool.h>
#include "common/mem.h"
+#include "config/rcxml.h"
#include "labwc.h"
#include "output.h"
#include "ssd.h"
#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"
#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)
#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"
#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"
}
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);
* 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) {
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);
/* 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;
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);
* 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;
#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
#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"
// 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, \
#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"
#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"
return false;
}
-enum ssd_mode
+enum lab_ssd_mode
ssd_mode_parse(const char *mode)
{
if (!mode) {
#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"
#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"
}
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:
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;
}
}
}
- 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;
}
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) {
}
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) {
* 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;
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;
}
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);
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);
}
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);
{
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) {
view->ssd = NULL;
}
-enum ssd_mode
+enum lab_ssd_mode
view_get_ssd_mode(struct view *view)
{
assert(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);
}
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)) {
/* 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;
}
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 */
}
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);
}
}
-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) {
}
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);
#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
#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"
static bool
xdg_toplevel_view_contains_window_type(struct view *view,
- enum window_type window_type)
+ enum lab_window_type window_type)
{
assert(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;
*/
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;
}
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);
projects / proto / labwc.git / commitdiff