mirrors/labwc
1
0
Fork 0
mirror of https://github.com/labwc/labwc.git synced 2026-03-29 07:58:10 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

overlay: allow to draw both/either of filled/outlined rectangle

Browse source 
Filled/outlined rectangles shown as snapping overlay are now enabled/disabled
independently with `snapping.overlay.[region|edge].bg.enabled` and
`snapping.overlay.[region|edge].border.enabled`.

To keep the default behavior, `*.bg.enabled` is yes and `*.border.enabled` is
no for hardware-based renderers, while `*.bg.enabled` is no and
`*.border.enabled` is yes for software-based (pixman) renderer.

Users can now use a filled rectangle as an overlay even with pixman renderer.
However, this may severely impact performance when used with translucent
`snapping.overlay.[region|edge].bg.color`.

This commit includes a refactor to use substruct `theme_snapping_overlay`
inside `theme` in order to pass it to `create_overlay_rect()` in a cleaner way.

Breaking changes is:
- `snapping.overlay.[region|edge].fill` is now removed.
This commit is contained in:
tokyo4j 2024-04-21 02:30:31 +09:00 • committed by Johan Malm
parent 34290ef629
commit b0ba585ff8
9 changed files with 160 additions and 122 deletions
Download patch file Download diff file Expand all files Collapse all files

22
docs/labwc-theme.5.scd
View file

@ -210,15 +210,25 @@ elements are not listed here, but are supported.
Height of boxes in workspace switcher in pixels. Setting to 0 disables Height of boxes in workspace switcher in pixels. Setting to 0 disables
boxes. Default is 20. boxes. Default is 20.
*snapping.overlay.region.fill* [yes|no] *snapping.overlay.region.bg.enabled* [yes|no]
Show a filled rectangle as an overlay when a window is snapped to a region. Show a filled rectangle as an overlay when a window is snapped to a region.
Otherwise, an outlined rectangle is shown instead. Default is yes for hardware-based renderers and no for software-based
If software rendering is used, an outlined rectangle is always shown. renderers.
*snapping.overlay.edge.fill* [yes|no] *snapping.overlay.edge.bg.enabled* [yes|no]
Show a filled rectangle as an overlay when a window is snapped to an edge. Show a filled rectangle as an overlay when a window is snapped to an edge.
Otherwise, an outlined rectangle is shown instead. Default is yes for hardware-based renderer and no for software-based
If software rendering is used, an outlined rectangle is always shown. renderers.
*snapping.overlay.region.border.enabled* [yes|no]
Show an outlined rectangle as an overlay when a window is snapped to a
region. Default is no for hardware-based renderers and yes for software-based
renderers.
*snapping.overlay.edge.border.enabled* [yes|no]
Show an outlined rectangle as an overlay when a window is snapped to an edge.
Default is no for hardware-based renderer and yes for software-based
renderers.
*snapping.overlay.region.bg.color* *snapping.overlay.region.bg.color*
Color of a filled rectangle shown as an overlay when a window is snapped to Color of a filled rectangle shown as an overlay when a window is snapped to

14
docs/themerc
View file

@ -74,8 +74,18 @@ osd.window-switcher.preview.border.color: #dddda6,#000000,#dddda6
osd.workspace-switcher.boxes.width: 20 osd.workspace-switcher.boxes.width: 20
osd.workspace-switcher.boxes.height: 20 osd.workspace-switcher.boxes.height: 20
snapping.overlay.region.fill: yes # Default values for following options change depending on the rendering
snapping.overlay.edge.fill: yes # backend. For software-based renderers, *.bg.enabled is "no" and
# *.border.enabled is "yes" if not set. For hardware-based renderers,
# *.bg.enabled is "yes" and *.border.enabled is "no" if not set.
# Setting *.bg.enabled to "yes" for software-based renderer with translucent
# background color may severely impact performance.
#
# snapping.overlay.region.bg.enabled:
# snapping.overlay.edge.bg.enabled:
# snapping.overlay.region.border.enabled:
# snapping.overlay.edge.border.enabled:
snapping.overlay.region.bg.color: #8080b380 snapping.overlay.region.bg.color: #8080b380
snapping.overlay.edge.bg.color: #8080b380 snapping.overlay.edge.bg.color: #8080b380
snapping.overlay.region.border.width: 1 snapping.overlay.region.border.width: 1

15
include/overlay.h
View file

