theme: move some variables into theme->window

For example, variables:
  `theme->window_inactive_border_color`
  `theme->window_active_border_color`
are converted to:
  `theme->window[THEME_INACTIVE].border_color`
  `theme->window[THEME_ACTIVE].border_color`

diff --git a/include/theme.h b/include/theme.h
index e1773e6c649a1fe99e45357cc05ed8611395e2c7..46016aa932c2fba76c5c00bc97318d3c919b92ca 100644 (file)
--- a/include/theme.h
+++ b/include/theme.h
@@ -46,17 +46,7 @@ struct theme {
 
        int title_height;
 
-       /* colors */
-       float window_active_border_color[4];
-       float window_inactive_border_color[4];
-
        float window_toggled_keybinds_color[4];
-
-       float window_active_title_bg_color[4];
-       float window_inactive_title_bg_color[4];
-
-       float window_active_label_text_color[4];
-       float window_inactive_label_text_color[4];
        enum lab_justification window_label_text_justify;
 
        /* buttons */
@@ -67,13 +57,23 @@ struct theme {
        /* the corner radius of the hover effect */
        int window_button_hover_bg_corner_radius;
 
-       /* window drop-shadows */
-       int window_active_shadow_size;
-       int window_inactive_shadow_size;
-       float window_active_shadow_color[4];
-       float window_inactive_shadow_color[4];
-
+       /*
+        * Themes/textures for each active/inactive window. Indexed by
+        * THEME_INACTIVE and THEME_ACTIVE.
+        */
        struct {
+               /* TODO: add toggled/hover/pressed/disabled colors for buttons */
+               float button_colors[LAB_SSD_BUTTON_LAST + 1][4];
+
+               float border_color[4];
+               float toggled_keybinds_color[4];
+               float title_bg_color[4];
+               float label_text_color[4];
+
+               /* window drop-shadows */
+               int shadow_size;
+               float shadow_color[4];
+
                /*
                 * The texture of a window buttons for each hover/toggled/rounded
                 * state. This can be accessed like:
@@ -85,13 +85,15 @@ struct theme {
                struct lab_data_buffer *buttons
                        [LAB_SSD_BUTTON_LAST + 1][LAB_BS_ALL + 1];
 
-               /* TODO: add toggled/hover/pressed/disabled colors for buttons */
-               float button_colors[LAB_SSD_BUTTON_LAST + 1][4];
-
-               /* TODO: move other window.(in)active.* entries to here */
+               struct lab_data_buffer *corner_top_left_normal;
+               struct lab_data_buffer *corner_top_right_normal;
 
-       } window[2]; /* indexed by THEME_INACTIVE and THEME_ACTIVE */
+               struct lab_data_buffer *shadow_corner_top;
+               struct lab_data_buffer *shadow_corner_bottom;
+               struct lab_data_buffer *shadow_edge;
+       } window[2];
 
+       /* Derived from font sizes */
        int menu_item_height;
        int menu_header_height;
 
@@ -137,19 +139,6 @@ struct theme {
        struct theme_snapping_overlay
                snapping_overlay_region, snapping_overlay_edge;
 
-       /* textures */
-       struct lab_data_buffer *corner_top_left_active_normal;
-       struct lab_data_buffer *corner_top_right_active_normal;
-       struct lab_data_buffer *corner_top_left_inactive_normal;
-       struct lab_data_buffer *corner_top_right_inactive_normal;
-
-       struct lab_data_buffer *shadow_corner_top_active;
-       struct lab_data_buffer *shadow_corner_bottom_active;
-       struct lab_data_buffer *shadow_edge_active;
-       struct lab_data_buffer *shadow_corner_top_inactive;
-       struct lab_data_buffer *shadow_corner_bottom_inactive;
-       struct lab_data_buffer *shadow_edge_inactive;
-
        /*
         * Not set in rc.xml/themerc, but derived from the tallest titlebar
         * object plus 2 * window_titlebar_padding_height

diff --git a/src/ssd/ssd-border.c b/src/ssd/ssd-border.c
index aa7c4d5f104f501e7b17fe2ff6dd51010bee04d2..435119e28aa135de5081172fe741bf1eca8600ff 100644 (file)
--- a/src/ssd/ssd-border.c
+++ b/src/ssd/ssd-border.c
@@ -27,6 +27,7 @@ ssd_border_create(struct ssd *ssd)
        float *color;
        struct wlr_scene_tree *parent;
        struct ssd_sub_tree *subtree;
+       int active;
 
        ssd->border.tree = wlr_scene_tree_create(ssd->tree);
        wlr_scene_node_set_position(&ssd->border.tree->node, -theme->border_width, 0);
@@ -34,12 +35,11 @@ ssd_border_create(struct ssd *ssd)
        FOR_EACH_STATE(ssd, subtree) {
                subtree->tree = wlr_scene_tree_create(ssd->border.tree);
                parent = subtree->tree;
-               if (subtree == &ssd->border.active) {
-                       color = theme->window_active_border_color;
-               } else {
-                       color = theme->window_inactive_border_color;
-                       wlr_scene_node_set_enabled(&parent->node, false);
-               }
+               active = (subtree == &ssd->border.active) ?
+                       THEME_ACTIVE : THEME_INACTIVE;
+               wlr_scene_node_set_enabled(&parent->node, active);
+               color = theme->window[active].border_color;
+
                wl_list_init(&subtree->parts);
                add_scene_rect(&subtree->parts, LAB_SSD_PART_LEFT, parent,
                        theme->border_width, height, 0, 0, color);

diff --git a/src/ssd/ssd-shadow.c b/src/ssd/ssd-shadow.c
index dfd18bd2f8cddea1ac1eb3e4bfffdd64e31379cb..34dec3a92d2aab9148a76eb5232e598a5372bbdd 100644 (file)
--- a/src/ssd/ssd-shadow.c
+++ b/src/ssd/ssd-shadow.c
@@ -181,10 +181,9 @@ set_shadow_geometry(struct ssd *ssd)
                        continue;
                }
 
-               bool active = subtree == &ssd->shadow.active;
-               int visible_shadow_width = active
-                       ? theme->window_active_shadow_size
-                       : theme->window_inactive_shadow_size;
+               int active = (subtree == &ssd->shadow.active) ?
+                       THEME_ACTIVE : THEME_INACTIVE;
+               int visible_shadow_width = theme->window[active].shadow_size;
                /* inset as a proportion of shadow width */
                double inset_proportion = SSD_SHADOW_INSET;
                /* inset in actual pixels */
@@ -195,9 +194,8 @@ set_shadow_geometry(struct ssd *ssd)
                 * portion.  Top and bottom are the same size (only the cutout
                 * is different).  The buffers are square so width == height.
                 */
-               int corner_size = active
-                       ? theme->shadow_corner_top_active->logical_height
-                       : theme->shadow_corner_top_inactive->logical_height;
+               int corner_size =
+                       theme->window[active].shadow_corner_top->logical_height;
 
                wl_list_for_each(part, &subtree->parts, link) {
                        set_shadow_part_geometry(part, width, height,
@@ -239,6 +237,7 @@ ssd_shadow_create(struct ssd *ssd)
        struct wlr_buffer *edge_buffer;
        struct ssd_sub_tree *subtree;
        struct wlr_scene_tree *parent;
+       int active;
 
        FOR_EACH_STATE(ssd, subtree) {
                wl_list_init(&subtree->parts);
@@ -246,29 +245,19 @@ ssd_shadow_create(struct ssd *ssd)
                if (!rc.shadows_enabled) {
                        /* Shadows are globally disabled */
                        continue;
-               } else if (subtree == &ssd->shadow.active) {
-                       if (theme->window_active_shadow_size == 0) {
-                               /* Active window shadows are disabled */
-                               continue;
-                       }
-               } else {
-                       if (theme->window_inactive_shadow_size == 0) {
-                               /* Inactive window shadows are disabled */
-                               continue;
-                       }
+               }
+               active = (subtree == &ssd->shadow.active) ?
+                       THEME_ACTIVE : THEME_INACTIVE;
+               if (theme->window[active].shadow_size == 0) {
+                       /* Window shadows are disabled */
+                       continue;
                }
 
                subtree->tree = wlr_scene_tree_create(ssd->shadow.tree);
                parent = subtree->tree;
-               if (subtree == &ssd->shadow.active) {
-                       corner_top_buffer = &theme->shadow_corner_top_active->base;
-                       corner_bottom_buffer = &theme->shadow_corner_bottom_active->base;
-                       edge_buffer = &theme->shadow_edge_active->base;
-               } else {
-                       corner_top_buffer = &theme->shadow_corner_top_inactive->base;
-                       corner_bottom_buffer = &theme->shadow_corner_bottom_inactive->base;
-                       edge_buffer = &theme->shadow_edge_inactive->base;
-               }
+               corner_top_buffer = &theme->window[active].shadow_corner_top->base;
+               corner_bottom_buffer = &theme->window[active].shadow_corner_bottom->base;
+               edge_buffer = &theme->window[active].shadow_edge->base;
 
                make_shadow(&subtree->parts,
                        LAB_SSD_PART_CORNER_BOTTOM_RIGHT, parent,

diff --git a/src/ssd/ssd-titlebar.c b/src/ssd/ssd-titlebar.c
index 8591759affd893a9ef0762c206e89852f31e5dfc..3c1c92b9acea9b59a26572b6bdebc7aa2b4bff71 100644 (file)
--- a/src/ssd/ssd-titlebar.c
+++ b/src/ssd/ssd-titlebar.c
@@ -38,6 +38,7 @@ ssd_titlebar_create(struct ssd *ssd)
        struct wlr_scene_tree *parent;
        struct wlr_buffer *corner_top_left;
        struct wlr_buffer *corner_top_right;
+       int active;
 
        ssd->titlebar.tree = wlr_scene_tree_create(ssd->tree);
 
@@ -45,18 +46,13 @@ ssd_titlebar_create(struct ssd *ssd)
        FOR_EACH_STATE(ssd, subtree) {
                subtree->tree = wlr_scene_tree_create(ssd->titlebar.tree);
                parent = subtree->tree;
+               active = (subtree == &ssd->titlebar.active) ?
+                       THEME_ACTIVE : THEME_INACTIVE;
+               color = theme->window[active].title_bg_color;
+               corner_top_left = &theme->window[active].corner_top_left_normal->base;
+               corner_top_right = &theme->window[active].corner_top_right_normal->base;
+               wlr_scene_node_set_enabled(&parent->node, active);
                wlr_scene_node_set_position(&parent->node, 0, -theme->title_height);
-               if (subtree == &ssd->titlebar.active) {
-                       color = theme->window_active_title_bg_color;
-                       corner_top_left = &theme->corner_top_left_active_normal->base;
-                       corner_top_right = &theme->corner_top_right_active_normal->base;
-               } else {
-                       color = theme->window_inactive_title_bg_color;
-                       corner_top_left = &theme->corner_top_left_inactive_normal->base;
-                       corner_top_right = &theme->corner_top_right_inactive_normal->base;
-
-                       wlr_scene_node_set_enabled(&parent->node, false);
-               }
                wl_list_init(&subtree->parts);
 
                /* Background */
@@ -69,9 +65,6 @@ ssd_titlebar_create(struct ssd *ssd)
                        corner_top_right, width - corner_width,
                        -rc.theme->border_width);
 
-               int active = (subtree == &ssd->titlebar.active) ?
-                               THEME_ACTIVE : THEME_INACTIVE;
-
                /* Buttons */
                struct title_button *b;
                int x = theme->window_titlebar_padding_width;
@@ -474,23 +467,19 @@ ssd_update_title(struct ssd *ssd)
        struct ssd_part *part;
        struct ssd_sub_tree *subtree;
        struct ssd_state_title_width *dstate;
+       int active;
 
        int offset_left, offset_right;
        get_title_offsets(ssd, &offset_left, &offset_right);
        int title_bg_width = view->current.width - offset_left - offset_right;
 
        FOR_EACH_STATE(ssd, subtree) {
-               if (subtree == &ssd->titlebar.active) {
-                       dstate = &state->active;
-                       text_color = theme->window_active_label_text_color;
-                       bg_color = theme->window_active_title_bg_color;
-                       font = &rc.font_activewindow;
-               } else {
-                       dstate = &state->inactive;
-                       text_color = theme->window_inactive_label_text_color;
-                       bg_color = theme->window_inactive_title_bg_color;
-                       font = &rc.font_inactivewindow;
-               }
+               active = (subtree == &ssd->titlebar.active) ?
+                       THEME_ACTIVE : THEME_INACTIVE;
+               dstate = active ? &state->active : &state->inactive;
+               text_color = theme->window[active].label_text_color;
+               bg_color = theme->window[active].title_bg_color;
+               font = &rc.font_activewindow;
 
                if (title_bg_width <= 0) {
                        dstate->truncated = true;

diff --git a/src/ssd/ssd.c b/src/ssd/ssd.c
index a9fc1abc7df594984f9cd8d0a853d7643a859d1a..149bf5863108e774f881917df12b60024976b6e7 100644 (file)
--- a/src/ssd/ssd.c
+++ b/src/ssd/ssd.c
@@ -404,7 +404,7 @@ ssd_enable_keybind_inhibit_indicator(struct ssd *ssd, bool enable)
 
        float *color = enable
                ? rc.theme->window_toggled_keybinds_color
-               : rc.theme->window_active_border_color;
+               : rc.theme->window[THEME_ACTIVE].border_color;
 
        struct ssd_part *part = ssd_get_part(&ssd->border.active.parts, LAB_SSD_PART_TOP);
        struct wlr_scene_rect *rect = wlr_scene_rect_from_node(part->node);

diff --git a/src/theme.c b/src/theme.c
index 8f5e3d0e0770857326ef960f4dbe4b28fd1f7294..05c668b9d85b70c767423f5c4da977676749ea34 100644 (file)
--- a/src/theme.c
+++ b/src/theme.c
@@ -564,16 +564,16 @@ theme_builtin(struct theme *theme, struct server *server)
        theme->window_titlebar_padding_width = 0;
        theme->title_height = INT_MIN;
 
-       parse_hexstr("#e1dedb", theme->window_active_border_color);
-       parse_hexstr("#f6f5f4", theme->window_inactive_border_color);
+       parse_hexstr("#e1dedb", theme->window[THEME_ACTIVE].border_color);
+       parse_hexstr("#f6f5f4", theme->window[THEME_INACTIVE].border_color);
 
        parse_hexstr("#ff0000", theme->window_toggled_keybinds_color);
 
-       parse_hexstr("#e1dedb", theme->window_active_title_bg_color);
-       parse_hexstr("#f6f5f4", theme->window_inactive_title_bg_color);
+       parse_hexstr("#e1dedb", theme->window[THEME_ACTIVE].title_bg_color);
+       parse_hexstr("#f6f5f4", theme->window[THEME_INACTIVE].title_bg_color);
 
-       parse_hexstr("#000000", theme->window_active_label_text_color);
-       parse_hexstr("#000000", theme->window_inactive_label_text_color);
+       parse_hexstr("#000000", theme->window[THEME_ACTIVE].label_text_color);
+       parse_hexstr("#000000", theme->window[THEME_INACTIVE].label_text_color);
        theme->window_label_text_justify = parse_justification("Center");
 
        theme->window_button_width = 26;
@@ -589,10 +589,10 @@ theme_builtin(struct theme *theme, struct server *server)
                        theme->window[THEME_ACTIVE].button_colors[type]);
        }
 
-       theme->window_active_shadow_size = 60;
-       theme->window_inactive_shadow_size = 40;
-       parse_hexstr("#00000060", theme->window_active_shadow_color);
-       parse_hexstr("#00000040", theme->window_inactive_shadow_color);
+       theme->window[THEME_ACTIVE].shadow_size = 60;
+       theme->window[THEME_INACTIVE].shadow_size = 40;
+       parse_hexstr("#00000060", theme->window[THEME_ACTIVE].shadow_color);
+       parse_hexstr("#00000040", theme->window[THEME_INACTIVE].shadow_color);
 
        theme->menu_overlap_x = 0;
        theme->menu_overlap_y = 0;
@@ -708,15 +708,15 @@ entry(struct theme *theme, const char *key, const char *value)
        }
 
        if (match_glob(key, "window.active.border.color")) {
-               parse_hexstr(value, theme->window_active_border_color);
+               parse_hexstr(value, theme->window[THEME_ACTIVE].border_color);
        }
        if (match_glob(key, "window.inactive.border.color")) {
-               parse_hexstr(value, theme->window_inactive_border_color);
+               parse_hexstr(value, theme->window[THEME_INACTIVE].border_color);
        }
        /* border.color is obsolete, but handled for backward compatibility */
        if (match_glob(key, "border.color")) {
-               parse_hexstr(value, theme->window_active_border_color);
-               parse_hexstr(value, theme->window_inactive_border_color);
+               parse_hexstr(value, theme->window[THEME_ACTIVE].border_color);
+               parse_hexstr(value, theme->window[THEME_INACTIVE].border_color);
        }
 
        if (match_glob(key, "window.active.indicator.toggled-keybind.color")) {
@@ -724,17 +724,17 @@ entry(struct theme *theme, const char *key, const char *value)
        }
 
        if (match_glob(key, "window.active.title.bg.color")) {
-               parse_hexstr(value, theme->window_active_title_bg_color);
+               parse_hexstr(value, theme->window[THEME_ACTIVE].title_bg_color);
        }
        if (match_glob(key, "window.inactive.title.bg.color")) {
-               parse_hexstr(value, theme->window_inactive_title_bg_color);
+               parse_hexstr(value, theme->window[THEME_INACTIVE].title_bg_color);
        }
 
        if (match_glob(key, "window.active.label.text.color")) {
-               parse_hexstr(value, theme->window_active_label_text_color);
+               parse_hexstr(value, theme->window[THEME_ACTIVE].label_text_color);
        }
        if (match_glob(key, "window.inactive.label.text.color")) {
-               parse_hexstr(value, theme->window_inactive_label_text_color);
+               parse_hexstr(value, theme->window[THEME_INACTIVE].label_text_color);
        }
        if (match_glob(key, "window.label.text.justify")) {
                theme->window_label_text_justify = parse_justification(value);
@@ -837,18 +837,18 @@ entry(struct theme *theme, const char *key, const char *value)
 
        /* window drop-shadows */
        if (match_glob(key, "window.active.shadow.size")) {
-               theme->window_active_shadow_size = get_int_if_positive(
+               theme->window[THEME_ACTIVE].shadow_size = get_int_if_positive(
                        value, "window.active.shadow.size");
        }
        if (match_glob(key, "window.inactive.shadow.size")) {
-               theme->window_inactive_shadow_size = get_int_if_positive(
+               theme->window[THEME_INACTIVE].shadow_size = get_int_if_positive(
                        value, "window.inactive.shadow.size");
        }
        if (match_glob(key, "window.active.shadow.color")) {
-               parse_hexstr(value, theme->window_active_shadow_color);
+               parse_hexstr(value, theme->window[THEME_ACTIVE].shadow_color);
        }
        if (match_glob(key, "window.inactive.shadow.color")) {
-               parse_hexstr(value, theme->window_inactive_shadow_color);
+               parse_hexstr(value, theme->window[THEME_INACTIVE].shadow_color);
        }
 
        if (match_glob(key, "menu.overlap.x")) {
@@ -1246,28 +1246,19 @@ create_corners(struct theme *theme)
                .height = theme->title_height + theme->border_width,
        };
 
-       struct rounded_corner_ctx ctx = {
-               .box = &box,
-               .radius = rc.corner_radius,
-               .line_width = theme->border_width,
-               .fill_color = theme->window_active_title_bg_color,
-               .border_color = theme->window_active_border_color,
-               .corner = LAB_CORNER_TOP_LEFT,
-       };
-       theme->corner_top_left_active_normal = rounded_rect(&ctx);
-
-       ctx.fill_color = theme->window_inactive_title_bg_color,
-       ctx.border_color = theme->window_inactive_border_color,
-       theme->corner_top_left_inactive_normal = rounded_rect(&ctx);
-
-       ctx.corner = LAB_CORNER_TOP_RIGHT;
-       ctx.fill_color = theme->window_active_title_bg_color,
-       ctx.border_color = theme->window_active_border_color,
-       theme->corner_top_right_active_normal = rounded_rect(&ctx);
-
-       ctx.fill_color = theme->window_inactive_title_bg_color,
-       ctx.border_color = theme->window_inactive_border_color,
-       theme->corner_top_right_inactive_normal = rounded_rect(&ctx);
+       for (int active = THEME_INACTIVE; active <= THEME_ACTIVE; active++) {
+               struct rounded_corner_ctx ctx = {
+                       .box = &box,
+                       .radius = rc.corner_radius,
+                       .line_width = theme->border_width,
+                       .fill_color = theme->window[active].title_bg_color,
+                       .border_color = theme->window[active].border_color,
+                       .corner = LAB_CORNER_TOP_LEFT,
+               };
+               theme->window[active].corner_top_left_normal = rounded_rect(&ctx);
+               ctx.corner = LAB_CORNER_TOP_RIGHT;
+               theme->window[active].corner_top_right_normal = rounded_rect(&ctx);
+       }
 }
 
 /*
@@ -1385,68 +1376,50 @@ shadow_corner_gradient(struct lab_data_buffer *buffer, int visible_size,
 }
 
 static void
-create_shadows(struct theme *theme)
+create_shadow(struct theme *theme, int active)
 {
        /* Size of shadow visible extending beyond the window */
-       int visible_active_size = theme->window_active_shadow_size;
-       int visible_inactive_size = theme->window_inactive_shadow_size;
+       int visible_size = theme->window[active].shadow_size;
        /* How far inside the window the shadow inset begins */
-       int inset_active = (double)visible_active_size * SSD_SHADOW_INSET;
-       int inset_inactive = (double)visible_inactive_size * SSD_SHADOW_INSET;
+       int inset = (double)visible_size * SSD_SHADOW_INSET;
        /* Total width including visible and obscured portion */
-       int total_active_size = visible_active_size + inset_active;
-       int total_inactive_size = visible_inactive_size + inset_inactive;
+       int total_size = visible_size + inset;
 
        /*
         * Edge shadows don't need to be inset so the buffers are sized just for
         * the visible width.  Corners are inset so the buffers are larger for
         * this.
         */
-       if (visible_active_size > 0) {
-               theme->shadow_edge_active = buffer_create_cairo(
-                       visible_active_size, 1, 1.0);
-               theme->shadow_corner_top_active = buffer_create_cairo(
-                       total_active_size, total_active_size, 1.0);
-               theme->shadow_corner_bottom_active = buffer_create_cairo(
-                       total_active_size, total_active_size, 1.0);
-               if (!theme->shadow_corner_top_active
-                               || !theme->shadow_corner_bottom_active
-                               || !theme->shadow_edge_active) {
-                       wlr_log(WLR_ERROR, "Failed to allocate shadow buffer");
-                       return;
-               }
-       }
-       if (visible_inactive_size > 0) {
-               theme->shadow_edge_inactive = buffer_create_cairo(
-                       visible_inactive_size, 1, 1.0);
-               theme->shadow_corner_top_inactive = buffer_create_cairo(
-                       total_inactive_size, total_inactive_size, 1.0);
-               theme->shadow_corner_bottom_inactive = buffer_create_cairo(
-                       total_inactive_size, total_inactive_size, 1.0);
-               if (!theme->shadow_corner_top_inactive
-                               || !theme->shadow_corner_bottom_inactive
-                               || !theme->shadow_edge_inactive) {
+       if (visible_size > 0) {
+               theme->window[active].shadow_edge = buffer_create_cairo(
+                       visible_size, 1, 1.0);
+               theme->window[active].shadow_corner_top = buffer_create_cairo(
+                       total_size, total_size, 1.0);
+               theme->window[active].shadow_corner_bottom = buffer_create_cairo(
+                       total_size, total_size, 1.0);
+               if (!theme->window[active].shadow_corner_top
+                               || !theme->window[active].shadow_corner_bottom
+                               || !theme->window[active].shadow_edge) {
                        wlr_log(WLR_ERROR, "Failed to allocate shadow buffer");
                        return;
                }
        }
 
-       shadow_edge_gradient(theme->shadow_edge_active, visible_active_size,
-               total_active_size, theme->window_active_shadow_color);
-       shadow_edge_gradient(theme->shadow_edge_inactive, visible_inactive_size,
-               total_inactive_size, theme->window_inactive_shadow_color);
-       shadow_corner_gradient(theme->shadow_corner_top_active,
-               visible_active_size, total_active_size,
-               theme->title_height, theme->window_active_shadow_color);
-       shadow_corner_gradient(theme->shadow_corner_bottom_active,
-               visible_active_size, total_active_size, 0,
-               theme->window_active_shadow_color);
-       shadow_corner_gradient(theme->shadow_corner_top_inactive,
-               visible_inactive_size, total_inactive_size,
-               theme->title_height, theme->window_inactive_shadow_color);
-       shadow_corner_gradient(theme->shadow_corner_bottom_inactive,
-               visible_inactive_size, total_inactive_size, 0,
-               theme->window_inactive_shadow_color);
+       shadow_edge_gradient(theme->window[active].shadow_edge, visible_size,
+               total_size, theme->window[active].shadow_color);
+       shadow_corner_gradient(theme->window[active].shadow_corner_top,
+               visible_size, total_size,
+               theme->title_height, theme->window[active].shadow_color);
+       shadow_corner_gradient(theme->window[active].shadow_corner_bottom,
+               visible_size, total_size, 0,
+               theme->window[active].shadow_color);
+}
+
+static void
+create_shadows(struct theme *theme)
+{
+       create_shadow(theme, THEME_INACTIVE);
+       create_shadow(theme, THEME_ACTIVE);
 }
 
 static void
@@ -1504,7 +1477,7 @@ post_processing(struct theme *theme)
        /* Inherit OSD settings if not set */
        if (theme->osd_bg_color[0] == FLT_MIN) {
                memcpy(theme->osd_bg_color,
-                       theme->window_active_title_bg_color,
+                       theme->window[THEME_ACTIVE].title_bg_color,
                        sizeof(theme->osd_bg_color));
        }
        if (theme->osd_border_width == INT_MIN) {
@@ -1512,19 +1485,19 @@ post_processing(struct theme *theme)
        }
        if (theme->osd_label_text_color[0] == FLT_MIN) {
                memcpy(theme->osd_label_text_color,
-                       theme->window_active_label_text_color,
+                       theme->window[THEME_ACTIVE].label_text_color,
                        sizeof(theme->osd_label_text_color));
        }
        if (theme->osd_border_color[0] == FLT_MIN) {
                /*
                 * As per https://openbox.org/help/Themes#osd.border.color
-                * we should fall back to window_active_border_color but
-                * that is usually the same as window_active_title_bg_color
-                * and thus the fallback for osd_bg_color. Which would mean
+                * we should fall back to window.active.border.color but
+                * that is usually the same as window.active.title.bg.color
+                * and thus the fallback for osd.bg.color. Which would mean
                 * they are both the same color and thus the border is invisible.
                 *
-                * Instead, we fall back to osd_label_text_color which in turn
-                * falls back to window_active_label_text_color.
+                * Instead, we fall back to osd.label.text.color which in turn
+                * falls back to window.active.label.text.color.
                 */
                memcpy(theme->osd_border_color, theme->osd_label_text_color,
                        sizeof(theme->osd_border_color));
@@ -1606,15 +1579,11 @@ theme_finish(struct theme *theme)
                }
        }
 
-       zdrop(&theme->corner_top_left_active_normal);
-       zdrop(&theme->corner_top_left_inactive_normal);
-       zdrop(&theme->corner_top_right_active_normal);
-       zdrop(&theme->corner_top_right_inactive_normal);
-
-       zdrop(&theme->shadow_corner_top_active);
-       zdrop(&theme->shadow_corner_bottom_active);
-       zdrop(&theme->shadow_edge_active);
-       zdrop(&theme->shadow_corner_top_inactive);
-       zdrop(&theme->shadow_corner_bottom_inactive);
-       zdrop(&theme->shadow_edge_inactive);
+       for (int active = THEME_INACTIVE; active <= THEME_ACTIVE; active++) {
+               zdrop(&theme->window[active].corner_top_left_normal);
+               zdrop(&theme->window[active].corner_top_right_normal);
+               zdrop(&theme->window[active].shadow_corner_top);
+               zdrop(&theme->window[active].shadow_corner_bottom);
+               zdrop(&theme->window[active].shadow_edge);
+       }
 }