--- /dev/null
+/* SPDX-License-Identifier: GPL-2.0-only */
+#ifndef LABWC_NODE_TYPE_H
+#define LABWC_NODE_TYPE_H
+
+#include "common/edge.h"
+
+/*
+ * In labwc, "node type" indicates the role of a wlr_scene_node in the
+ * overall desktop. It also maps more-or-less to the openbox concept of
+ * "context" (as used when defining mouse bindings).
+ *
+ * Some types (BUTTON, BORDER, etc.) refer to groups or categories of
+ * other node types rather than individual nodes. These categories are
+ * defined as ranges (e.g. BUTTON means anything from BUTTON_FIRST to
+ * BUTTON_LAST), therefore order is significant.
+ *
+ * Be sure to keep node_type_contains() in sync with any changes!
+ */
+enum lab_node_type {
+ LAB_NODE_NONE = 0,
+
+ LAB_NODE_BUTTON_CLOSE = 1,
+ LAB_NODE_BUTTON_MAXIMIZE,
+ LAB_NODE_BUTTON_ICONIFY,
+ LAB_NODE_BUTTON_WINDOW_ICON,
+ LAB_NODE_BUTTON_WINDOW_MENU,
+ LAB_NODE_BUTTON_SHADE,
+ LAB_NODE_BUTTON_OMNIPRESENT,
+ LAB_NODE_BUTTON_FIRST = LAB_NODE_BUTTON_CLOSE,
+ LAB_NODE_BUTTON_LAST = LAB_NODE_BUTTON_OMNIPRESENT,
+ LAB_NODE_BUTTON,
+
+ LAB_NODE_TITLEBAR,
+ LAB_NODE_TITLE,
+
+ LAB_NODE_CORNER_TOP_LEFT,
+ LAB_NODE_CORNER_TOP_RIGHT,
+ LAB_NODE_CORNER_BOTTOM_RIGHT,
+ LAB_NODE_CORNER_BOTTOM_LEFT,
+ LAB_NODE_BORDER_TOP,
+ LAB_NODE_BORDER_RIGHT,
+ LAB_NODE_BORDER_BOTTOM,
+ LAB_NODE_BORDER_LEFT,
+ LAB_NODE_BORDER,
+
+ LAB_NODE_CLIENT,
+ LAB_NODE_FRAME,
+ LAB_NODE_ROOT,
+ LAB_NODE_MENU,
+ LAB_NODE_OSD,
+ LAB_NODE_LAYER_SURFACE,
+ LAB_NODE_LAYER_SUBSURFACE,
+ LAB_NODE_UNMANAGED,
+ LAB_NODE_ALL,
+};
+
+enum lab_node_type node_type_parse(const char *context);
+
+bool node_type_contains(enum lab_node_type whole, enum lab_node_type part);
+
+enum lab_edge node_type_to_edges(enum lab_node_type type);
+
+#endif /* LABWC_NODE_TYPE_H */
#ifndef LABWC_MOUSEBIND_H
#define LABWC_MOUSEBIND_H
+#include <stdbool.h>
#include <wayland-util.h>
-#include "ssd.h"
-#include "config/keybind.h"
+#include "common/node-type.h"
enum mouse_event {
MOUSE_ACTION_NONE = 0,
};
struct mousebind {
- enum ssd_part_type context;
+ enum lab_node_type context;
/* ex: BTN_LEFT, BTN_RIGHT from linux/input_event_codes.h */
uint32_t button;
#include "common/border.h"
#include "common/buf.h"
#include "common/font.h"
+#include "common/node-type.h"
#include "config/types.h"
-#include "ssd.h"
#define BUTTON_MAP_MAX 16
};
struct title_button {
- enum ssd_part_type type;
+ enum lab_node_type type;
struct wl_list link;
};
#include <wlr/types/wlr_cursor.h>
#include "common/edge.h"
-#include "ssd.h"
+#include "common/node-type.h"
struct view;
struct seat;
struct view *view;
struct wlr_scene_node *node;
struct wlr_surface *surface;
- enum ssd_part_type type;
+ enum lab_node_type type;
double sx, sy;
};
#define LABWC_SSD_INTERNAL_H
#include <wlr/util/box.h>
-#include "ssd.h"
+#include "common/border.h"
#include "theme.h"
#include "view.h"
* the cursor.
*/
struct ssd_part {
- enum ssd_part_type type;
+ enum lab_node_type type;
struct view *view;
/* This part represented in scene graph */
struct wlr_scene_tree;
/* SSD internal helpers to create various SSD elements */
-struct ssd_part *attach_ssd_part(enum ssd_part_type type, struct view *view,
+struct ssd_part *attach_ssd_part(enum lab_node_type type, struct view *view,
struct wlr_scene_node *node);
struct ssd_part_button *attach_ssd_part_button(struct wl_list *button_parts,
- enum ssd_part_type type, struct wlr_scene_tree *parent,
+ enum lab_node_type type, struct wlr_scene_tree *parent,
struct lab_img *imgs[LAB_BS_ALL + 1], int x, int y,
struct view *view);
struct ssd_part_button *button_try_from_ssd_part(struct ssd_part *part);
#define LABWC_SSD_H
#include "common/border.h"
-#include "common/edge.h"
+#include "common/node-type.h"
#include "config/types.h"
enum ssd_active_state {
*/
#define SSD_SHADOW_INSET 0.3
-/*
- * Sequence these according to the order they should be processed for
- * press and hover events. Bear in mind that some of their respective
- * interactive areas overlap, so for example buttons need to come before title.
- */
-enum ssd_part_type {
- LAB_SSD_NONE = 0,
-
- LAB_SSD_BUTTON_CLOSE = 1,
- LAB_SSD_BUTTON_MAXIMIZE,
- LAB_SSD_BUTTON_ICONIFY,
- LAB_SSD_BUTTON_WINDOW_ICON,
- LAB_SSD_BUTTON_WINDOW_MENU,
- LAB_SSD_BUTTON_SHADE,
- LAB_SSD_BUTTON_OMNIPRESENT,
- /* only for internal use */
- LAB_SSD_BUTTON_FIRST = LAB_SSD_BUTTON_CLOSE,
- LAB_SSD_BUTTON_LAST = LAB_SSD_BUTTON_OMNIPRESENT,
- LAB_SSD_BUTTON,
-
- LAB_SSD_PART_TITLEBAR,
- LAB_SSD_PART_TITLE,
-
- LAB_SSD_PART_CORNER_TOP_LEFT,
- LAB_SSD_PART_CORNER_TOP_RIGHT,
- LAB_SSD_PART_CORNER_BOTTOM_RIGHT,
- LAB_SSD_PART_CORNER_BOTTOM_LEFT,
- LAB_SSD_PART_TOP,
- LAB_SSD_PART_RIGHT,
- LAB_SSD_PART_BOTTOM,
- LAB_SSD_PART_LEFT,
- LAB_SSD_PART_BORDER,
-
- LAB_SSD_CLIENT,
- LAB_SSD_FRAME,
- LAB_SSD_ROOT,
- LAB_SSD_MENU,
- LAB_SSD_OSD,
- LAB_SSD_LAYER_SURFACE,
- LAB_SSD_LAYER_SUBSURFACE,
- LAB_SSD_UNMANAGED,
- LAB_SSD_ALL,
- LAB_SSD_END_MARKER
-};
-
/* Forward declare arguments */
struct ssd;
struct ssd_hover_state;
void ssd_update_button_hover(struct wlr_scene_node *node,
struct ssd_hover_state *hover_state);
-enum ssd_part_type ssd_part_get_type(const struct ssd_part *part);
+enum lab_node_type ssd_part_get_type(const struct ssd_part *part);
struct view *ssd_part_get_view(const struct ssd_part *part);
/* Public SSD helpers */
* Returns a part type that represents a mouse context like "Top", "Left" and
* "TRCorner" when the cursor is on the window border or resizing handle.
*/
-enum ssd_part_type ssd_get_resizing_type(const struct ssd *ssd,
+enum lab_node_type ssd_get_resizing_type(const struct ssd *ssd,
struct wlr_cursor *cursor);
-enum lab_edge ssd_resize_edges(enum ssd_part_type type);
-bool ssd_part_contains(enum ssd_part_type whole, enum ssd_part_type candidate);
enum lab_ssd_mode ssd_mode_parse(const char *mode);
/* TODO: clean up / update */
#include <cairo.h>
#include <wlr/render/wlr_renderer.h>
-#include "ssd.h"
+#include "common/node-type.h"
struct lab_img;
struct theme_background title_bg;
/* TODO: add toggled/hover/pressed/disabled colors for buttons */
- float button_colors[LAB_SSD_BUTTON_LAST + 1][4];
+ float button_colors[LAB_NODE_BUTTON_LAST + 1][4];
float border_color[4];
float toggled_keybinds_color[4];
* Elements in buttons[0] are all NULL since LAB_SSD_BUTTON_FIRST is 1.
*/
struct lab_img *button_imgs
- [LAB_SSD_BUTTON_LAST + 1][LAB_BS_ALL + 1];
+ [LAB_NODE_BUTTON_LAST + 1][LAB_BS_ALL + 1];
/*
* The titlebar background is specified as a cairo_pattern
x = extent.x;
y = view->current.y;
/* Push the client menu underneath the button */
- if (is_client_menu && ssd_part_contains(
- LAB_SSD_BUTTON, ctx->type)) {
+ if (is_client_menu && node_type_contains(
+ LAB_NODE_BUTTON, ctx->type)) {
assert(ctx->node);
int lx, ly;
wlr_scene_node_coords(ctx->node, &lx, &ly);
'match.c',
'mem.c',
'nodename.c',
+ 'node-type.c',
'parse-bool.c',
'parse-double.c',
'scene-helpers.c',
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-only
+#include "common/node-type.h"
+#include <strings.h>
+#include <wlr/util/log.h>
+
+enum lab_node_type
+node_type_parse(const char *context)
+{
+ if (!strcasecmp(context, "Close")) {
+ return LAB_NODE_BUTTON_CLOSE;
+ } else if (!strcasecmp(context, "Maximize")) {
+ return LAB_NODE_BUTTON_MAXIMIZE;
+ } else if (!strcasecmp(context, "Iconify")) {
+ return LAB_NODE_BUTTON_ICONIFY;
+ } else if (!strcasecmp(context, "WindowMenu")) {
+ return LAB_NODE_BUTTON_WINDOW_MENU;
+ } else if (!strcasecmp(context, "Icon")) {
+ return LAB_NODE_BUTTON_WINDOW_ICON;
+ } else if (!strcasecmp(context, "Shade")) {
+ return LAB_NODE_BUTTON_SHADE;
+ } else if (!strcasecmp(context, "AllDesktops")) {
+ return LAB_NODE_BUTTON_OMNIPRESENT;
+ } else if (!strcasecmp(context, "Titlebar")) {
+ return LAB_NODE_TITLEBAR;
+ } else if (!strcasecmp(context, "Title")) {
+ return LAB_NODE_TITLE;
+ } else if (!strcasecmp(context, "TLCorner")) {
+ return LAB_NODE_CORNER_TOP_LEFT;
+ } else if (!strcasecmp(context, "TRCorner")) {
+ return LAB_NODE_CORNER_TOP_RIGHT;
+ } else if (!strcasecmp(context, "BRCorner")) {
+ return LAB_NODE_CORNER_BOTTOM_RIGHT;
+ } else if (!strcasecmp(context, "BLCorner")) {
+ return LAB_NODE_CORNER_BOTTOM_LEFT;
+ } else if (!strcasecmp(context, "Border")) {
+ return LAB_NODE_BORDER;
+ } else if (!strcasecmp(context, "Top")) {
+ return LAB_NODE_BORDER_TOP;
+ } else if (!strcasecmp(context, "Right")) {
+ return LAB_NODE_BORDER_RIGHT;
+ } else if (!strcasecmp(context, "Bottom")) {
+ return LAB_NODE_BORDER_BOTTOM;
+ } else if (!strcasecmp(context, "Left")) {
+ return LAB_NODE_BORDER_LEFT;
+ } else if (!strcasecmp(context, "Frame")) {
+ return LAB_NODE_FRAME;
+ } else if (!strcasecmp(context, "Client")) {
+ return LAB_NODE_CLIENT;
+ } else if (!strcasecmp(context, "Desktop")) {
+ return LAB_NODE_ROOT;
+ } else if (!strcasecmp(context, "Root")) {
+ return LAB_NODE_ROOT;
+ } else if (!strcasecmp(context, "All")) {
+ return LAB_NODE_ALL;
+ }
+ wlr_log(WLR_ERROR, "unknown mouse context (%s)", context);
+ return LAB_NODE_NONE;
+}
+
+bool
+node_type_contains(enum lab_node_type whole, enum lab_node_type part)
+{
+ if (whole == part || whole == LAB_NODE_ALL) {
+ return true;
+ }
+ if (whole == LAB_NODE_BUTTON) {
+ return part >= LAB_NODE_BUTTON_FIRST
+ && part <= LAB_NODE_BUTTON_LAST;
+ }
+ if (whole == LAB_NODE_TITLEBAR) {
+ return part >= LAB_NODE_BUTTON_FIRST
+ && part <= LAB_NODE_TITLE;
+ }
+ if (whole == LAB_NODE_TITLE) {
+ /* "Title" includes blank areas of "Titlebar" as well */
+ return part >= LAB_NODE_TITLEBAR
+ && part <= LAB_NODE_TITLE;
+ }
+ if (whole == LAB_NODE_FRAME) {
+ return part >= LAB_NODE_BUTTON_FIRST
+ && part <= LAB_NODE_CLIENT;
+ }
+ if (whole == LAB_NODE_BORDER) {
+ return part >= LAB_NODE_CORNER_TOP_LEFT
+ && part <= LAB_NODE_BORDER_LEFT;
+ }
+ if (whole == LAB_NODE_BORDER_TOP) {
+ return part == LAB_NODE_CORNER_TOP_LEFT
+ || part == LAB_NODE_CORNER_TOP_RIGHT;
+ }
+ if (whole == LAB_NODE_BORDER_RIGHT) {
+ return part == LAB_NODE_CORNER_TOP_RIGHT
+ || part == LAB_NODE_CORNER_BOTTOM_RIGHT;
+ }
+ if (whole == LAB_NODE_BORDER_BOTTOM) {
+ return part == LAB_NODE_CORNER_BOTTOM_RIGHT
+ || part == LAB_NODE_CORNER_BOTTOM_LEFT;
+ }
+ if (whole == LAB_NODE_BORDER_LEFT) {
+ return part == LAB_NODE_CORNER_TOP_LEFT
+ || part == LAB_NODE_CORNER_BOTTOM_LEFT;
+ }
+ return false;
+}
+
+enum lab_edge
+node_type_to_edges(enum lab_node_type type)
+{
+ switch (type) {
+ case LAB_NODE_BORDER_TOP:
+ return LAB_EDGE_TOP;
+ case LAB_NODE_BORDER_RIGHT:
+ return LAB_EDGE_RIGHT;
+ case LAB_NODE_BORDER_BOTTOM:
+ return LAB_EDGE_BOTTOM;
+ case LAB_NODE_BORDER_LEFT:
+ return LAB_EDGE_LEFT;
+ case LAB_NODE_CORNER_TOP_LEFT:
+ return LAB_EDGES_TOP_LEFT;
+ case LAB_NODE_CORNER_TOP_RIGHT:
+ return LAB_EDGES_TOP_RIGHT;
+ case LAB_NODE_CORNER_BOTTOM_RIGHT:
+ return LAB_EDGES_BOTTOM_RIGHT;
+ case LAB_NODE_CORNER_BOTTOM_LEFT:
+ return LAB_EDGES_BOTTOM_LEFT;
+ default:
+ return LAB_EDGE_NONE;
+ }
+}
#include <wlr/util/log.h>
#include "common/list.h"
#include "common/mem.h"
+#include "config/keybind.h"
#include "config/rcxml.h"
uint32_t
return MOUSE_ACTION_NONE;
}
-static enum ssd_part_type
-context_from_str(const char *str)
-{
- if (!strcasecmp(str, "Close")) {
- return LAB_SSD_BUTTON_CLOSE;
- } else if (!strcasecmp(str, "Maximize")) {
- return LAB_SSD_BUTTON_MAXIMIZE;
- } else if (!strcasecmp(str, "Iconify")) {
- return LAB_SSD_BUTTON_ICONIFY;
- } else if (!strcasecmp(str, "WindowMenu")) {
- return LAB_SSD_BUTTON_WINDOW_MENU;
- } else if (!strcasecmp(str, "Icon")) {
- return LAB_SSD_BUTTON_WINDOW_ICON;
- } else if (!strcasecmp(str, "Shade")) {
- return LAB_SSD_BUTTON_SHADE;
- } else if (!strcasecmp(str, "AllDesktops")) {
- return LAB_SSD_BUTTON_OMNIPRESENT;
- } else if (!strcasecmp(str, "Titlebar")) {
- return LAB_SSD_PART_TITLEBAR;
- } else if (!strcasecmp(str, "Title")) {
- return LAB_SSD_PART_TITLE;
- } else if (!strcasecmp(str, "TLCorner")) {
- return LAB_SSD_PART_CORNER_TOP_LEFT;
- } else if (!strcasecmp(str, "TRCorner")) {
- return LAB_SSD_PART_CORNER_TOP_RIGHT;
- } else if (!strcasecmp(str, "BRCorner")) {
- return LAB_SSD_PART_CORNER_BOTTOM_RIGHT;
- } else if (!strcasecmp(str, "BLCorner")) {
- return LAB_SSD_PART_CORNER_BOTTOM_LEFT;
- } else if (!strcasecmp(str, "Border")) {
- return LAB_SSD_PART_BORDER;
- } else if (!strcasecmp(str, "Top")) {
- return LAB_SSD_PART_TOP;
- } else if (!strcasecmp(str, "Right")) {
- return LAB_SSD_PART_RIGHT;
- } else if (!strcasecmp(str, "Bottom")) {
- return LAB_SSD_PART_BOTTOM;
- } else if (!strcasecmp(str, "Left")) {
- return LAB_SSD_PART_LEFT;
- } else if (!strcasecmp(str, "Frame")) {
- return LAB_SSD_FRAME;
- } else if (!strcasecmp(str, "Client")) {
- return LAB_SSD_CLIENT;
- } else if (!strcasecmp(str, "Desktop")) {
- return LAB_SSD_ROOT;
- } else if (!strcasecmp(str, "Root")) {
- return LAB_SSD_ROOT;
- } else if (!strcasecmp(str, "All")) {
- return LAB_SSD_ALL;
- }
- wlr_log(WLR_ERROR, "unknown mouse context (%s)", str);
- return LAB_SSD_NONE;
-}
-
bool
mousebind_the_same(struct mousebind *a, struct mousebind *b)
{
return NULL;
}
struct mousebind *m = znew(*m);
- m->context = context_from_str(context);
- if (m->context != LAB_SSD_NONE) {
+ m->context = node_type_parse(context);
+ if (m->context != LAB_NODE_NONE) {
wl_list_append(&rc.mousebinds, &m->link);
}
wl_list_init(&m->actions);
#include "labwc.h"
#include "osd.h"
#include "regions.h"
+#include "ssd.h"
#include "view.h"
#include "window-rules.h"
#include "workspaces.h"
if (string_null_or_empty(identifier)) {
continue;
}
- enum ssd_part_type type = LAB_SSD_NONE;
+ enum lab_node_type type = LAB_NODE_NONE;
if (!strcmp(identifier, "icon")) {
#if HAVE_LIBSFDO
- type = LAB_SSD_BUTTON_WINDOW_ICON;
+ type = LAB_NODE_BUTTON_WINDOW_ICON;
#else
wlr_log(WLR_ERROR, "libsfdo is not linked. "
"Replacing 'icon' in titlebar layout with 'menu'.");
- type = LAB_SSD_BUTTON_WINDOW_MENU;
+ type = LAB_NODE_BUTTON_WINDOW_MENU;
#endif
} else if (!strcmp(identifier, "menu")) {
- type = LAB_SSD_BUTTON_WINDOW_MENU;
+ type = LAB_NODE_BUTTON_WINDOW_MENU;
} else if (!strcmp(identifier, "iconify")) {
- type = LAB_SSD_BUTTON_ICONIFY;
+ type = LAB_NODE_BUTTON_ICONIFY;
} else if (!strcmp(identifier, "max")) {
- type = LAB_SSD_BUTTON_MAXIMIZE;
+ type = LAB_NODE_BUTTON_MAXIMIZE;
} else if (!strcmp(identifier, "close")) {
- type = LAB_SSD_BUTTON_CLOSE;
+ type = LAB_NODE_BUTTON_CLOSE;
} else if (!strcmp(identifier, "shade")) {
- type = LAB_SSD_BUTTON_SHADE;
+ type = LAB_NODE_BUTTON_SHADE;
} else if (!strcmp(identifier, "desk")) {
- type = LAB_SSD_BUTTON_OMNIPRESENT;
+ type = LAB_NODE_BUTTON_OMNIPRESENT;
} else {
wlr_log(WLR_ERROR, "invalid titleLayout identifier '%s'",
identifier);
continue;
}
- assert(type != LAB_SSD_NONE);
+ assert(type != LAB_NODE_NONE);
/* We no longer need this check, but let's keep it just in case */
if (*found_buttons & (1 << type)) {
struct cursor_context
get_cursor_context(struct server *server)
{
- struct cursor_context ret = {.type = LAB_SSD_NONE};
+ struct cursor_context ret = {.type = LAB_NODE_NONE};
struct wlr_cursor *cursor = server->seat.cursor;
/* Prevent drag icons to be on top of the hitbox detection */
ret.node = node;
if (!node) {
- ret.type = LAB_SSD_ROOT;
+ ret.type = LAB_NODE_ROOT;
return ret;
}
if (node->type == WLR_SCENE_NODE_BUFFER) {
struct wlr_surface *surface = lab_wlr_surface_from_node(node);
if (node->parent == server->unmanaged_tree) {
- ret.type = LAB_SSD_UNMANAGED;
+ ret.type = LAB_NODE_UNMANAGED;
ret.surface = surface;
return ret;
}
ret.view = desc->data;
if (ret.node->type == WLR_SCENE_NODE_BUFFER
&& lab_wlr_surface_from_node(ret.node)) {
- ret.type = LAB_SSD_CLIENT;
+ ret.type = LAB_NODE_CLIENT;
ret.surface = lab_wlr_surface_from_node(ret.node);
} else {
/* should never be reached */
/* Detect mouse contexts like Top, Left and TRCorner */
ret.type = ssd_get_resizing_type(ret.view->ssd, cursor);
- if (ret.type == LAB_SSD_NONE) {
+ if (ret.type == LAB_NODE_NONE) {
/*
* Otherwise, detect mouse contexts like
* Title, Titlebar and Iconify
}
case LAB_NODE_DESC_LAYER_SURFACE:
ret.node = node;
- ret.type = LAB_SSD_LAYER_SURFACE;
+ ret.type = LAB_NODE_LAYER_SURFACE;
ret.surface = get_surface_from_layer_node(node);
return ret;
case LAB_NODE_DESC_LAYER_POPUP:
ret.node = node;
- ret.type = LAB_SSD_CLIENT;
+ ret.type = LAB_NODE_CLIENT;
ret.surface = get_surface_from_layer_node(node);
return ret;
case LAB_NODE_DESC_SESSION_LOCK_SURFACE: /* fallthrough */
case LAB_NODE_DESC_IME_POPUP:
- ret.type = LAB_SSD_CLIENT;
+ ret.type = LAB_NODE_CLIENT;
ret.surface = lab_wlr_surface_from_node(ret.node);
return ret;
case LAB_NODE_DESC_MENUITEM:
/* Always return the top scene node for menu items */
ret.node = node;
- ret.type = LAB_SSD_MENU;
+ ret.type = LAB_NODE_MENU;
return ret;
case LAB_NODE_DESC_NODE:
case LAB_NODE_DESC_TREE:
if (surface && wlr_subsurface_try_from_wlr_surface(surface)
&& subsurface_parent_layer(surface)) {
ret.surface = surface;
- ret.type = LAB_SSD_LAYER_SUBSURFACE;
+ ret.type = LAB_NODE_LAYER_SUBSURFACE;
return ret;
}
}
#include "common/macros.h"
#include "config/rcxml.h"
#include "labwc.h"
+#include "node.h"
#include "output.h"
+#include "ssd.h"
#include "view.h"
-#include "node.h"
static void
edges_for_target_geometry(struct border *edges, struct view *view,
}
static enum lab_cursors
-cursor_get_from_ssd(enum ssd_part_type view_area)
+cursor_get_from_ssd(enum lab_node_type view_area)
{
- enum lab_edge resize_edges = ssd_resize_edges(view_area);
+ enum lab_edge resize_edges = node_type_to_edges(view_area);
return cursor_get_from_edge(resize_edges);
}
enum lab_edge
cursor_get_resize_edges(struct wlr_cursor *cursor, struct cursor_context *ctx)
{
- enum lab_edge resize_edges = ssd_resize_edges(ctx->type);
+ enum lab_edge resize_edges = node_type_to_edges(ctx->type);
if (ctx->view && !resize_edges) {
struct wlr_box box = ctx->view->current;
resize_edges |=
struct cursor_context ctx = get_cursor_context(server);
struct seat *seat = &server->seat;
- if (ctx.type == LAB_SSD_MENU) {
+ if (ctx.type == LAB_NODE_MENU) {
menu_process_cursor_motion(ctx.node);
cursor_set(&server->seat, LAB_CURSOR_DEFAULT);
return false;
struct mousebind *mousebind;
wl_list_for_each(mousebind, &rc.mousebinds, link) {
- if (ctx.type == LAB_SSD_CLIENT
+ if (ctx.type == LAB_NODE_CLIENT
&& view_inhibits_actions(ctx.view, &mousebind->actions)) {
continue;
}
uint32_t modifiers = keyboard_get_all_modifiers(&server->seat);
wl_list_for_each(mousebind, &rc.mousebinds, link) {
- if (ctx->type == LAB_SSD_CLIENT
+ if (ctx->type == LAB_NODE_CLIENT
&& view_inhibits_actions(ctx->view, &mousebind->actions)) {
continue;
}
- if (ssd_part_contains(mousebind->context, ctx->type)
+ if (node_type_contains(mousebind->context, ctx->type)
&& mousebind->button == button
&& modifiers == mousebind->modifiers) {
switch (mousebind->mouse_event) {
is_double_click(long double_click_speed, uint32_t button,
struct cursor_context *ctx)
{
- static enum ssd_part_type last_type;
+ static enum lab_node_type last_type;
static uint32_t last_button;
static struct view *last_view;
static struct timespec last_click;
*/
last_button = 0;
last_view = NULL;
- last_type = LAB_SSD_NONE;
+ last_type = LAB_NODE_NONE;
return true;
}
return false;
uint32_t modifiers = keyboard_get_all_modifiers(&server->seat);
wl_list_for_each(mousebind, &rc.mousebinds, link) {
- if (ctx->type == LAB_SSD_CLIENT
+ if (ctx->type == LAB_NODE_CLIENT
&& view_inhibits_actions(ctx->view, &mousebind->actions)) {
continue;
}
- if (ssd_part_contains(mousebind->context, ctx->type)
+ if (node_type_contains(mousebind->context, ctx->type)
&& mousebind->button == button
&& modifiers == mousebind->modifiers) {
switch (mousebind->mouse_event) {
if (!double_click) {
/* Swallow the press event */
consumed_by_frame_context |=
- mousebind->context == LAB_SSD_FRAME;
+ mousebind->context == LAB_NODE_FRAME;
consumed_by_frame_context |=
- mousebind->context == LAB_SSD_ALL;
+ mousebind->context == LAB_NODE_ALL;
mousebind->pressed_in_context = true;
}
continue;
default:
continue;
}
- consumed_by_frame_context |= mousebind->context == LAB_SSD_FRAME;
- consumed_by_frame_context |= mousebind->context == LAB_SSD_ALL;
+ consumed_by_frame_context |= mousebind->context == LAB_NODE_FRAME;
+ consumed_by_frame_context |= mousebind->context == LAB_NODE_ALL;
actions_run(ctx->view, server, &mousebind->actions, ctx);
}
}
* Action processing does not run for these surfaces and thus
* the Focus action (used for normal views) does not work.
*/
- if (ctx.type == LAB_SSD_LAYER_SURFACE) {
+ if (ctx.type == LAB_NODE_LAYER_SURFACE) {
wlr_log(WLR_DEBUG, "press on layer-surface");
struct wlr_layer_surface_v1 *layer =
wlr_layer_surface_v1_try_from_wlr_surface(ctx.surface);
if (layer && layer->current.keyboard_interactive) {
layer_try_set_focus(seat, layer);
}
- } else if (ctx.type == LAB_SSD_LAYER_SUBSURFACE) {
+ } else if (ctx.type == LAB_NODE_LAYER_SUBSURFACE) {
wlr_log(WLR_DEBUG, "press on layer-subsurface");
struct wlr_layer_surface_v1 *layer =
subsurface_parent_layer(ctx.surface);
layer_try_set_focus(seat, layer);
}
#ifdef HAVE_XWAYLAND
- } else if (ctx.type == LAB_SSD_UNMANAGED) {
+ } else if (ctx.type == LAB_NODE_UNMANAGED) {
desktop_focus_view_or_surface(seat, NULL, ctx.surface,
/*raise*/ false);
#endif
}
- if (ctx.type != LAB_SSD_CLIENT && ctx.type != LAB_SSD_LAYER_SUBSURFACE
+ if (ctx.type != LAB_NODE_CLIENT && ctx.type != LAB_NODE_LAYER_SUBSURFACE
&& wlr_seat_pointer_has_grab(seat->seat)) {
/*
* If we have an active popup grab (an open popup) we want to
if (server->input_mode == LAB_INPUT_STATE_MENU) {
/* TODO: take into account overflow of time_msec */
if (time_msec - press_msec > rc.menu_ignore_button_release_period) {
- if (ctx.type == LAB_SSD_MENU) {
+ if (ctx.type == LAB_NODE_MENU) {
menu_call_selected_actions(server);
} else {
menu_close_root(server);
if (direction != LAB_DIRECTION_INVALID) {
struct mousebind *mousebind;
wl_list_for_each(mousebind, &rc.mousebinds, link) {
- if (ctx.type == LAB_SSD_CLIENT
+ if (ctx.type == LAB_NODE_CLIENT
&& view_inhibits_actions(ctx.view, &mousebind->actions)) {
continue;
}
- if (ssd_part_contains(mousebind->context, ctx.type)
+ if (node_type_contains(mousebind->context, ctx.type)
&& mousebind->direction == direction
&& modifiers == mousebind->modifiers
&& mousebind->mouse_event == MOUSE_ACTION_SCROLL) {
wl_list_for_each(mousebind, &rc.mousebinds, link) {
if (mousebind->mouse_event == MOUSE_ACTION_PRESS
&& mousebind->button == button
- && mousebind->context == LAB_SSD_CLIENT) {
+ && mousebind->context == LAB_NODE_CLIENT) {
actions_run(view, tool->seat->server,
&mousebind->actions, NULL);
}
wl_list_for_each(mousebind, &rc.mousebinds, link) {
if (mousebind->mouse_event == MOUSE_ACTION_PRESS
&& mousebind->button == BTN_LEFT
- && mousebind->context == LAB_SSD_CLIENT) {
+ && mousebind->context == LAB_NODE_CLIENT) {
actions_run(view, seat->server, &mousebind->actions, NULL);
}
}
#include "output.h"
#include "scaled-buffer/scaled-font-buffer.h"
#include "scaled-buffer/scaled-icon-buffer.h"
+#include "ssd.h"
#include "theme.h"
#include "view.h"
#include "window-rules.h"
#include "resize-indicator.h"
#include "scaled-buffer/scaled-buffer.h"
#include "session-lock.h"
+#include "ssd.h"
#include "theme.h"
#include "view.h"
#include "workspaces.h"
#include "snap.h"
#include <assert.h>
#include <wlr/util/box.h>
+#include <wlr/util/log.h>
#include "common/border.h"
#include "config/rcxml.h"
#include "edges.h"
-#include "labwc.h"
#include "output.h"
#include "snap-constraints.h"
+#include "ssd.h"
#include "view.h"
static void
#include <wlr/types/wlr_scene.h>
#include <wlr/util/box.h>
#include <wlr/util/log.h>
-#include "common/macros.h"
#include "config/rcxml.h"
#include "labwc.h"
#include "resize-indicator.h"
#include "resize-outlines.h"
#include "scaled-buffer/scaled-font-buffer.h"
+#include "ssd.h"
#include "theme.h"
#include "view.h"
#include "common/macros.h"
#include "common/scene-helpers.h"
#include "labwc.h"
+#include "ssd.h"
#include "ssd-internal.h"
#include "theme.h"
#include "view.h"
* to is destroyed.
*/
static void
-init_ssd_part(struct ssd_part *part, enum ssd_part_type type,
+init_ssd_part(struct ssd_part *part, enum lab_node_type type,
struct view *view, struct wlr_scene_node *node)
{
part->type = type;
}
struct ssd_part *
-attach_ssd_part(enum ssd_part_type type, struct view *view,
+attach_ssd_part(enum lab_node_type type, struct view *view,
struct wlr_scene_node *node)
{
- assert(!ssd_part_contains(LAB_SSD_BUTTON, type));
+ assert(!node_type_contains(LAB_NODE_BUTTON, type));
struct ssd_part *part = znew(*part);
init_ssd_part(part, type, view, node);
return part;
}
struct ssd_part_button *
-attach_ssd_part_button(struct wl_list *button_parts, enum ssd_part_type type,
+attach_ssd_part_button(struct wl_list *button_parts, enum lab_node_type type,
struct wlr_scene_tree *parent,
struct lab_img *imgs[LAB_BS_ALL + 1],
int x, int y, struct view *view)
struct wlr_scene_tree *root = wlr_scene_tree_create(parent);
wlr_scene_node_set_position(&root->node, x, y);
- assert(ssd_part_contains(LAB_SSD_BUTTON, type));
+ assert(node_type_contains(LAB_NODE_BUTTON, type));
struct ssd_part_button *button = znew(*button);
init_ssd_part(&button->base, type, view, &root->node);
wl_list_append(button_parts, &button->link);
*/
int icon_padding = button_width / 10;
- if (type == LAB_SSD_BUTTON_WINDOW_ICON) {
+ if (type == LAB_NODE_BUTTON_WINDOW_ICON) {
struct scaled_icon_buffer *icon_buffer =
scaled_icon_buffer_create(root, view->server,
button_width - 2 * icon_padding, button_height);
struct ssd_part_button *
button_try_from_ssd_part(struct ssd_part *part)
{
- if (ssd_part_contains(LAB_SSD_BUTTON, part->type)) {
+ if (node_type_contains(LAB_NODE_BUTTON, part->type)) {
return (struct ssd_part_button *)part;
}
return NULL;
#include "buffer.h"
#include "config/rcxml.h"
#include "labwc.h"
+#include "ssd.h"
#include "ssd-internal.h"
#include "theme.h"
#include "view.h"
#include "scaled-buffer/scaled-font-buffer.h"
#include "scaled-buffer/scaled-icon-buffer.h"
#include "scaled-buffer/scaled-img-buffer.h"
+#include "ssd.h"
#include "ssd-internal.h"
#include "theme.h"
#include "view.h"
static void set_squared_corners(struct ssd *ssd, bool enable);
-static void set_alt_button_icon(struct ssd *ssd, enum ssd_part_type type, bool enable);
+static void set_alt_button_icon(struct ssd *ssd, enum lab_node_type type, bool enable);
static void update_visible_buttons(struct ssd *ssd);
void
int corner_width = ssd_get_corner_width();
ssd->titlebar.tree = wlr_scene_tree_create(ssd->tree);
- attach_ssd_part(LAB_SSD_PART_TITLEBAR, view, &ssd->titlebar.tree->node);
+ attach_ssd_part(LAB_NODE_TITLEBAR, view, &ssd->titlebar.tree->node);
enum ssd_active_state active;
FOR_EACH_ACTIVE_STATE(active) {
subtree->tree, theme->titlebar_height,
theme->window[active].titlebar_pattern);
assert(subtree->title);
- attach_ssd_part(LAB_SSD_PART_TITLE,
+ attach_ssd_part(LAB_NODE_TITLE,
view, &subtree->title->scene_buffer->node);
/* Buttons */
bool maximized = view->maximized == VIEW_AXIS_BOTH;
bool squared = ssd_should_be_squared(ssd);
if (maximized) {
- set_alt_button_icon(ssd, LAB_SSD_BUTTON_MAXIMIZE, true);
+ set_alt_button_icon(ssd, LAB_NODE_BUTTON_MAXIMIZE, true);
ssd->state.was_maximized = true;
}
if (squared) {
set_squared_corners(ssd, maximized || squared);
if (view->shaded) {
- set_alt_button_icon(ssd, LAB_SSD_BUTTON_SHADE, true);
+ set_alt_button_icon(ssd, LAB_NODE_BUTTON_SHADE, true);
}
if (view->visible_on_all_workspaces) {
- set_alt_button_icon(ssd, LAB_SSD_BUTTON_OMNIPRESENT, true);
+ set_alt_button_icon(ssd, LAB_NODE_BUTTON_OMNIPRESENT, true);
}
}
}
static void
-set_alt_button_icon(struct ssd *ssd, enum ssd_part_type type, bool enable)
+set_alt_button_icon(struct ssd *ssd, enum lab_node_type type, bool enable)
{
enum ssd_active_state active;
FOR_EACH_ACTIVE_STATE(active) {
|| ssd->state.was_squared != squared) {
set_squared_corners(ssd, maximized || squared);
if (ssd->state.was_maximized != maximized) {
- set_alt_button_icon(ssd, LAB_SSD_BUTTON_MAXIMIZE, maximized);
+ set_alt_button_icon(ssd, LAB_NODE_BUTTON_MAXIMIZE, maximized);
}
ssd->state.was_maximized = maximized;
ssd->state.was_squared = squared;
}
if (ssd->state.was_shaded != view->shaded) {
- set_alt_button_icon(ssd, LAB_SSD_BUTTON_SHADE, view->shaded);
+ set_alt_button_icon(ssd, LAB_NODE_BUTTON_SHADE, view->shaded);
ssd->state.was_shaded = view->shaded;
}
if (ssd->state.was_omnipresent != view->visible_on_all_workspaces) {
- set_alt_button_icon(ssd, LAB_SSD_BUTTON_OMNIPRESENT,
+ set_alt_button_icon(ssd, LAB_NODE_BUTTON_OMNIPRESENT,
view->visible_on_all_workspaces);
ssd->state.was_omnipresent = view->visible_on_all_workspaces;
}
* Copyright (C) Johan Malm 2020-2021
*/
+#include "ssd.h"
#include <assert.h>
#include <strings.h>
#include <wlr/types/wlr_scene.h>
* (generally rc.resize_corner_range, but clipped to view size) of the view
* bounds, so check the cursor against the view here.
*/
-enum ssd_part_type
+enum lab_node_type
ssd_get_resizing_type(const struct ssd *ssd, struct wlr_cursor *cursor)
{
struct view *view = ssd ? ssd->view : NULL;
if (!view || !cursor || !view->ssd_mode || view->fullscreen) {
- return LAB_SSD_NONE;
+ return LAB_NODE_NONE;
}
struct wlr_box view_box = view->current;
if (wlr_box_contains_point(&view_box, cursor->x, cursor->y)) {
/* A cursor in bounds of the view is never in an SSD context */
- return LAB_SSD_NONE;
+ return LAB_NODE_NONE;
}
int corner_height = MAX(0, MIN(rc.resize_corner_range, view_box.height / 2));
bool bottom = cursor->y > view_box.y + view_box.height - corner_height;
if (top && left) {
- return LAB_SSD_PART_CORNER_TOP_LEFT;
+ return LAB_NODE_CORNER_TOP_LEFT;
} else if (top && right) {
- return LAB_SSD_PART_CORNER_TOP_RIGHT;
+ return LAB_NODE_CORNER_TOP_RIGHT;
} else if (bottom && left) {
- return LAB_SSD_PART_CORNER_BOTTOM_LEFT;
+ return LAB_NODE_CORNER_BOTTOM_LEFT;
} else if (bottom && right) {
- return LAB_SSD_PART_CORNER_BOTTOM_RIGHT;
+ return LAB_NODE_CORNER_BOTTOM_RIGHT;
} else if (top) {
- return LAB_SSD_PART_TOP;
+ return LAB_NODE_BORDER_TOP;
} else if (bottom) {
- return LAB_SSD_PART_BOTTOM;
+ return LAB_NODE_BORDER_BOTTOM;
} else if (left) {
- return LAB_SSD_PART_LEFT;
+ return LAB_NODE_BORDER_LEFT;
} else if (right) {
- return LAB_SSD_PART_RIGHT;
+ return LAB_NODE_BORDER_RIGHT;
}
- return LAB_SSD_NONE;
-}
-
-enum lab_edge
-ssd_resize_edges(enum ssd_part_type type)
-{
- switch (type) {
- case LAB_SSD_PART_TOP:
- return LAB_EDGE_TOP;
- case LAB_SSD_PART_RIGHT:
- return LAB_EDGE_RIGHT;
- case LAB_SSD_PART_BOTTOM:
- return LAB_EDGE_BOTTOM;
- case LAB_SSD_PART_LEFT:
- return LAB_EDGE_LEFT;
- case LAB_SSD_PART_CORNER_TOP_LEFT:
- return LAB_EDGES_TOP_LEFT;
- case LAB_SSD_PART_CORNER_TOP_RIGHT:
- return LAB_EDGES_TOP_RIGHT;
- case LAB_SSD_PART_CORNER_BOTTOM_RIGHT:
- return LAB_EDGES_BOTTOM_RIGHT;
- case LAB_SSD_PART_CORNER_BOTTOM_LEFT:
- return LAB_EDGES_BOTTOM_LEFT;
- default:
- return LAB_EDGE_NONE;
- }
+ return LAB_NODE_NONE;
}
struct ssd *
ssd->view = view;
ssd->tree = wlr_scene_tree_create(view->scene_tree);
- attach_ssd_part(LAB_SSD_NONE, view, &ssd->tree->node);
+ attach_ssd_part(LAB_NODE_NONE, view, &ssd->tree->node);
wlr_scene_node_lower_to_bottom(&ssd->tree->node);
ssd->titlebar.height = view->server->theme->titlebar_height;
ssd_shadow_create(ssd);
free(ssd);
}
-bool
-ssd_part_contains(enum ssd_part_type whole, enum ssd_part_type candidate)
-{
- if (whole == candidate || whole == LAB_SSD_ALL) {
- return true;
- }
- if (whole == LAB_SSD_BUTTON) {
- return candidate >= LAB_SSD_BUTTON_CLOSE
- && candidate <= LAB_SSD_BUTTON_OMNIPRESENT;
- }
- if (whole == LAB_SSD_PART_TITLEBAR) {
- return candidate >= LAB_SSD_BUTTON_CLOSE
- && candidate <= LAB_SSD_PART_TITLE;
- }
- if (whole == LAB_SSD_PART_TITLE) {
- /* "Title" includes blank areas of "Titlebar" as well */
- return candidate >= LAB_SSD_PART_TITLEBAR
- && candidate <= LAB_SSD_PART_TITLE;
- }
- if (whole == LAB_SSD_FRAME) {
- return candidate >= LAB_SSD_BUTTON_CLOSE
- && candidate <= LAB_SSD_CLIENT;
- }
- if (whole == LAB_SSD_PART_BORDER) {
- return candidate >= LAB_SSD_PART_CORNER_TOP_LEFT
- && candidate <= LAB_SSD_PART_LEFT;
- }
- if (whole == LAB_SSD_PART_TOP) {
- return candidate == LAB_SSD_PART_CORNER_TOP_LEFT
- || candidate == LAB_SSD_PART_CORNER_TOP_RIGHT;
- }
- if (whole == LAB_SSD_PART_RIGHT) {
- return candidate == LAB_SSD_PART_CORNER_TOP_RIGHT
- || candidate == LAB_SSD_PART_CORNER_BOTTOM_RIGHT;
- }
- if (whole == LAB_SSD_PART_BOTTOM) {
- return candidate == LAB_SSD_PART_CORNER_BOTTOM_RIGHT
- || candidate == LAB_SSD_PART_CORNER_BOTTOM_LEFT;
- }
- if (whole == LAB_SSD_PART_LEFT) {
- return candidate == LAB_SSD_PART_CORNER_TOP_LEFT
- || candidate == LAB_SSD_PART_CORNER_BOTTOM_LEFT;
- }
- return false;
-}
-
enum lab_ssd_mode
ssd_mode_parse(const char *mode)
{
return znew(struct ssd_hover_state);
}
-enum ssd_part_type
+enum lab_node_type
ssd_part_get_type(const struct ssd_part *part)
{
- return part ? part->type : LAB_SSD_NONE;
+ return part ? part->type : LAB_NODE_NONE;
}
struct view *
const char *name;
const char *alt_name;
const char *fallback_button; /* built-in 6x6 button */
- enum ssd_part_type type;
+ enum lab_node_type type;
uint8_t state_set;
};
struct button buttons[] = { {
.name = "menu",
.fallback_button = (const char[]){ 0x00, 0x21, 0x33, 0x1E, 0x0C, 0x00 },
- .type = LAB_SSD_BUTTON_WINDOW_MENU,
+ .type = LAB_NODE_BUTTON_WINDOW_MENU,
.state_set = 0,
}, {
.name = "iconify",
.fallback_button = (const char[]){ 0x00, 0x00, 0x00, 0x00, 0x3f, 0x3f },
- .type = LAB_SSD_BUTTON_ICONIFY,
+ .type = LAB_NODE_BUTTON_ICONIFY,
.state_set = 0,
}, {
.name = "max",
.fallback_button = (const char[]){ 0x3f, 0x3f, 0x21, 0x21, 0x21, 0x3f },
- .type = LAB_SSD_BUTTON_MAXIMIZE,
+ .type = LAB_NODE_BUTTON_MAXIMIZE,
.state_set = 0,
}, {
.name = "max_toggled",
.fallback_button = (const char[]){ 0x3e, 0x22, 0x2f, 0x29, 0x39, 0x0f },
- .type = LAB_SSD_BUTTON_MAXIMIZE,
+ .type = LAB_NODE_BUTTON_MAXIMIZE,
.state_set = LAB_BS_TOGGLED,
}, {
.name = "shade",
.fallback_button = (const char[]){ 0x3f, 0x3f, 0x00, 0x0c, 0x1e, 0x3f },
- .type = LAB_SSD_BUTTON_SHADE,
+ .type = LAB_NODE_BUTTON_SHADE,
.state_set = 0,
}, {
.name = "shade_toggled",
.fallback_button = (const char[]){ 0x3f, 0x3f, 0x00, 0x3f, 0x1e, 0x0c },
- .type = LAB_SSD_BUTTON_SHADE,
+ .type = LAB_NODE_BUTTON_SHADE,
.state_set = LAB_BS_TOGGLED,
}, {
.name = "desk",
.fallback_button = (const char[]){ 0x33, 0x33, 0x00, 0x00, 0x33, 0x33 },
- .type = LAB_SSD_BUTTON_OMNIPRESENT,
+ .type = LAB_NODE_BUTTON_OMNIPRESENT,
.state_set = 0,
}, {
.name = "desk_toggled",
.fallback_button = (const char[]){ 0x00, 0x1e, 0x1a, 0x16, 0x1e, 0x00 },
- .type = LAB_SSD_BUTTON_OMNIPRESENT,
+ .type = LAB_NODE_BUTTON_OMNIPRESENT,
.state_set = LAB_BS_TOGGLED,
}, {
.name = "close",
.fallback_button = (const char[]){ 0x33, 0x3f, 0x1e, 0x1e, 0x3f, 0x33 },
- .type = LAB_SSD_BUTTON_CLOSE,
+ .type = LAB_NODE_BUTTON_CLOSE,
.state_set = 0,
}, {
.name = "menu_hover",
- .type = LAB_SSD_BUTTON_WINDOW_MENU,
+ .type = LAB_NODE_BUTTON_WINDOW_MENU,
.state_set = LAB_BS_HOVERED,
/* no fallback (non-hover variant is used instead) */
}, {
.name = "iconify_hover",
- .type = LAB_SSD_BUTTON_ICONIFY,
+ .type = LAB_NODE_BUTTON_ICONIFY,
.state_set = LAB_BS_HOVERED,
/* no fallback (non-hover variant is used instead) */
}, {
.name = "max_hover",
- .type = LAB_SSD_BUTTON_MAXIMIZE,
+ .type = LAB_NODE_BUTTON_MAXIMIZE,
.state_set = LAB_BS_HOVERED,
/* no fallback (non-hover variant is used instead) */
}, {
.name = "max_toggled_hover",
.alt_name = "max_hover_toggled",
- .type = LAB_SSD_BUTTON_MAXIMIZE,
+ .type = LAB_NODE_BUTTON_MAXIMIZE,
.state_set = LAB_BS_TOGGLED | LAB_BS_HOVERED,
/* no fallback (non-hover variant is used instead) */
}, {
.name = "shade_hover",
- .type = LAB_SSD_BUTTON_SHADE,
+ .type = LAB_NODE_BUTTON_SHADE,
.state_set = LAB_BS_HOVERED,
/* no fallback (non-hover variant is used instead) */
}, {
.name = "shade_toggled_hover",
.alt_name = "shade_hover_toggled",
- .type = LAB_SSD_BUTTON_SHADE,
+ .type = LAB_NODE_BUTTON_SHADE,
.state_set = LAB_BS_TOGGLED | LAB_BS_HOVERED,
/* no fallback (non-hover variant is used instead) */
}, {
.name = "desk_hover",
/* no fallback (non-hover variant is used instead) */
- .type = LAB_SSD_BUTTON_OMNIPRESENT,
+ .type = LAB_NODE_BUTTON_OMNIPRESENT,
.state_set = LAB_BS_HOVERED,
}, {
.name = "desk_toggled_hover",
.alt_name = "desk_hover_toggled",
- .type = LAB_SSD_BUTTON_OMNIPRESENT,
+ .type = LAB_NODE_BUTTON_OMNIPRESENT,
.state_set = LAB_BS_TOGGLED | LAB_BS_HOVERED,
/* no fallback (non-hover variant is used instead) */
}, {
.name = "close_hover",
- .type = LAB_SSD_BUTTON_CLOSE,
+ .type = LAB_NODE_BUTTON_CLOSE,
.state_set = LAB_BS_HOVERED,
/* no fallback (non-hover variant is used instead) */
}, };
theme->window_button_spacing = 0;
theme->window_button_hover_bg_corner_radius = 0;
- for (enum ssd_part_type type = LAB_SSD_BUTTON_FIRST;
- type <= LAB_SSD_BUTTON_LAST; type++) {
+ for (enum lab_node_type type = LAB_NODE_BUTTON_FIRST;
+ type <= LAB_NODE_BUTTON_LAST; type++) {
parse_hexstr("#000000",
theme->window[THEME_INACTIVE].button_colors[type]);
parse_hexstr("#000000",
/* universal button */
if (match_glob(key, "window.active.button.unpressed.image.color")) {
- for (enum ssd_part_type type = LAB_SSD_BUTTON_FIRST;
- type <= LAB_SSD_BUTTON_LAST; type++) {
+ for (enum lab_node_type type = LAB_NODE_BUTTON_FIRST;
+ type <= LAB_NODE_BUTTON_LAST; type++) {
parse_color(value,
theme->window[THEME_ACTIVE].button_colors[type]);
}
}
if (match_glob(key, "window.inactive.button.unpressed.image.color")) {
- for (enum ssd_part_type type = LAB_SSD_BUTTON_FIRST;
- type <= LAB_SSD_BUTTON_LAST; type++) {
+ for (enum lab_node_type type = LAB_NODE_BUTTON_FIRST;
+ type <= LAB_NODE_BUTTON_LAST; type++) {
parse_color(value,
theme->window[THEME_INACTIVE].button_colors[type]);
}
/* individual buttons */
if (match_glob(key, "window.active.button.menu.unpressed.image.color")) {
parse_color(value, theme->window[THEME_ACTIVE]
- .button_colors[LAB_SSD_BUTTON_WINDOW_MENU]);
+ .button_colors[LAB_NODE_BUTTON_WINDOW_MENU]);
parse_color(value, theme->window[THEME_ACTIVE]
- .button_colors[LAB_SSD_BUTTON_WINDOW_ICON]);
+ .button_colors[LAB_NODE_BUTTON_WINDOW_ICON]);
}
if (match_glob(key, "window.active.button.iconify.unpressed.image.color")) {
parse_color(value, theme->window[THEME_ACTIVE]
- .button_colors[LAB_SSD_BUTTON_ICONIFY]);
+ .button_colors[LAB_NODE_BUTTON_ICONIFY]);
}
if (match_glob(key, "window.active.button.max.unpressed.image.color")) {
parse_color(value, theme->window[THEME_ACTIVE]
- .button_colors[LAB_SSD_BUTTON_MAXIMIZE]);
+ .button_colors[LAB_NODE_BUTTON_MAXIMIZE]);
}
if (match_glob(key, "window.active.button.shade.unpressed.image.color")) {
parse_color(value, theme->window[THEME_ACTIVE]
- .button_colors[LAB_SSD_BUTTON_SHADE]);
+ .button_colors[LAB_NODE_BUTTON_SHADE]);
}
if (match_glob(key, "window.active.button.desk.unpressed.image.color")) {
parse_color(value, theme->window[THEME_ACTIVE]
- .button_colors[LAB_SSD_BUTTON_OMNIPRESENT]);
+ .button_colors[LAB_NODE_BUTTON_OMNIPRESENT]);
}
if (match_glob(key, "window.active.button.close.unpressed.image.color")) {
parse_color(value, theme->window[THEME_ACTIVE]
- .button_colors[LAB_SSD_BUTTON_CLOSE]);
+ .button_colors[LAB_NODE_BUTTON_CLOSE]);
}
if (match_glob(key, "window.inactive.button.menu.unpressed.image.color")) {
parse_color(value, theme->window[THEME_INACTIVE]
- .button_colors[LAB_SSD_BUTTON_WINDOW_MENU]);
+ .button_colors[LAB_NODE_BUTTON_WINDOW_MENU]);
parse_color(value, theme->window[THEME_INACTIVE]
- .button_colors[LAB_SSD_BUTTON_WINDOW_ICON]);
+ .button_colors[LAB_NODE_BUTTON_WINDOW_ICON]);
}
if (match_glob(key, "window.inactive.button.iconify.unpressed.image.color")) {
parse_color(value, theme->window[THEME_INACTIVE]
- .button_colors[LAB_SSD_BUTTON_ICONIFY]);
+ .button_colors[LAB_NODE_BUTTON_ICONIFY]);
}
if (match_glob(key, "window.inactive.button.max.unpressed.image.color")) {
parse_color(value, theme->window[THEME_INACTIVE]
- .button_colors[LAB_SSD_BUTTON_MAXIMIZE]);
+ .button_colors[LAB_NODE_BUTTON_MAXIMIZE]);
}
if (match_glob(key, "window.inactive.button.shade.unpressed.image.color")) {
parse_color(value, theme->window[THEME_INACTIVE]
- .button_colors[LAB_SSD_BUTTON_SHADE]);
+ .button_colors[LAB_NODE_BUTTON_SHADE]);
}
if (match_glob(key, "window.inactive.button.desk.unpressed.image.color")) {
parse_color(value, theme->window[THEME_INACTIVE]
- .button_colors[LAB_SSD_BUTTON_OMNIPRESENT]);
+ .button_colors[LAB_NODE_BUTTON_OMNIPRESENT]);
}
if (match_glob(key, "window.inactive.button.close.unpressed.image.color")) {
parse_color(value, theme->window[THEME_INACTIVE]
- .button_colors[LAB_SSD_BUTTON_CLOSE]);
+ .button_colors[LAB_NODE_BUTTON_CLOSE]);
}
/* window drop-shadows */
void
theme_finish(struct theme *theme)
{
- for (enum ssd_part_type type = LAB_SSD_BUTTON_FIRST;
- type <= LAB_SSD_BUTTON_LAST; type++) {
+ for (enum lab_node_type type = LAB_NODE_BUTTON_FIRST;
+ type <= LAB_NODE_BUTTON_LAST; type++) {
for (uint8_t state_set = LAB_BS_DEFAULT;
state_set <= LAB_BS_ALL; state_set++) {
destroy_img(&theme->window[THEME_INACTIVE]
#include "labwc.h"
#include "node.h"
#include "output.h"
-#include "ssd.h"
#include "view.h"
#include "view-impl-common.h"
#include "window-rules.h"
projects / proto / labwc.git / commitdiff