@ -8,14 +8,13 @@
#include "view.h" #include "view.h"
struct overlay_rect { struct overlay_rect {
struct wlr_scene_node *node; struct wlr_scene_tree *tree;
bool fill;
union { bool bg_enabled;
/* if fill is true */ struct wlr_scene_rect *bg_rect;
struct wlr_scene_rect *scene_rect;
/* if fill is false */ bool border_enabled;
struct multi_rect *pixman_rect; struct multi_rect *border_rect;
};
}; };
struct overlay { struct overlay {

25
include/theme.h
View file

@ -17,6 +17,14 @@ enum lab_justification {
LAB_JUSTIFY_RIGHT, LAB_JUSTIFY_RIGHT,
}; };
struct theme_snapping_overlay {
bool bg_enabled;
bool border_enabled;
float bg_color[4];
int border_width;
float border_color[3][4];
};
struct theme { struct theme {
int border_width; int border_width;
int padding_height; int padding_height;
@ -82,16 +90,8 @@ struct theme {
int osd_workspace_switcher_boxes_width; int osd_workspace_switcher_boxes_width;
int osd_workspace_switcher_boxes_height; int osd_workspace_switcher_boxes_height;
bool snapping_overlay_region_fill; struct theme_snapping_overlay
bool snapping_overlay_edge_fill; snapping_overlay_region, snapping_overlay_edge;
float snapping_overlay_region_bg_color[4];
float snapping_overlay_edge_bg_color[4];
int snapping_overlay_region_border_width;
int snapping_overlay_edge_border_width;
float snapping_overlay_region_border_color[3][4];
float snapping_overlay_edge_border_color[3][4];
/* textures */ /* textures */
struct lab_data_buffer *button_close_active_unpressed; struct lab_data_buffer *button_close_active_unpressed;
@ -128,13 +128,16 @@ struct theme {
int osd_window_switcher_item_height; int osd_window_switcher_item_height;
}; };
struct server;
/** /**
* theme_init - read openbox theme and generate button textures * theme_init - read openbox theme and generate button textures
* @theme: theme data * @theme: theme data
* @server: server
* @theme_name: theme-name in <theme-dir>/<theme-name>/openbox-3/themerc * @theme_name: theme-name in <theme-dir>/<theme-name>/openbox-3/themerc
* Note <theme-dir> is obtained in theme-dir.c * Note <theme-dir> is obtained in theme-dir.c
*/ */
void theme_init(struct theme *theme, const char *theme_name); void theme_init(struct theme *theme, struct server *server, const char *theme_name);
/** /**
* theme_finish - free button textures * theme_finish - free button textures

30
src/debug.c
View file

@ -138,13 +138,13 @@ get_special(struct server *server, struct wlr_scene_node *node)
if (node == &server->seat.drag.icons->node) { if (node == &server->seat.drag.icons->node) {
return "seat->drag.icons"; return "seat->drag.icons";
} }
if (server->seat.overlay.region_rect.node if (server->seat.overlay.region_rect.tree
&& node == server->seat.overlay.region_rect.node) { && node == &server->seat.overlay.region_rect.tree->node) {
/* Created on-demand */ /* Created on-demand */
return "seat->overlay.region_rect"; return "seat->overlay.region_rect";
} }
if (server->seat.overlay.edge_rect.node if (server->seat.overlay.edge_rect.tree
&& node == server->seat.overlay.edge_rect.node) { && node == &server->seat.overlay.edge_rect.tree->node) {
/* Created on-demand */ /* Created on-demand */
return "seat->overlay.edge_rect"; return "seat->overlay.edge_rect";
} }
@ -219,17 +219,23 @@ dump_tree(struct server *server, struct wlr_scene_node *node,
} }
printf("%.*s %*c %4d %4d [%p]\n", max_width - 1, type, padding, ' ', x, y, node); printf("%.*s %*c %4d %4d [%p]\n", max_width - 1, type, padding, ' ', x, y, node);
struct multi_rect *osd_preview_outline =
server->osd_state.preview_outline;
struct multi_rect *region_snapping_overlay_outline =
server->seat.overlay.region_rect.border_rect;
struct multi_rect *edge_snapping_overlay_outline =
server->seat.overlay.edge_rect.border_rect;
if ((IGNORE_MENU && node == &server->menu_tree->node) if ((IGNORE_MENU && node == &server->menu_tree->node)
|| (IGNORE_SSD && last_view || (IGNORE_SSD && last_view
&& ssd_debug_is_root_node(last_view->ssd, node)) && ssd_debug_is_root_node(last_view->ssd, node))
|| (IGNORE_OSD_PREVIEW_OUTLINE && server->osd_state.preview_outline || (IGNORE_OSD_PREVIEW_OUTLINE && osd_preview_outline
&& node == &server->osd_state.preview_outline->tree->node) && node == &osd_preview_outline->tree->node)
|| (IGNORE_SNAPPING_PREVIEW_OUTLINE && server->seat.overlay.region_rect.node || (IGNORE_SNAPPING_PREVIEW_OUTLINE
&& !server->seat.overlay.region_rect.fill && region_snapping_overlay_outline
&& node == server->seat.overlay.region_rect.node) && node == &region_snapping_overlay_outline->tree->node)
|| (IGNORE_SNAPPING_PREVIEW_OUTLINE && server->seat.overlay.edge_rect.node || (IGNORE_SNAPPING_PREVIEW_OUTLINE
&& !server->seat.overlay.edge_rect.fill && edge_snapping_overlay_outline
&& node == server->seat.overlay.edge_rect.node)) { && node == &edge_snapping_overlay_outline->tree->node)) {
printf("%*c%s\n", pos + 4 + INDENT_SIZE, ' ', "<skipping children>"); printf("%*c%s\n", pos + 4 + INDENT_SIZE, ' ', "<skipping children>");
return; return;
} }

