LAB_NODE_FRAME,
LAB_NODE_ROOT,
LAB_NODE_MENUITEM,
- LAB_NODE_OSD_ITEM,
+ LAB_NODE_CYCLE_OSD_ITEM,
LAB_NODE_LAYER_SURFACE,
LAB_NODE_UNMANAGED,
LAB_NODE_ALL,
bool unshade;
enum lab_view_criteria criteria;
struct wl_list fields; /* struct window_switcher_field.link */
- enum window_switcher_style style;
- enum osd_output_criteria output_criteria;
+ enum cycle_osd_style style;
+ enum cycle_osd_output_criteria output_criteria;
char *thumbnail_label_format;
} window_switcher;
LAB_WINDOW_TYPE_LEN
};
-enum window_switcher_style {
- WINDOW_SWITCHER_CLASSIC,
- WINDOW_SWITCHER_THUMBNAIL,
+enum cycle_osd_style {
+ CYCLE_OSD_STYLE_CLASSIC,
+ CYCLE_OSD_STYLE_THUMBNAIL,
};
-enum osd_output_criteria {
- OSD_OUTPUT_ALL,
- OSD_OUTPUT_POINTER,
- OSD_OUTPUT_KEYBOARD,
+enum cycle_osd_output_criteria {
+ CYCLE_OSD_OUTPUT_ALL,
+ CYCLE_OSD_OUTPUT_POINTER,
+ CYCLE_OSD_OUTPUT_KEYBOARD,
};
#endif /* LABWC_CONFIG_TYPES_H */
};
/* TODO: add field with keyboard layout? */
-enum window_switcher_field_content {
+enum cycle_osd_field_content {
LAB_FIELD_NONE = 0,
LAB_FIELD_TYPE,
LAB_FIELD_TYPE_SHORT,
LAB_FIELD_COUNT
};
-struct window_switcher_field {
- enum window_switcher_field_content content;
+struct cycle_osd_field {
+ enum cycle_osd_field_content content;
int width;
char *format;
struct wl_list link; /* struct rcxml.window_switcher.fields */
struct wlr_scene_node;
/* Begin window switcher */
-void osd_begin(struct server *server, enum lab_cycle_dir direction);
+void cycle_begin(struct server *server, enum lab_cycle_dir direction);
/* Cycle the selected view in the window switcher */
-void osd_cycle(struct server *server, enum lab_cycle_dir direction);
+void cycle_step(struct server *server, enum lab_cycle_dir direction);
/* Closes the OSD */
-void osd_finish(struct server *server, bool switch_focus);
+void cycle_finish(struct server *server, bool switch_focus);
/* Notify OSD about a destroying view */
-void osd_on_view_destroy(struct view *view);
+void cycle_on_view_destroy(struct view *view);
/* Focus the clicked window and close OSD */
-void osd_on_cursor_release(struct server *server, struct wlr_scene_node *node);
+void cycle_on_cursor_release(struct server *server, struct wlr_scene_node *node);
/* Used by osd.c internally to render window switcher fields */
-void osd_field_get_content(struct window_switcher_field *field,
+void cycle_osd_field_get_content(struct cycle_osd_field *field,
struct buf *buf, struct view *view);
/* Sets view info to buf according to format */
-void osd_field_set_custom(struct buf *buf, struct view *view,
+void cycle_osd_field_set_custom(struct buf *buf, struct view *view,
const char *format);
/* Used by rcxml.c when parsing the config */
-void osd_field_arg_from_xml_node(struct window_switcher_field *field,
+void cycle_osd_field_arg_from_xml_node(struct cycle_osd_field *field,
const char *nodename, const char *content);
-bool osd_field_is_valid(struct window_switcher_field *field);
-void osd_field_free(struct window_switcher_field *field);
+bool cycle_osd_field_is_valid(struct cycle_osd_field *field);
+void cycle_osd_field_free(struct cycle_osd_field *field);
/* Internal API */
-struct osd_item {
+struct cycle_osd_item {
struct view *view;
struct wlr_scene_tree *tree;
struct wl_list link;
};
-struct osd_impl {
+struct cycle_osd_impl {
/*
* Create a scene-tree of OSD for an output.
- * This sets output->osd_scene.{items,tree}.
+ * This sets output->cycle_osd.{items,tree}.
*/
void (*create)(struct output *output, struct wl_array *views);
/*
- * Update output->osd_scene.tree to highlight
- * server->osd_state.cycle_view.
+ * Update output->cycle_osd.tree to highlight
+ * server->cycle_state.selected_view.
*/
void (*update)(struct output *output);
};
-extern struct osd_impl osd_classic_impl;
-extern struct osd_impl osd_thumbnail_impl;
+extern struct cycle_osd_impl cycle_osd_classic_impl;
+extern struct cycle_osd_impl cycle_osd_thumbnail_impl;
#endif // LABWC_CYCLE_H
LAB_INPUT_STATE_MOVE,
LAB_INPUT_STATE_RESIZE,
LAB_INPUT_STATE_MENU,
- LAB_INPUT_STATE_WINDOW_SWITCHER,
+ LAB_INPUT_STATE_CYCLE, /* a.k.a. window switching */
};
struct seat {
struct wlr_security_context_manager_v1 *security_context_manager_v1;
/* Set when in cycle (alt-tab) mode */
- struct osd_state {
- struct view *cycle_view;
+ struct cycle_state {
+ struct view *selected_view;
bool preview_was_shaded;
bool preview_was_enabled;
struct wlr_scene_node *preview_node;
struct wlr_scene_tree *preview_parent;
struct wlr_scene_node *preview_anchor;
struct lab_scene_rect *preview_outline;
- } osd_state;
+ } cycle;
struct theme *theme;
struct wlr_scene_node *wlr_scene_node);
/**
- * node_osd_item_from_node - return osd item struct from node
+ * node_cycle_osd_item_from_node - return cycle OSD item struct from node
* @wlr_scene_node: wlr_scene_node from which to return data
*/
-struct osd_item *node_osd_item_from_node(
+struct cycle_osd_item *node_cycle_osd_item_from_node(
struct wlr_scene_node *wlr_scene_node);
/**
struct wlr_scene_output *scene_output;
struct wlr_scene_tree *layer_tree[LAB_NR_LAYERS];
struct wlr_scene_tree *layer_popup_tree;
- struct wlr_scene_tree *osd_tree;
+ struct wlr_scene_tree *cycle_osd_tree;
struct wlr_scene_tree *session_lock_tree;
struct wlr_scene_buffer *workspace_osd;
- struct osd_scene {
- struct wl_list items; /* struct osd_item */
+ struct cycle_osd_scene {
+ struct wl_list items; /* struct cycle_osd_item */
struct wlr_scene_tree *tree;
- } osd_scene;
+ } cycle_osd;
/* In output-relative scene coordinates */
struct wlr_box usable_area;
}
break;
case ACTION_TYPE_NEXT_WINDOW:
- if (server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER) {
- osd_cycle(server, LAB_CYCLE_DIR_FORWARD);
+ if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
+ cycle_step(server, LAB_CYCLE_DIR_FORWARD);
} else {
- osd_begin(server, LAB_CYCLE_DIR_FORWARD);
+ cycle_begin(server, LAB_CYCLE_DIR_FORWARD);
}
break;
case ACTION_TYPE_PREVIOUS_WINDOW:
- if (server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER) {
- osd_cycle(server, LAB_CYCLE_DIR_BACKWARD);
+ if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
+ cycle_step(server, LAB_CYCLE_DIR_BACKWARD);
} else {
- osd_begin(server, LAB_CYCLE_DIR_BACKWARD);
+ cycle_begin(server, LAB_CYCLE_DIR_BACKWARD);
}
break;
case ACTION_TYPE_RECONFIGURE:
struct action *action;
wl_list_for_each(action, actions, link) {
- if (server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER
+ if (server->input_mode == LAB_INPUT_STATE_CYCLE
&& action->type != ACTION_TYPE_NEXT_WINDOW
&& action->type != ACTION_TYPE_PREVIOUS_WINDOW) {
wlr_log(WLR_INFO, "Only NextWindow or PreviousWindow "
static void
clear_window_switcher_fields(void)
{
- struct window_switcher_field *field, *field_tmp;
+ struct cycle_osd_field *field, *field_tmp;
wl_list_for_each_safe(field, field_tmp, &rc.window_switcher.fields, link) {
wl_list_remove(&field->link);
- osd_field_free(field);
+ cycle_osd_field_free(field);
}
}
static void
fill_window_switcher_field(xmlNode *node)
{
- struct window_switcher_field *field = znew(*field);
+ struct cycle_osd_field *field = znew(*field);
wl_list_append(&rc.window_switcher.fields, &field->link);
xmlNode *child;
char *key, *content;
LAB_XML_FOR_EACH(node, child, key, content) {
- osd_field_arg_from_xml_node(field, key, content);
+ cycle_osd_field_arg_from_xml_node(field, key, content);
}
}
set_bool(content, &rc.window_switcher.show);
} else if (!strcasecmp(nodename, "style.osd.windowSwitcher")) {
if (!strcasecmp(content, "classic")) {
- rc.window_switcher.style = WINDOW_SWITCHER_CLASSIC;
+ rc.window_switcher.style = CYCLE_OSD_STYLE_CLASSIC;
} else if (!strcasecmp(content, "thumbnail")) {
- rc.window_switcher.style = WINDOW_SWITCHER_THUMBNAIL;
+ rc.window_switcher.style = CYCLE_OSD_STYLE_THUMBNAIL;
} else {
wlr_log(WLR_ERROR, "Invalid windowSwitcher style %s: "
"should be one of classic|thumbnail", content);
}
} else if (!strcasecmp(nodename, "output.osd.windowSwitcher")) {
if (!strcasecmp(content, "all")) {
- rc.window_switcher.output_criteria = OSD_OUTPUT_ALL;
+ rc.window_switcher.output_criteria = CYCLE_OSD_OUTPUT_ALL;
} else if (!strcasecmp(content, "pointer")) {
- rc.window_switcher.output_criteria = OSD_OUTPUT_POINTER;
+ rc.window_switcher.output_criteria = CYCLE_OSD_OUTPUT_POINTER;
} else if (!strcasecmp(content, "keyboard")) {
- rc.window_switcher.output_criteria = OSD_OUTPUT_KEYBOARD;
+ rc.window_switcher.output_criteria = CYCLE_OSD_OUTPUT_KEYBOARD;
} else {
wlr_log(WLR_ERROR, "Invalid windowSwitcher output %s: "
"should be one of all|pointer|keyboard", content);
" Use <osd show=\"\" />");
} else if (!strcasecmp(nodename, "style.windowSwitcher")) {
if (!strcasecmp(content, "classic")) {
- rc.window_switcher.style = WINDOW_SWITCHER_CLASSIC;
+ rc.window_switcher.style = CYCLE_OSD_STYLE_CLASSIC;
} else if (!strcasecmp(content, "thumbnail")) {
- rc.window_switcher.style = WINDOW_SWITCHER_THUMBNAIL;
+ rc.window_switcher.style = CYCLE_OSD_STYLE_THUMBNAIL;
}
wlr_log(WLR_ERROR, "<windowSwitcher style=\"\" /> is deprecated."
" Use <osd style=\"\" />");
rc.snap_tiling_events_mode = LAB_TILING_EVENTS_ALWAYS;
rc.window_switcher.show = true;
- rc.window_switcher.style = WINDOW_SWITCHER_CLASSIC;
- rc.window_switcher.output_criteria = OSD_OUTPUT_ALL;
+ rc.window_switcher.style = CYCLE_OSD_STYLE_CLASSIC;
+ rc.window_switcher.output_criteria = CYCLE_OSD_OUTPUT_ALL;
rc.window_switcher.thumbnail_label_format = xstrdup("%T");
rc.window_switcher.preview = true;
rc.window_switcher.outlines = true;
load_default_window_switcher_fields(void)
{
static const struct {
- enum window_switcher_field_content content;
+ enum cycle_osd_field_content content;
int width;
} fields[] = {
#if HAVE_LIBSFDO
#endif
};
- struct window_switcher_field *field;
+ struct cycle_osd_field *field;
for (size_t i = 0; i < ARRAY_SIZE(fields); i++) {
field = znew(*field);
field->content = fields[i].content;
/* OSD fields */
int field_width_sum = 0;
- struct window_switcher_field *field, *field_tmp;
+ struct cycle_osd_field *field, *field_tmp;
wl_list_for_each_safe(field, field_tmp, &rc.window_switcher.fields, link) {
field_width_sum += field->width;
- if (!osd_field_is_valid(field) || field_width_sum > 100) {
+ if (!cycle_osd_field_is_valid(field) || field_width_sum > 100) {
wlr_log(WLR_ERROR, "Deleting invalid window switcher field %p", field);
wl_list_remove(&field->link);
- osd_field_free(field);
+ cycle_osd_field_free(field);
}
}
}
#include "theme.h"
#include "view.h"
-static void update_osd(struct server *server);
+static void update_cycle(struct server *server);
static void
destroy_osd_scenes(struct server *server)
{
struct output *output;
wl_list_for_each(output, &server->outputs, link) {
- struct osd_item *item, *tmp;
- wl_list_for_each_safe(item, tmp, &output->osd_scene.items, link) {
+ struct cycle_osd_item *item, *tmp;
+ wl_list_for_each_safe(item, tmp, &output->cycle_osd.items, link) {
wl_list_remove(&item->link);
free(item);
}
- if (output->osd_scene.tree) {
- wlr_scene_node_destroy(&output->osd_scene.tree->node);
- output->osd_scene.tree = NULL;
+ if (output->cycle_osd.tree) {
+ wlr_scene_node_destroy(&output->cycle_osd.tree->node);
+ output->cycle_osd.tree = NULL;
}
}
}
static void
-osd_update_preview_outlines(struct view *view)
+update_preview_outlines(struct view *view)
{
/* Create / Update preview outline tree */
struct server *server = view->server;
struct theme *theme = server->theme;
- struct lab_scene_rect *rect = view->server->osd_state.preview_outline;
+ struct lab_scene_rect *rect = view->server->cycle.preview_outline;
if (!rect) {
struct lab_scene_rect_options opts = {
.border_colors = (float *[3]) {
};
rect = lab_scene_rect_create(&server->scene->tree, &opts);
wlr_scene_node_place_above(&rect->tree->node, &server->menu_tree->node);
- server->osd_state.preview_outline = rect;
+ server->cycle.preview_outline = rect;
}
struct wlr_box geo = ssd_max_extents(view);
* If !start_view, the second focusable view is returned.
*/
static struct view *
-get_next_cycle_view(struct server *server, struct view *start_view,
+get_next_selected_view(struct server *server, struct view *start_view,
enum lab_cycle_dir dir)
{
struct view *(*iter)(struct wl_list *head, struct view *view,
}
void
-osd_on_view_destroy(struct view *view)
+cycle_on_view_destroy(struct view *view)
{
assert(view);
- struct osd_state *osd_state = &view->server->osd_state;
+ struct server *server = view->server;
+ struct cycle_state *cycle = &server->cycle;
- if (view->server->input_mode != LAB_INPUT_STATE_WINDOW_SWITCHER) {
+ if (server->input_mode != LAB_INPUT_STATE_CYCLE) {
/* OSD not active, no need for clean up */
return;
}
- if (osd_state->cycle_view == view) {
+ if (cycle->selected_view == view) {
/*
* If we are the current OSD selected view, cycle
* to the next because we are dying.
*/
/* Also resets preview node */
- osd_state->cycle_view = get_next_cycle_view(view->server,
- osd_state->cycle_view, LAB_CYCLE_DIR_BACKWARD);
+ cycle->selected_view = get_next_selected_view(server,
+ cycle->selected_view, LAB_CYCLE_DIR_BACKWARD);
/*
* If we cycled back to ourselves, then we have no more windows.
* Just close the OSD for good.
*/
- if (osd_state->cycle_view == view || !osd_state->cycle_view) {
- /* osd_finish() additionally resets cycle_view to NULL */
- osd_finish(view->server, /*switch_focus*/ false);
+ if (cycle->selected_view == view
+ || !cycle->selected_view) {
+ /* cycle_finish() additionally resets selected_view to NULL */
+ cycle_finish(server, /*switch_focus*/ false);
}
}
- if (osd_state->cycle_view) {
+ if (cycle->selected_view) {
/* Recreate the OSD to reflect the view has now gone. */
- destroy_osd_scenes(view->server);
- update_osd(view->server);
+ destroy_osd_scenes(server);
+ update_cycle(server);
}
if (view->scene_tree) {
struct wlr_scene_node *node = &view->scene_tree->node;
- if (osd_state->preview_anchor == node) {
+ if (cycle->preview_anchor == node) {
/*
* If we are the anchor for the current OSD selected view,
* replace the anchor with the node before us.
*/
- osd_state->preview_anchor = lab_wlr_scene_get_prev_node(node);
+ cycle->preview_anchor = lab_wlr_scene_get_prev_node(node);
}
}
}
void
-osd_on_cursor_release(struct server *server, struct wlr_scene_node *node)
+cycle_on_cursor_release(struct server *server, struct wlr_scene_node *node)
{
- assert(server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER);
+ assert(server->input_mode == LAB_INPUT_STATE_CYCLE);
- struct osd_item *item = node_osd_item_from_node(node);
- server->osd_state.cycle_view = item->view;
- osd_finish(server, /*switch_focus*/ true);
+ struct cycle_osd_item *item = node_cycle_osd_item_from_node(node);
+ server->cycle.selected_view = item->view;
+ cycle_finish(server, /*switch_focus*/ true);
}
static void
restore_preview_node(struct server *server)
{
- struct osd_state *osd_state = &server->osd_state;
- if (osd_state->preview_node) {
- wlr_scene_node_reparent(osd_state->preview_node,
- osd_state->preview_parent);
-
- if (osd_state->preview_anchor) {
- wlr_scene_node_place_above(osd_state->preview_node,
- osd_state->preview_anchor);
+ if (server->cycle.preview_node) {
+ wlr_scene_node_reparent(server->cycle.preview_node,
+ server->cycle.preview_parent);
+
+ if (server->cycle.preview_anchor) {
+ wlr_scene_node_place_above(server->cycle.preview_node,
+ server->cycle.preview_anchor);
} else {
/* Selected view was the first node */
- wlr_scene_node_lower_to_bottom(osd_state->preview_node);
+ wlr_scene_node_lower_to_bottom(server->cycle.preview_node);
}
/* Node was disabled / minimized before, disable again */
- if (!osd_state->preview_was_enabled) {
- wlr_scene_node_set_enabled(osd_state->preview_node, false);
+ if (!server->cycle.preview_was_enabled) {
+ wlr_scene_node_set_enabled(server->cycle.preview_node, false);
}
- if (osd_state->preview_was_shaded) {
- struct view *view = node_view_from_node(osd_state->preview_node);
+ if (server->cycle.preview_was_shaded) {
+ struct view *view = node_view_from_node(server->cycle.preview_node);
view_set_shade(view, true);
}
- osd_state->preview_node = NULL;
- osd_state->preview_parent = NULL;
- osd_state->preview_anchor = NULL;
- osd_state->preview_was_shaded = false;
+ server->cycle.preview_node = NULL;
+ server->cycle.preview_parent = NULL;
+ server->cycle.preview_anchor = NULL;
+ server->cycle.preview_was_shaded = false;
}
}
void
-osd_begin(struct server *server, enum lab_cycle_dir direction)
+cycle_begin(struct server *server, enum lab_cycle_dir direction)
{
if (server->input_mode != LAB_INPUT_STATE_PASSTHROUGH) {
return;
}
- server->osd_state.cycle_view = get_next_cycle_view(server,
- server->osd_state.cycle_view, direction);
+ server->cycle.selected_view = get_next_selected_view(server,
+ server->cycle.selected_view, direction);
seat_focus_override_begin(&server->seat,
- LAB_INPUT_STATE_WINDOW_SWITCHER, LAB_CURSOR_DEFAULT);
- update_osd(server);
+ LAB_INPUT_STATE_CYCLE, LAB_CURSOR_DEFAULT);
+ update_cycle(server);
/* Update cursor, in case it is within the area covered by OSD */
cursor_update_focus(server);
}
void
-osd_cycle(struct server *server, enum lab_cycle_dir direction)
+cycle_step(struct server *server, enum lab_cycle_dir direction)
{
- assert(server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER);
+ assert(server->input_mode == LAB_INPUT_STATE_CYCLE);
- server->osd_state.cycle_view = get_next_cycle_view(server,
- server->osd_state.cycle_view, direction);
- update_osd(server);
+ server->cycle.selected_view = get_next_selected_view(server,
+ server->cycle.selected_view, direction);
+ update_cycle(server);
}
void
-osd_finish(struct server *server, bool switch_focus)
+cycle_finish(struct server *server, bool switch_focus)
{
- if (server->input_mode != LAB_INPUT_STATE_WINDOW_SWITCHER) {
+ if (server->input_mode != LAB_INPUT_STATE_CYCLE) {
return;
}
/* FIXME: this sets focus to the old surface even with switch_focus=true */
seat_focus_override_end(&server->seat);
- struct view *cycle_view = server->osd_state.cycle_view;
- server->osd_state.preview_node = NULL;
- server->osd_state.preview_anchor = NULL;
- server->osd_state.cycle_view = NULL;
- server->osd_state.preview_was_shaded = false;
+ struct view *selected_view = server->cycle.selected_view;
+ server->cycle.preview_node = NULL;
+ server->cycle.preview_anchor = NULL;
+ server->cycle.selected_view = NULL;
+ server->cycle.preview_was_shaded = false;
destroy_osd_scenes(server);
- if (server->osd_state.preview_outline) {
+ if (server->cycle.preview_outline) {
/* Destroy the whole multi_rect so we can easily react to new themes */
- wlr_scene_node_destroy(&server->osd_state.preview_outline->tree->node);
- server->osd_state.preview_outline = NULL;
+ wlr_scene_node_destroy(&server->cycle.preview_outline->tree->node);
+ server->cycle.preview_outline = NULL;
}
/* Hiding OSD may need a cursor change */
cursor_update_focus(server);
- if (switch_focus && cycle_view) {
+ if (switch_focus && selected_view) {
if (rc.window_switcher.unshade) {
- view_set_shade(cycle_view, false);
+ view_set_shade(selected_view, false);
}
- desktop_focus_view(cycle_view, /*raise*/ true);
+ desktop_focus_view(selected_view, /*raise*/ true);
}
}
static void
-preview_cycled_view(struct view *view)
+preview_selected_view(struct view *view)
{
assert(view);
assert(view->scene_tree);
- struct osd_state *osd_state = &view->server->osd_state;
+ struct server *server = view->server;
+ struct cycle_state *cycle = &server->cycle;
/* Move previous selected node back to its original place */
- restore_preview_node(view->server);
+ restore_preview_node(server);
/* Store some pointers so we can reset the preview later on */
- osd_state->preview_node = &view->scene_tree->node;
- osd_state->preview_parent = view->scene_tree->node.parent;
+ cycle->preview_node = &view->scene_tree->node;
+ cycle->preview_parent = view->scene_tree->node.parent;
/* Remember the sibling right before the selected node */
- osd_state->preview_anchor = lab_wlr_scene_get_prev_node(
- osd_state->preview_node);
- while (osd_state->preview_anchor && !osd_state->preview_anchor->data) {
+ cycle->preview_anchor = lab_wlr_scene_get_prev_node(
+ cycle->preview_node);
+ while (cycle->preview_anchor && !cycle->preview_anchor->data) {
/* Ignore non-view nodes */
- osd_state->preview_anchor = lab_wlr_scene_get_prev_node(
- osd_state->preview_anchor);
+ cycle->preview_anchor = lab_wlr_scene_get_prev_node(
+ cycle->preview_anchor);
}
/* Store node enabled / minimized state and force-enable if disabled */
- osd_state->preview_was_enabled = osd_state->preview_node->enabled;
- if (!osd_state->preview_was_enabled) {
- wlr_scene_node_set_enabled(osd_state->preview_node, true);
+ cycle->preview_was_enabled = cycle->preview_node->enabled;
+ if (!cycle->preview_was_enabled) {
+ wlr_scene_node_set_enabled(cycle->preview_node, true);
}
if (rc.window_switcher.unshade && view->shaded) {
view_set_shade(view, false);
- osd_state->preview_was_shaded = true;
+ cycle->preview_was_shaded = true;
}
/*
* Create a permanent server->osd_preview_tree instead that can
* also be used as parent for the preview outlines.
*/
- wlr_scene_node_reparent(osd_state->preview_node,
+ wlr_scene_node_reparent(cycle->preview_node,
view->server->view_tree_always_on_top);
/* Finally raise selected node to the top */
- wlr_scene_node_raise_to_top(osd_state->preview_node);
+ wlr_scene_node_raise_to_top(cycle->preview_node);
}
static void
update_osd_on_output(struct server *server, struct output *output,
- struct osd_impl *osd_impl, struct wl_array *views)
+ struct cycle_osd_impl *osd_impl, struct wl_array *views)
{
if (!output_is_usable(output)) {
return;
}
- if (!output->osd_scene.tree) {
+ if (!output->cycle_osd.tree) {
osd_impl->create(output, views);
- assert(output->osd_scene.tree);
+ assert(output->cycle_osd.tree);
}
osd_impl->update(output);
}
static void
-update_osd(struct server *server)
+update_cycle(struct server *server)
{
struct wl_array views;
wl_array_init(&views);
view_array_append(server, &views, rc.window_switcher.criteria);
- struct osd_impl *osd_impl = NULL;
+ struct cycle_osd_impl *osd_impl = NULL;
switch (rc.window_switcher.style) {
- case WINDOW_SWITCHER_CLASSIC:
- osd_impl = &osd_classic_impl;
+ case CYCLE_OSD_STYLE_CLASSIC:
+ osd_impl = &cycle_osd_classic_impl;
break;
- case WINDOW_SWITCHER_THUMBNAIL:
- osd_impl = &osd_thumbnail_impl;
+ case CYCLE_OSD_STYLE_THUMBNAIL:
+ osd_impl = &cycle_osd_thumbnail_impl;
break;
}
- if (!wl_array_len(&views) || !server->osd_state.cycle_view) {
- osd_finish(server, /*switch_focus*/ false);
+ if (!wl_array_len(&views) || !server->cycle.selected_view) {
+ cycle_finish(server, /*switch_focus*/ false);
goto out;
}
if (rc.window_switcher.show) {
/* Display the actual OSD */
switch (rc.window_switcher.output_criteria) {
- case OSD_OUTPUT_ALL: {
+ case CYCLE_OSD_OUTPUT_ALL: {
struct output *output;
wl_list_for_each(output, &server->outputs, link) {
update_osd_on_output(server, output, osd_impl, &views);
}
break;
}
- case OSD_OUTPUT_POINTER:
+ case CYCLE_OSD_OUTPUT_POINTER:
update_osd_on_output(server,
output_nearest_to_cursor(server), osd_impl, &views);
break;
- case OSD_OUTPUT_KEYBOARD: {
+ case CYCLE_OSD_OUTPUT_KEYBOARD: {
struct output *output;
if (server->active_view) {
output = server->active_view->output;
}
if (rc.window_switcher.preview) {
- preview_cycled_view(server->osd_state.cycle_view);
+ preview_selected_view(server->cycle.selected_view);
}
/* Outline current window */
if (rc.window_switcher.outlines) {
- if (view_is_focusable(server->osd_state.cycle_view)) {
- osd_update_preview_outlines(server->osd_state.cycle_view);
+ if (view_is_focusable(server->cycle.selected_view)) {
+ update_preview_outlines(server->cycle.selected_view);
}
}
#include "theme.h"
#include "workspaces.h"
-struct osd_classic_item {
- struct osd_item base;
+struct cycle_osd_classic_item {
+ struct cycle_osd_item base;
struct wlr_scene_tree *normal_tree, *active_tree;
};
struct window_switcher_classic_theme *switcher_theme =
&theme->osd_window_switcher_classic;
- struct window_switcher_field *field;
+ struct cycle_osd_field *field;
wl_list_for_each(field, &rc.window_switcher.fields, link) {
int field_width = field_widths_sum * field->width / 100.0;
struct wlr_scene_node *node = NULL;
height = icon_size;
} else {
struct buf buf = BUF_INIT;
- osd_field_get_content(field, &buf, view);
+ cycle_osd_field_get_content(field, &buf, view);
if (!string_null_or_empty(buf.data)) {
struct scaled_font_buffer *font_buffer =
}
static void
-osd_classic_create(struct output *output, struct wl_array *views)
+cycle_osd_classic_create(struct output *output, struct wl_array *views)
{
- assert(!output->osd_scene.tree && wl_list_empty(&output->osd_scene.items));
+ assert(!output->cycle_osd.tree && wl_list_empty(&output->cycle_osd.items));
struct server *server = output->server;
struct theme *theme = server->theme;
h += switcher_theme->item_height;
}
- output->osd_scene.tree = wlr_scene_tree_create(output->osd_tree);
+ output->cycle_osd.tree = wlr_scene_tree_create(output->cycle_osd_tree);
float *text_color = theme->osd_label_text_color;
float *bg_color = theme->osd_bg_color;
.width = w,
.height = h,
};
- lab_scene_rect_create(output->osd_scene.tree, &bg_opts);
+ lab_scene_rect_create(output->cycle_osd.tree, &bg_opts);
int y = padding;
}
struct scaled_font_buffer *font_buffer =
- scaled_font_buffer_create(output->osd_scene.tree);
+ scaled_font_buffer_create(output->cycle_osd.tree);
wlr_scene_node_set_position(&font_buffer->scene_buffer->node,
x, y + (switcher_theme->item_height - font_height(&font)) / 2);
scaled_font_buffer_update(font_buffer, workspace_name, 0,
/* Draw text for each node */
struct view **view;
wl_array_for_each(view, views) {
- struct osd_classic_item *item = znew(*item);
- wl_list_append(&output->osd_scene.items, &item->base.link);
+ struct cycle_osd_classic_item *item = znew(*item);
+ wl_list_append(&output->cycle_osd.items, &item->base.link);
item->base.view = *view;
- item->base.tree = wlr_scene_tree_create(output->osd_scene.tree);
+ item->base.tree = wlr_scene_tree_create(output->cycle_osd.tree);
node_descriptor_create(&item->base.tree->node,
- LAB_NODE_OSD_ITEM, NULL, item);
+ LAB_NODE_CYCLE_OSD_ITEM, NULL, item);
/*
* OSD border
* +---------------------------------+
error:;
/* Center OSD */
- wlr_scene_node_set_position(&output->osd_scene.tree->node,
+ wlr_scene_node_set_position(&output->cycle_osd.tree->node,
output_box.x + (output_box.width - w) / 2,
output_box.y + (output_box.height - h) / 2);
}
static void
-osd_classic_update(struct output *output)
+cycle_osd_classic_update(struct output *output)
{
- struct osd_classic_item *item;
- wl_list_for_each(item, &output->osd_scene.items, base.link) {
- bool active = item->base.view == output->server->osd_state.cycle_view;
+ struct cycle_osd_classic_item *item;
+ wl_list_for_each(item, &output->cycle_osd.items, base.link) {
+ bool active = item->base.view == output->server->cycle.selected_view;
wlr_scene_node_set_enabled(&item->normal_tree->node, !active);
wlr_scene_node_set_enabled(&item->active_tree->node, active);
}
}
-struct osd_impl osd_classic_impl = {
- .create = osd_classic_create,
- .update = osd_classic_update,
+struct cycle_osd_impl cycle_osd_classic_impl = {
+ .create = cycle_osd_classic_create,
+ .update = cycle_osd_classic_update,
};
[LAB_FIELD_TITLE] = { 'T', field_set_title },
[LAB_FIELD_TITLE_SHORT] = { 't', field_set_title_short },
/* fmt_char can never be matched so prevents LAB_FIELD_CUSTOM recursion */
- [LAB_FIELD_CUSTOM] = { '\0', osd_field_set_custom },
+ [LAB_FIELD_CUSTOM] = { '\0', cycle_osd_field_set_custom },
};
void
-osd_field_set_custom(struct buf *buf, struct view *view, const char *format)
+cycle_osd_field_set_custom(struct buf *buf, struct view *view, const char *format)
{
if (!format) {
wlr_log(WLR_ERROR, "Missing format for custom window switcher field");
}
void
-osd_field_arg_from_xml_node(struct window_switcher_field *field,
+cycle_osd_field_arg_from_xml_node(struct cycle_osd_field *field,
const char *nodename, const char *content)
{
if (!strcmp(nodename, "content")) {
}
bool
-osd_field_is_valid(struct window_switcher_field *field)
+cycle_osd_field_is_valid(struct cycle_osd_field *field)
{
if (field->content == LAB_FIELD_NONE) {
wlr_log(WLR_ERROR, "Invalid OSD field: no content set");
}
void
-osd_field_get_content(struct window_switcher_field *field,
+cycle_osd_field_get_content(struct cycle_osd_field *field,
struct buf *buf, struct view *view)
{
if (field->content == LAB_FIELD_NONE) {
}
void
-osd_field_free(struct window_switcher_field *field)
+cycle_osd_field_free(struct cycle_osd_field *field)
{
zfree(field->format);
zfree(field);
#include "theme.h"
#include "view.h"
-struct osd_thumbnail_item {
- struct osd_item base;
+struct cycle_osd_thumbnail_item {
+ struct cycle_osd_item base;
struct scaled_font_buffer *normal_label;
struct scaled_font_buffer *active_label;
struct lab_scene_rect *active_bg;
const float *text_color, const float *bg_color, int y)
{
struct buf buf = BUF_INIT;
- osd_field_set_custom(&buf, view,
+ cycle_osd_field_set_custom(&buf, view,
rc.window_switcher.thumbnail_label_format);
struct scaled_font_buffer *buffer =
scaled_font_buffer_create(parent);
return buffer;
}
-static struct osd_thumbnail_item *
+static struct cycle_osd_thumbnail_item *
create_item_scene(struct wlr_scene_tree *parent, struct view *view,
struct output *output)
{
return NULL;
}
- struct osd_thumbnail_item *item = znew(*item);
- wl_list_append(&output->osd_scene.items, &item->base.link);
+ struct cycle_osd_thumbnail_item *item = znew(*item);
+ wl_list_append(&output->cycle_osd.items, &item->base.link);
struct wlr_scene_tree *tree = wlr_scene_tree_create(parent);
- node_descriptor_create(&tree->node, LAB_NODE_OSD_ITEM, NULL, item);
+ node_descriptor_create(&tree->node, LAB_NODE_CYCLE_OSD_ITEM, NULL, item);
item->base.tree = tree;
item->base.view = view;
}
static void
-osd_thumbnail_create(struct output *output, struct wl_array *views)
+cycle_osd_thumbnail_create(struct output *output, struct wl_array *views)
{
- assert(!output->osd_scene.tree && wl_list_empty(&output->osd_scene.items));
+ assert(!output->cycle_osd.tree && wl_list_empty(&output->cycle_osd.items));
struct server *server = output->server;
struct theme *theme = server->theme;
&theme->osd_window_switcher_thumbnail;
int padding = theme->osd_border_width + switcher_theme->padding;
- output->osd_scene.tree = wlr_scene_tree_create(output->osd_tree);
+ output->cycle_osd.tree = wlr_scene_tree_create(output->cycle_osd_tree);
int nr_views = wl_array_len(views);
assert(nr_views > 0);
struct view **view;
int index = 0;
wl_array_for_each(view, views) {
- struct osd_thumbnail_item *item = create_item_scene(
- output->osd_scene.tree, *view, output);
+ struct cycle_osd_thumbnail_item *item = create_item_scene(
+ output->cycle_osd.tree, *view, output);
if (!item) {
break;
}
.height = nr_rows * switcher_theme->item_height + 2 * padding,
};
struct lab_scene_rect *bg =
- lab_scene_rect_create(output->osd_scene.tree, &bg_opts);
+ lab_scene_rect_create(output->cycle_osd.tree, &bg_opts);
wlr_scene_node_lower_to_bottom(&bg->tree->node);
/* center */
&output_box);
int lx = output_box.x + (output_box.width - bg_opts.width) / 2;
int ly = output_box.y + (output_box.height - bg_opts.height) / 2;
- wlr_scene_node_set_position(&output->osd_scene.tree->node, lx, ly);
+ wlr_scene_node_set_position(&output->cycle_osd.tree->node, lx, ly);
}
static void
-osd_thumbnail_update(struct output *output)
+cycle_osd_thumbnail_update(struct output *output)
{
- struct osd_thumbnail_item *item;
- wl_list_for_each(item, &output->osd_scene.items, base.link) {
- bool active = (item->base.view == output->server->osd_state.cycle_view);
+ struct cycle_osd_thumbnail_item *item;
+ wl_list_for_each(item, &output->cycle_osd.items, base.link) {
+ bool active = (item->base.view == output->server->cycle.selected_view);
wlr_scene_node_set_enabled(&item->active_bg->tree->node, active);
wlr_scene_node_set_enabled(
&item->active_label->scene_buffer->node, active);
}
}
-struct osd_impl osd_thumbnail_impl = {
- .create = osd_thumbnail_create,
- .update = osd_thumbnail_update,
+struct cycle_osd_impl cycle_osd_thumbnail_impl = {
+ .create = cycle_osd_thumbnail_create,
+ .update = cycle_osd_thumbnail_update,
};
#define IGNORE_SSD true
#define IGNORE_MENU true
-#define IGNORE_OSD_PREVIEW_OUTLINE true
+#define IGNORE_CYCLE_PREVIEW_OUTLINE true
#define IGNORE_SNAPPING_OVERLAY true
static struct view *last_view;
if (node->parent == &server->scene->tree) {
struct output *output;
wl_list_for_each(output, &server->outputs, link) {
- if (node == &output->osd_tree->node) {
+ if (node == &output->cycle_osd_tree->node) {
return "output->osd_tree";
}
if (node == &output->layer_popup_tree->node) {
/* Created on-demand */
return "seat->im_relay->popup_tree";
}
- if (server->osd_state.preview_outline
- && node == &server->osd_state.preview_outline->tree->node) {
+ if (server->cycle.preview_outline
+ && node == &server->cycle.preview_outline->tree->node) {
/* Created on-demand */
- return "osd_state->preview_outline";
+ return "cycle_state->preview_outline";
}
#if HAVE_XWAYLAND
if (node == &server->unmanaged_tree->node) {
}
printf("%.*s %*c %4d %4d [%p]\n", max_width - 1, type, padding, ' ', x, y, node);
- struct lab_scene_rect *osd_preview_outline =
- server->osd_state.preview_outline;
if ((IGNORE_MENU && node == &server->menu_tree->node)
|| (IGNORE_SSD && last_view
&& ssd_debug_is_root_node(last_view->ssd, node))
- || (IGNORE_OSD_PREVIEW_OUTLINE && osd_preview_outline
- && node == &osd_preview_outline->tree->node)
+ || (IGNORE_CYCLE_PREVIEW_OUTLINE && server->cycle.preview_outline
+ && node == &server->cycle.preview_outline->tree->node)
|| (IGNORE_SNAPPING_OVERLAY && server->seat.overlay.rect
&& node == &server->seat.overlay.rect->tree->node)) {
printf("%*c%s\n", pos + 4 + INDENT_SIZE, ' ', "<skipping children>");
return;
}
- if (view->server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER) {
+ if (view->server->input_mode == LAB_INPUT_STATE_CYCLE) {
wlr_log(WLR_DEBUG, "not focusing window while window switching");
return;
}
ret.node = node;
ret.type = LAB_NODE_MENUITEM;
return ret;
- case LAB_NODE_OSD_ITEM:
+ case LAB_NODE_CYCLE_OSD_ITEM:
/* Always return the top scene node for osd items */
ret.node = node;
- ret.type = LAB_NODE_OSD_ITEM;
+ ret.type = LAB_NODE_CYCLE_OSD_ITEM;
return ret;
case LAB_NODE_BUTTON_FIRST...LAB_NODE_BUTTON_LAST:
case LAB_NODE_SSD_ROOT:
process_release_mousebinding(struct server *server,
struct cursor_context *ctx, uint32_t button)
{
- if (server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER) {
+ if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
return;
}
process_press_mousebinding(struct server *server, struct cursor_context *ctx,
uint32_t button)
{
- if (server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER) {
+ if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
return false;
}
}
return notify;
}
- if (server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER) {
- if (ctx.type == LAB_NODE_OSD_ITEM) {
- osd_on_cursor_release(server, ctx.node);
+ if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
+ if (ctx.type == LAB_NODE_CYCLE_OSD_ITEM) {
+ cycle_on_cursor_release(server, ctx.node);
}
return notify;
}
overlay_update(seat);
}
- bool window_switcher_active = server->input_mode
- == LAB_INPUT_STATE_WINDOW_SWITCHER;
+ bool cycling = server->input_mode == LAB_INPUT_STATE_CYCLE;
- if ((window_switcher_active || seat->workspace_osd_shown_by_modifier)
+ if ((cycling || seat->workspace_osd_shown_by_modifier)
&& !keyboard_get_all_modifiers(seat)) {
- if (window_switcher_active) {
+ if (cycling) {
if (key_state_nr_bound_keys()) {
should_cancel_cycling_on_next_key_release = true;
} else {
should_cancel_cycling_on_next_key_release = false;
- osd_finish(server, /*switch_focus*/ true);
+ cycle_finish(server, /*switch_focus*/ true);
}
}
if (seat->workspace_osd_shown_by_modifier) {
*/
if (should_cancel_cycling_on_next_key_release) {
should_cancel_cycling_on_next_key_release = false;
- osd_finish(server, /*switch_focus*/ true);
+ cycle_finish(server, /*switch_focus*/ true);
}
/*
for (int i = 0; i < keyinfo->translated.nr_syms; i++) {
if (keyinfo->translated.syms[i] == XKB_KEY_Escape) {
/* Esc deactivates window switcher */
- osd_finish(server, /*switch_focus*/ false);
+ cycle_finish(server, /*switch_focus*/ false);
return true;
}
if (keyinfo->translated.syms[i] == XKB_KEY_Up
|| keyinfo->translated.syms[i] == XKB_KEY_Left) {
/* Up/Left cycles the window backward */
- osd_cycle(server, LAB_CYCLE_DIR_BACKWARD);
+ cycle_step(server, LAB_CYCLE_DIR_BACKWARD);
return true;
}
if (keyinfo->translated.syms[i] == XKB_KEY_Down
|| keyinfo->translated.syms[i] == XKB_KEY_Right) {
/* Down/Right cycles the window forward */
- osd_cycle(server, LAB_CYCLE_DIR_FORWARD);
+ cycle_step(server, LAB_CYCLE_DIR_FORWARD);
return true;
}
}
key_state_store_pressed_key_as_bound(event->keycode);
handle_menu_keys(server, &keyinfo.translated);
return LAB_KEY_HANDLED_TRUE;
- } else if (server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER) {
+ } else if (server->input_mode == LAB_INPUT_STATE_CYCLE) {
if (handle_cycle_view_key(server, &keyinfo)) {
key_state_store_pressed_key_as_bound(event->keycode);
return LAB_KEY_HANDLED_TRUE;
return (struct menuitem *)node_descriptor->data;
}
-struct osd_item *
-node_osd_item_from_node(struct wlr_scene_node *wlr_scene_node)
+struct cycle_osd_item *
+node_cycle_osd_item_from_node(struct wlr_scene_node *wlr_scene_node)
{
assert(wlr_scene_node->data);
struct node_descriptor *node_descriptor = wlr_scene_node->data;
- assert(node_descriptor->type == LAB_NODE_OSD_ITEM);
- return (struct osd_item *)node_descriptor->data;
+ assert(node_descriptor->type == LAB_NODE_CYCLE_OSD_ITEM);
+ return (struct cycle_osd_item *)node_descriptor->data;
}
struct ssd_button *
wlr_scene_node_destroy(&output->layer_tree[i]->node);
}
wlr_scene_node_destroy(&output->layer_popup_tree->node);
- wlr_scene_node_destroy(&output->osd_tree->node);
+ wlr_scene_node_destroy(&output->cycle_osd_tree->node);
wlr_scene_node_destroy(&output->session_lock_tree->node);
if (output->workspace_osd) {
wlr_scene_node_destroy(&output->workspace_osd->node);
wl_signal_add(&wlr_output->events.request_state, &output->request_state);
wl_list_init(&output->regions);
- wl_list_init(&output->osd_scene.items);
+ wl_list_init(&output->cycle_osd.items);
/*
* Create layer-trees (background, bottom, top and overlay) and
wlr_scene_tree_create(&server->scene->tree);
}
output->layer_popup_tree = wlr_scene_tree_create(&server->scene->tree);
- output->osd_tree = wlr_scene_tree_create(&server->scene->tree);
+ output->cycle_osd_tree = wlr_scene_tree_create(&server->scene->tree);
output->session_lock_tree = wlr_scene_tree_create(&server->scene->tree);
/*
wlr_scene_node_place_below(&output->layer_tree[3]->node, menu_node);
wlr_scene_node_place_below(&output->layer_popup_tree->node, menu_node);
- wlr_scene_node_raise_to_top(&output->osd_tree->node);
+ wlr_scene_node_raise_to_top(&output->cycle_osd_tree->node);
wlr_scene_node_raise_to_top(&output->session_lock_tree->node);
/*
* z-order for nodes which cover the whole work-area. For per-output
* scene-trees, see handle_new_output() in src/output.c
*
- * | Type | Scene Tree | Per Output | Example
- * | ----------------- | ---------------- | ---------- | -------
- * | ext-session | lock-screen | Yes | swaylock
- * | osd | osd_tree | Yes |
- * | compositor-menu | menu_tree | No | root-menu
- * | layer-shell | layer-popups | Yes |
- * | layer-shell | overlay-layer | Yes |
- * | layer-shell | top-layer | Yes | waybar
- * | xwayland-OR | unmanaged | No | dmenu
- * | xdg-popups | xdg-popups | No |
- * | toplevels windows | always-on-top | No |
- * | toplevels windows | normal | No | firefox
- * | toplevels windows | always-on-bottom | No | pcmanfm-qt --desktop
- * | layer-shell | bottom-layer | Yes | waybar
- * | layer-shell | background-layer | Yes | swaybg
+ * | Type | Scene Tree | Per Output | Example
+ * | ------------------- | ---------------- | ---------- | -------
+ * | ext-session | lock-screen | Yes | swaylock
+ * | window switcher OSD | cycle_osd_tree | Yes |
+ * | compositor-menu | menu_tree | No | root-menu
+ * | layer-shell | layer-popups | Yes |
+ * | layer-shell | overlay-layer | Yes |
+ * | layer-shell | top-layer | Yes | waybar
+ * | xwayland-OR | unmanaged | No | dmenu
+ * | xdg-popups | xdg-popups | No |
+ * | toplevels windows | always-on-top | No |
+ * | toplevels windows | normal | No | firefox
+ * | toplevels windows | always-on-bottom | No | pcmanfm-qt --desktop
+ * | layer-shell | bottom-layer | Yes | waybar
+ * | layer-shell | background-layer | Yes | swaybg
*/
server->view_tree_always_on_bottom = wlr_scene_tree_create(&server->scene->tree);
{
assert(view);
- if (view->server->input_mode == LAB_INPUT_STATE_WINDOW_SWITCHER) {
+ if (view->server->input_mode == LAB_INPUT_STATE_CYCLE) {
wlr_log(WLR_ERROR, "not minimizing window while window switching");
return;
}
zfree(view->tiled_region_evacuate);
}
- osd_on_view_destroy(view);
+ cycle_on_view_destroy(view);
undecorate(view);
view_set_icon(view, NULL, NULL);
projects / proto / labwc.git / commitdiff