2
src/main.c
View file

@ -171,7 +171,7 @@ main(int argc, char *argv[])
server_start(&server); server_start(&server);
struct theme theme = { 0 }; struct theme theme = { 0 };
theme_init(&theme, rc.theme_name); theme_init(&theme, &server, rc.theme_name);
rc.theme = &theme; rc.theme = &theme;
server.theme = &theme; server.theme = &theme;

88
src/overlay.c
View file

@ -1,62 +1,54 @@
// SPDX-License-Identifier: GPL-2.0-only // SPDX-License-Identifier: GPL-2.0-only
#include <assert.h> #include <assert.h>
#include <wlr/render/pixman.h>
#include "labwc.h" #include "labwc.h"
#include "overlay.h" #include "overlay.h"
#include "view.h" #include "view.h"
#include "theme.h"
static void static void
create_overlay_rect(struct seat *seat, struct overlay_rect *rect, int fill, create_overlay_rect(struct seat *seat, struct overlay_rect *rect,
float bg_color[4], int border_width, float border_colors[3][4]) struct theme_snapping_overlay *theme)
{ {
struct server *server = seat->server; struct server *server = seat->server;
rect->fill = fill; rect->bg_enabled = theme->bg_enabled;
/* For pixman renderer, always render outlines to save CPU resource */ rect->border_enabled = theme->border_enabled;
if (wlr_renderer_is_pixman(server->renderer)) { rect->tree = wlr_scene_tree_create(&server->scene->tree);
rect->fill = false;
if (rect->bg_enabled) {
/* Create a filled rectangle */
rect->bg_rect = wlr_scene_rect_create(
rect->tree, 0, 0, theme->bg_color);
} }
if (rect->fill) { if (rect->border_enabled) {
/* Create a filled rectangle */
rect->scene_rect = wlr_scene_rect_create(&server->scene->tree,
0, 0, bg_color);
rect->node = &rect->scene_rect->node;
} else {
/* Create outlines */ /* Create outlines */
float *colors[3] = { float *colors[3] = {
border_colors[0], theme->border_color[0],
border_colors[1], theme->border_color[1],
border_colors[2], theme->border_color[2],
}; };
rect->pixman_rect = multi_rect_create(&server->scene->tree, rect->border_rect = multi_rect_create(
colors, border_width); rect->tree, colors, theme->border_width);
rect->node = &rect->pixman_rect->tree->node;
} }
wlr_scene_node_set_enabled(rect->node, false); wlr_scene_node_set_enabled(&rect->tree->node, false);
} }
void overlay_reconfigure(struct seat *seat) void overlay_reconfigure(struct seat *seat)
{ {
if (seat->overlay.region_rect.node) { if (seat->overlay.region_rect.tree) {
wlr_scene_node_destroy(seat->overlay.region_rect.node); wlr_scene_node_destroy(&seat->overlay.region_rect.tree->node);
} }
if (seat->overlay.edge_rect.node) { if (seat->overlay.edge_rect.tree) {
wlr_scene_node_destroy(seat->overlay.edge_rect.node); wlr_scene_node_destroy(&seat->overlay.edge_rect.tree->node);
} }
struct theme *theme = seat->server->theme; struct theme *theme = seat->server->theme;
create_overlay_rect(seat, &seat->overlay.region_rect, create_overlay_rect(seat, &seat->overlay.region_rect,
theme->snapping_overlay_region_fill, &theme->snapping_overlay_region);
theme->snapping_overlay_region_bg_color,
theme->snapping_overlay_region_border_width,
theme->snapping_overlay_region_border_color);
create_overlay_rect(seat, &seat->overlay.edge_rect, create_overlay_rect(seat, &seat->overlay.edge_rect,
theme->snapping_overlay_edge_fill, &theme->snapping_overlay_edge);
theme->snapping_overlay_edge_bg_color,
theme->snapping_overlay_edge_border_width,
theme->snapping_overlay_edge_border_color);
} }
static void static void
@ -65,20 +57,20 @@ show_overlay(struct seat *seat, struct overlay_rect *rect, struct wlr_box *box)
struct server *server = seat->server; struct server *server = seat->server;
struct view *view = server->grabbed_view; struct view *view = server->grabbed_view;
assert(view); assert(view);
struct wlr_scene_node *node = rect->node;
if (!node) { if (!rect->tree) {
overlay_reconfigure(seat); overlay_reconfigure(seat);
node = rect->node; assert(rect->tree);
assert(node);
} }
if (rect->fill) { if (rect->bg_enabled) {
wlr_scene_rect_set_size(rect->scene_rect, box->width, box->height); wlr_scene_rect_set_size(rect->bg_rect, box->width, box->height);
} else { }
multi_rect_set_size(rect->pixman_rect, box->width, box->height); if (rect->border_enabled) {
multi_rect_set_size(rect->border_rect, box->width, box->height);
} }
struct wlr_scene_node *node = &rect->tree->node;
wlr_scene_node_reparent(node, view->scene_tree->node.parent); wlr_scene_node_reparent(node, view->scene_tree->node.parent);
wlr_scene_node_place_below(node, &view->scene_tree->node); wlr_scene_node_place_below(node, &view->scene_tree->node);
wlr_scene_node_set_position(node, box->x, box->y); wlr_scene_node_set_position(node, box->x, box->y);
@ -88,13 +80,13 @@ show_overlay(struct seat *seat, struct overlay_rect *rect, struct wlr_box *box)
static void static void
inactivate_overlay(struct overlay *overlay) inactivate_overlay(struct overlay *overlay)
{ {
if (overlay->region_rect.node) { if (overlay->region_rect.tree) {
wlr_scene_node_set_enabled( wlr_scene_node_set_enabled(
overlay->region_rect.node, false); &overlay->region_rect.tree->node, false);
} }
if (overlay->edge_rect.node) { if (overlay->edge_rect.tree) {
wlr_scene_node_set_enabled( wlr_scene_node_set_enabled(
overlay->edge_rect.node, false); &overlay->edge_rect.tree->node, false);
} }
overlay->active.region = NULL; overlay->active.region = NULL;
overlay->active.edge = VIEW_EDGE_INVALID; overlay->active.edge = VIEW_EDGE_INVALID;
@ -259,12 +251,12 @@ overlay_hide(struct seat *seat)
* Reparent the rectangle nodes to server's scene-tree so they don't * Reparent the rectangle nodes to server's scene-tree so they don't
* get destroyed on view destruction * get destroyed on view destruction
*/ */
if (overlay->region_rect.node) { if (overlay->region_rect.tree) {
wlr_scene_node_reparent(overlay->region_rect.node, wlr_scene_node_reparent(&overlay->region_rect.tree->node,
&server->scene->tree); &server->scene->tree);
} }
if (overlay->edge_rect.node) { if (overlay->edge_rect.tree) {
wlr_scene_node_reparent(overlay->edge_rect.node, wlr_scene_node_reparent(&overlay->edge_rect.tree->node,
&server->scene->tree); &server->scene->tree);
} }
} }

2
src/server.c
View file

@ -51,7 +51,7 @@ reload_config_and_theme(struct server *server)
rcxml_finish(); rcxml_finish();
rcxml_read(rc.config_file); rcxml_read(rc.config_file);
theme_finish(server->theme); theme_finish(server->theme);
theme_init(server->theme, rc.theme_name); theme_init(server->theme, server, rc.theme_name);
struct view *view; struct view *view;
wl_list_for_each(view, &server->views, link) { wl_list_for_each(view, &server->views, link) {

84
src/theme.c
View file

@ -17,6 +17,7 @@
#include <string.h> #include <string.h>
#include <wlr/util/box.h> #include <wlr/util/box.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include <wlr/render/pixman.h>
#include <strings.h> #include <strings.h>
#include "common/macros.h" #include "common/macros.h"
#include "common/dir.h" #include "common/dir.h"
@ -28,6 +29,7 @@
#include "common/string-helpers.h" #include "common/string-helpers.h"
#include "config/rcxml.h" #include "config/rcxml.h"
#include "button/button-png.h" #include "button/button-png.h"
#include "labwc.h"
#if HAVE_RSVG #if HAVE_RSVG
#include "button/button-svg.h" #include "button/button-svg.h"
@ -463,7 +465,7 @@ parse_justification(const char *str)
* theme_builtin() applies a theme that is similar to vanilla GTK * theme_builtin() applies a theme that is similar to vanilla GTK
*/ */
static void static void
theme_builtin(struct theme *theme) theme_builtin(struct theme *theme, struct server *server)
{ {
theme->border_width = 1; theme->border_width = 1;
theme->padding_height = 3; theme->padding_height = 3;
@ -538,21 +540,31 @@ theme_builtin(struct theme *theme)
theme->osd_border_color[0] = FLT_MIN; theme->osd_border_color[0] = FLT_MIN;
theme->osd_label_text_color[0] = FLT_MIN; theme->osd_label_text_color[0] = FLT_MIN;
theme->snapping_overlay_region_fill = true; if (wlr_renderer_is_pixman(server->renderer)) {
theme->snapping_overlay_edge_fill = true; /* Draw only outlined overlay by default to save CPU resource */
theme->snapping_overlay_region.bg_enabled = false;
theme->snapping_overlay_edge.bg_enabled = false;
theme->snapping_overlay_region.border_enabled = true;
theme->snapping_overlay_edge.border_enabled = true;
} else {
theme->snapping_overlay_region.bg_enabled = true;
theme->snapping_overlay_edge.bg_enabled = true;
theme->snapping_overlay_region.border_enabled = false;
theme->snapping_overlay_edge.border_enabled = false;
}
parse_hexstr("#8080b380", theme->snapping_overlay_region_bg_color); parse_hexstr("#8080b380", theme->snapping_overlay_region.bg_color);
parse_hexstr("#8080b380", theme->snapping_overlay_edge_bg_color); parse_hexstr("#8080b380", theme->snapping_overlay_edge.bg_color);
/* inherit settings in post_processing() if not set elsewhere */ /* inherit settings in post_processing() if not set elsewhere */
theme->snapping_overlay_region_border_width = INT_MIN; theme->snapping_overlay_region.border_width = INT_MIN;
theme->snapping_overlay_edge_border_width = INT_MIN; theme->snapping_overlay_edge.border_width = INT_MIN;
memset(theme->snapping_overlay_region_border_color, 0, memset(theme->snapping_overlay_region.border_color, 0,
sizeof(theme->snapping_overlay_region_border_color)); sizeof(theme->snapping_overlay_region.border_color));
theme->snapping_overlay_region_border_color[0][0] = FLT_MIN; theme->snapping_overlay_region.border_color[0][0] = FLT_MIN;
memset(theme->snapping_overlay_edge_border_color, 0, memset(theme->snapping_overlay_edge.border_color, 0,
sizeof(theme->snapping_overlay_edge_border_color)); sizeof(theme->snapping_overlay_edge.border_color));
theme->snapping_overlay_edge_border_color[0][0] = FLT_MIN; theme->snapping_overlay_edge.border_color[0][0] = FLT_MIN;
} }
static void static void
@ -754,29 +766,35 @@ entry(struct theme *theme, const char *key, const char *value)
if (match_glob(key, "osd.label.text.color")) { if (match_glob(key, "osd.label.text.color")) {
parse_hexstr(value, theme->osd_label_text_color); parse_hexstr(value, theme->osd_label_text_color);
} }
if (match_glob(key, "snapping.overlay.region.fill")) { if (match_glob(key, "snapping.overlay.region.bg.enabled")) {
theme->snapping_overlay_region_fill = parse_bool(value, true); set_bool(value, &theme->snapping_overlay_region.bg_enabled);
} }
if (match_glob(key, "snapping.overlay.edge.fill")) { if (match_glob(key, "snapping.overlay.edge.bg.enabled")) {
theme->snapping_overlay_edge_fill = parse_bool(value, true); set_bool(value, &theme->snapping_overlay_edge.bg_enabled);
}
if (match_glob(key, "snapping.overlay.region.border.enabled")) {
set_bool(value, &theme->snapping_overlay_region.border_enabled);
}
if (match_glob(key, "snapping.overlay.edge.border.enabled")) {
set_bool(value, &theme->snapping_overlay_edge.border_enabled);
} }
if (match_glob(key, "snapping.overlay.region.bg.color")) { if (match_glob(key, "snapping.overlay.region.bg.color")) {
parse_hexstr(value, theme->snapping_overlay_region_bg_color); parse_hexstr(value, theme->snapping_overlay_region.bg_color);
} }
if (match_glob(key, "snapping.overlay.edge.bg.color")) { if (match_glob(key, "snapping.overlay.edge.bg.color")) {
parse_hexstr(value, theme->snapping_overlay_edge_bg_color); parse_hexstr(value, theme->snapping_overlay_edge.bg_color);
} }
if (match_glob(key, "snapping.overlay.region.border.width")) { if (match_glob(key, "snapping.overlay.region.border.width")) {
theme->snapping_overlay_region_border_width = atoi(value); theme->snapping_overlay_region.border_width = atoi(value);
} }
if (match_glob(key, "snapping.overlay.edge.border.width")) { if (match_glob(key, "snapping.overlay.edge.border.width")) {
theme->snapping_overlay_edge_border_width = atoi(value); theme->snapping_overlay_edge.border_width = atoi(value);
} }
if (match_glob(key, "snapping.overlay.region.border.color")) { if (match_glob(key, "snapping.overlay.region.border.color")) {
parse_hexstrs(value, theme->snapping_overlay_region_border_color); parse_hexstrs(value, theme->snapping_overlay_region.border_color);
} }
if (match_glob(key, "snapping.overlay.edge.border.color")) { if (match_glob(key, "snapping.overlay.edge.border.color")) {
parse_hexstrs(value, theme->snapping_overlay_edge_border_color); parse_hexstrs(value, theme->snapping_overlay_edge.border_color);
} }
} }
@ -1113,32 +1131,32 @@ post_processing(struct theme *theme)
theme->osd_window_switcher_preview_border_color); theme->osd_window_switcher_preview_border_color);
} }
if (theme->snapping_overlay_region_border_width == INT_MIN) { if (theme->snapping_overlay_region.border_width == INT_MIN) {
theme->snapping_overlay_region_border_width = theme->snapping_overlay_region.border_width =
theme->osd_border_width; theme->osd_border_width;
} }
if (theme->snapping_overlay_edge_border_width == INT_MIN) { if (theme->snapping_overlay_edge.border_width == INT_MIN) {
theme->snapping_overlay_edge_border_width = theme->snapping_overlay_edge.border_width =
theme->osd_border_width; theme->osd_border_width;
} }
if (theme->snapping_overlay_region_border_color[0][0] == FLT_MIN) { if (theme->snapping_overlay_region.border_color[0][0] == FLT_MIN) {
fill_colors_with_osd_theme(theme, fill_colors_with_osd_theme(theme,
theme->snapping_overlay_region_border_color); theme->snapping_overlay_region.border_color);
} }
if (theme->snapping_overlay_edge_border_color[0][0] == FLT_MIN) { if (theme->snapping_overlay_edge.border_color[0][0] == FLT_MIN) {
fill_colors_with_osd_theme(theme, fill_colors_with_osd_theme(theme,
theme->snapping_overlay_edge_border_color); theme->snapping_overlay_edge.border_color);
} }
} }
void void
theme_init(struct theme *theme, const char *theme_name) theme_init(struct theme *theme, struct server *server, const char *theme_name)
{ {
/* /*
* Set some default values. This is particularly important on * Set some default values. This is particularly important on
* reconfigure as not all themes set all options * reconfigure as not all themes set all options
*/ */
theme_builtin(theme); theme_builtin(theme, server);
/* Read <data-dir>/share/themes/$theme_name/openbox-3/themerc */ /* Read <data-dir>/share/themes/$theme_name/openbox-3/themerc */
struct wl_list paths; struct wl_list paths;