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

Centralize buffer preparation and standardize placement

Browse source
This commit is contained in:
Jack Zeal 2026-03-28 09:01:21 -07:00
parent 90e652a8a1
commit d80dd2470b
16 changed files with 251 additions and 431 deletions
Download patch file Download diff file Expand all files Collapse all files

27
include/common/borderset.h
View file

@ -3,10 +3,14 @@
#ifndef LABWC_BORDERSET_H #ifndef LABWC_BORDERSET_H
#define LABWC_BORDERSET_H #define LABWC_BORDERSET_H
enum border_type {
BORDER_FLAT, BORDER_SINGLE, BORDER_DOUBLE, BORDER_INSET
};
struct borderset { struct borderset {
uint32_t id; // Base colour, but could be used as a tracking hash for images or whatever in the future uint32_t id; // Base colour, but could be used as a tracking hash for images or whatever in the future
int size; // width (since I suspect a 2px border scaled up to 20px might look weird) int size; // width (since I suspect a 2px border scaled up to 20px might look weird)
int type; // Single or double bevel enum border_type type; // Single or double bevel
uint32_t * top; uint32_t * top;
uint32_t * left; uint32_t * left;
uint32_t * right; uint32_t * right;
@ -18,12 +22,29 @@ struct borderset {
struct borderset * next; struct borderset * next;
}; };
struct bufferset {
enum border_type type;
int border_width;
struct wlr_scene_buffer * top;
struct wlr_scene_buffer * left;
struct wlr_scene_buffer * right;
struct wlr_scene_buffer * bottom;
struct wlr_scene_buffer * tl;
struct wlr_scene_buffer * tr;
struct wlr_scene_buffer * bl;
struct wlr_scene_buffer * br;
};
extern struct borderset * borderCache; extern struct borderset * borderCache;
struct borderset * getBorders(uint32_t id, int size, int type, int bevelSize); struct borderset * getBorders(uint32_t id, int size, enum border_type, int bevelSize);
struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize); struct borderset * createBuffer(uint32_t id, int size, enum border_type, int bevelSize);
struct bufferset * generateBufferset(struct wlr_scene_tree * tree, struct borderset *borderset, int bw);
void renderBufferset(struct bufferset *, int width, int height, int y);
void clearBorderCache(struct borderset *borderset); void clearBorderCache(struct borderset *borderset);

2
include/common/lab-scene-rect.h
View file

@ -12,7 +12,7 @@ struct lab_scene_rect_options {
float *bg_color; /* can be NULL */ float *bg_color; /* can be NULL */
int width; int width;
int height; int height;
int beveled; bool beveled;
}; };
struct lab_scene_rect { struct lab_scene_rect {

4
include/common/macros.h
View file

@ -74,8 +74,6 @@
* Assumes "bw" was defined externally * Assumes "bw" was defined externally
*/ */
#define PIXEL(x, y) (bw * y + x) #define PIXEL(x, y, size) (size * y + x)
#define PIXELSIZED(x, y, size) (size * y + x)
#endif /* LABWC_MACROS_H */ #endif /* LABWC_MACROS_H */

3
include/ssd-internal.h
View file

@ -115,8 +115,7 @@ struct ssd {
struct ssd_border_subtree { struct ssd_border_subtree {
struct wlr_scene_tree *tree; struct wlr_scene_tree *tree;
struct wlr_scene_rect *top, *bottom, *left, *right; struct wlr_scene_rect *top, *bottom, *left, *right;
struct wlr_scene_buffer *tlcorner, *trcorner, *blcorner, *brcorner, struct bufferset * texturedBorders;
*ttexture, *btexture, *ltexture, *rtexture;
} subtrees[2]; /* indexed by enum ssd_active_state */ } subtrees[2]; /* indexed by enum ssd_active_state */
} border; } border;

2
include/view.h
View file

@ -244,7 +244,7 @@ struct view {
int width, height; int width, height;
struct wlr_scene_tree *tree; struct wlr_scene_tree *tree;
struct wlr_scene_rect *border; struct wlr_scene_rect *border;
struct wlr_scene_buffer *top, *left, *right, *bottom, *tl, *tr, *bl, *br; struct bufferset * texturedBorders;
struct wlr_scene_rect *background; struct wlr_scene_rect *background;
struct scaled_font_buffer *text; struct scaled_font_buffer *text;
} resize_indicator; } resize_indicator;

200
src/common/borderset.c
View file

@ -1,8 +1,10 @@
#include <wlr/types/wlr_scene.h>
#include "common/borderset.h" #include "common/borderset.h"
#include "common/mem.h" #include "common/mem.h"
#include "common/macros.h" #include "common/macros.h"
#include "buffer.h"
struct borderset * getBorders(uint32_t id, int size, int type, int bevelSize) { struct borderset * getBorders(uint32_t id, int size, enum border_type type, int bevelSize) {
struct borderset * current = borderCache; struct borderset * current = borderCache;
struct borderset * last; struct borderset * last;
while (current != NULL) { while (current != NULL) {
@ -24,7 +26,7 @@ struct borderset * getBorders(uint32_t id, int size, int type, int bevelSize) {
return NULL; return NULL;
} }
struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize) { struct borderset * createBuffer(uint32_t id, int size, enum border_type type, int bevelSize) {
struct borderset *newBorderset = znew(*newBorderset); struct borderset *newBorderset = znew(*newBorderset);
newBorderset->next = NULL; newBorderset->next = NULL;
@ -64,7 +66,7 @@ struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize)
newBorderset->br = znew_n(uint32_t, size*size); newBorderset->br = znew_n(uint32_t, size*size);
switch(type) { switch(type) {
case 1: // Single bevel borders have 1x1 sides case BORDER_SINGLE: // Single bevel borders have 1x1 sides
newBorderset->top = znew(uint32_t); newBorderset->top = znew(uint32_t);
newBorderset->left = znew(uint32_t); newBorderset->left = znew(uint32_t);
newBorderset->right = znew(uint32_t); newBorderset->right = znew(uint32_t);
@ -77,10 +79,10 @@ struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize)
// Fill with solid // Fill with solid
for (int j=0; j<size;j++) { for (int j=0; j<size;j++) {
for (int k=0; k<size;k++) { for (int k=0; k<size;k++) {
newBorderset->tl[PIXELSIZED(j, k, size)] = hl32; newBorderset->tl[PIXEL(j, k, size)] = hl32;
newBorderset->tr[PIXELSIZED(size - 1 - j, k, size)] = (j > k) ? hl32 : ll32; newBorderset->tr[PIXEL(size - 1 - j, k, size)] = (j > k) ? hl32 : ll32;
newBorderset->bl[PIXELSIZED(size - 1 -j, k, size)] = (j > k) ? hl32 : ll32; newBorderset->bl[PIXEL(size - 1 -j, k, size)] = (j > k) ? hl32 : ll32;
newBorderset->br[PIXELSIZED(j, k, size)] = ll32; newBorderset->br[PIXEL(j, k, size)] = ll32;
} }
} }
@ -89,7 +91,7 @@ struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize)
break; break;
case 2: case BORDER_DOUBLE:
newBorderset->top = znew_n(uint32_t, size); newBorderset->top = znew_n(uint32_t, size);
newBorderset->left = znew_n(uint32_t, size); newBorderset->left = znew_n(uint32_t, size);
newBorderset->right = znew_n(uint32_t, size); newBorderset->right = znew_n(uint32_t, size);
@ -119,10 +121,10 @@ struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize)
// Blank corners... // Blank corners...
for (int i=0; i<size;i++) { for (int i=0; i<size;i++) {
for (int j=0; j<size;j++) { for (int j=0; j<size;j++) {
newBorderset->tl[PIXELSIZED(i, j, size)] = id; newBorderset->tl[PIXEL(i, j, size)] = id;
newBorderset->tr[PIXELSIZED(i, j, size)] = id; newBorderset->tr[PIXEL(i, j, size)] = id;
newBorderset->bl[PIXELSIZED(i, j, size)] = id; newBorderset->bl[PIXEL(i, j, size)] = id;
newBorderset->br[PIXELSIZED(i, j, size)] = id; newBorderset->br[PIXEL(i, j, size)] = id;
} }
} }
@ -133,25 +135,25 @@ struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize)
// Solid bar parts // Solid bar parts
for (int j=0; j<size; j++) { for (int j=0; j<size; j++) {
// Top left corner: Entire "bevel size" top rows are highlighted // Top left corner: Entire "bevel size" top rows are highlighted
newBorderset->tl[PIXELSIZED(j, i, size)] = hl32; newBorderset->tl[PIXEL(j, i, size)] = hl32;
// First "bevel size" top columns are highlighted // First "bevel size" top columns are highlighted
newBorderset->tl[PIXELSIZED(i, j, size)] = hl32; newBorderset->tl[PIXEL(i, j, size)] = hl32;
// Bottom Right corner: Entire "bevel size" last rows are lowlight // Bottom Right corner: Entire "bevel size" last rows are lowlight
newBorderset->br[PIXELSIZED(j, (size-1-i), size)] = ll32; newBorderset->br[PIXEL(j, (size-1-i), size)] = ll32;
// Last "bevel size" columns are lowlight // Last "bevel size" columns are lowlight
newBorderset->br[PIXELSIZED((size-1-i), j, size)] = ll32; newBorderset->br[PIXEL((size-1-i), j, size)] = ll32;
// Bottom left corner: Entire "bevel size" last rows are lowlight // Bottom left corner: Entire "bevel size" last rows are lowlight
newBorderset->bl[PIXELSIZED(j, (size-1-i), size)] = ll32; newBorderset->bl[PIXEL(j, (size-1-i), size)] = ll32;
// First "bevel size" columns are highlight, except for the bottom right corner // First "bevel size" columns are highlight, except for the bottom right corner
newBorderset->bl[PIXELSIZED(i, j, size)] = hl32; newBorderset->bl[PIXEL(i, j, size)] = hl32;
// Top Right corner: Entire "bevel size" first rows are highlight // Top Right corner: Entire "bevel size" first rows are highlight
newBorderset->tr[PIXELSIZED(j, i, size)] = hl32; newBorderset->tr[PIXEL(j, i, size)] = hl32;
// Last "bevel size" columns are lowlight, except for the top left // Last "bevel size" columns are lowlight, except for the top left
newBorderset->tr[PIXELSIZED((size-1-i), j, size)] = ll32; newBorderset->tr[PIXEL((size-1-i), j, size)] = ll32;
} }
} }
@ -162,27 +164,27 @@ struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize)
// Outer Corners // Outer Corners
// Bottom left corner: // Bottom left corner:
// First "bevel size" columns are highlight, except for the bottom right corner // First "bevel size" columns are highlight, except for the bottom right corner
newBorderset->bl[PIXELSIZED(i, (size - 1 - j), size)] = (j >= i) ? hl32 : ll32; newBorderset->bl[PIXEL(i, (size - 1 - j), size)] = (j >= i) ? hl32 : ll32;
// Top Right corner: // Top Right corner:
// Last "bevel size" columns are lowlight, except for the top left // Last "bevel size" columns are lowlight, except for the top left
newBorderset->tr[PIXELSIZED((size-1-i), j, size)] = (j > i) ? ll32 : hl32; newBorderset->tr[PIXEL((size-1-i), j, size)] = (j > i) ? ll32 : hl32;
// Inner Corners // Inner Corners
// Top left corner: Bottom right is all dark // Top left corner: Bottom right is all dark
newBorderset->tl[PIXELSIZED((size-1-i), (size - 1 - j), size)] = ll32; newBorderset->tl[PIXEL((size-1-i), (size - 1 - j), size)] = ll32;
// Bottom Right corner: Top left is all light // Bottom Right corner: Top left is all light
newBorderset->br[PIXELSIZED(i, j, size)] = hl32; newBorderset->br[PIXEL(i, j, size)] = hl32;
// Top Right corner: // Top Right corner:
// Interior bottom left is dark on top, light on bottom // Interior bottom left is dark on top, light on bottom
newBorderset->tr[PIXELSIZED(i, (size-1-j), size)] = (i > j) ? hl32 : ll32; newBorderset->tr[PIXEL(i, (size-1-j), size)] = (i > j) ? hl32 : ll32;
// Bottom Left corner: // Bottom Left corner:
// Interior top right is dark on top, light on bottom // Interior top right is dark on top, light on bottom
newBorderset->bl[PIXELSIZED((size-1-i), j, size)] = (i > j) ? ll32 : hl32; newBorderset->bl[PIXEL((size-1-i), j, size)] = (i > j) ? ll32 : hl32;
@ -196,7 +198,31 @@ struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize)
break; break;
case 3: // Sunken Single bevel borders have 1x1 sides case BORDER_FLAT: // Placeholder that uses buffers but for a flat colour
newBorderset->top = znew(uint32_t);
newBorderset->left = znew(uint32_t);
newBorderset->right = znew(uint32_t);
newBorderset->bottom = znew(uint32_t);
*newBorderset->top = id;
*newBorderset->left = id;
*newBorderset->right = id;
*newBorderset->bottom = id;
// Fill with solid
for (int j=0; j<size;j++) {
for (int k=0; k<size;k++) {
newBorderset->tl[PIXEL(j, k, size)] = id;
newBorderset->tr[PIXEL(size - 1 - j, k, size)] = id;
newBorderset->bl[PIXEL(size - 1 -j, k, size)] = id;
newBorderset->br[PIXEL(j, k, size)] = id;
}
}
break;
case BORDER_INSET: // Sunken Single bevel borders have 1x1 sides
newBorderset->top = znew(uint32_t); newBorderset->top = znew(uint32_t);
newBorderset->left = znew(uint32_t); newBorderset->left = znew(uint32_t);
newBorderset->right = znew(uint32_t); newBorderset->right = znew(uint32_t);
@ -209,10 +235,10 @@ struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize)
// Fill with solid // Fill with solid
for (int j=0; j<size;j++) { for (int j=0; j<size;j++) {
for (int k=0; k<size;k++) { for (int k=0; k<size;k++) {
newBorderset->tl[PIXELSIZED(j, k, size)] = ll32; newBorderset->tl[PIXEL(j, k, size)] = ll32;
newBorderset->tr[PIXELSIZED(size - 1 - j, k, size)] = (j > k) ? ll32 : hl32; newBorderset->tr[PIXEL(size - 1 - j, k, size)] = (j > k) ? ll32 : hl32;
newBorderset->bl[PIXELSIZED(size - 1 -j, k, size)] = (j > k) ? ll32 : hl32; newBorderset->bl[PIXEL(size - 1 -j, k, size)] = (j > k) ? ll32 : hl32;
newBorderset->br[PIXELSIZED(j, k, size)] = hl32; newBorderset->br[PIXEL(j, k, size)] = hl32;
} }
} }
@ -224,6 +250,118 @@ struct borderset * createBuffer(uint32_t id, int size, int type, int bevelSize)
return newBorderset; return newBorderset;
} }
struct bufferset * generateBufferset(struct wlr_scene_tree * tree, struct borderset *borderset, int bw)
{
struct bufferset * bufferset = znew(struct bufferset);
bufferset->border_width = bw;
if (borderset->type == BORDER_DOUBLE) {
struct lab_data_buffer *ttexture_buffer =
buffer_create_from_data(borderset->top, 1, bw, 4);
bufferset->top = wlr_scene_buffer_create(tree, &ttexture_buffer->base);
struct lab_data_buffer *ltexture_buffer =
buffer_create_from_data(borderset->left, bw, 1, 4*bw);
bufferset->left = wlr_scene_buffer_create(tree, &ltexture_buffer->base);
struct lab_data_buffer *rtexture_buffer =
buffer_create_from_data(borderset->right, bw, 1, 4*bw);
bufferset->right = wlr_scene_buffer_create(tree, &rtexture_buffer->base);
struct lab_data_buffer *btexture_buffer =
buffer_create_from_data(borderset->bottom, 1, bw, 4);
bufferset->bottom = wlr_scene_buffer_create(tree, &btexture_buffer->base);
} else {
struct lab_data_buffer *ttexture_buffer =
buffer_create_from_data(borderset->top, 1, 1, 4);
bufferset->top = wlr_scene_buffer_create(tree, &ttexture_buffer->base);
struct lab_data_buffer *ltexture_buffer =
buffer_create_from_data(borderset->left, 1, 1, 4);
bufferset->left = wlr_scene_buffer_create(tree, &ltexture_buffer->base);
struct lab_data_buffer *rtexture_buffer =
buffer_create_from_data(borderset->right, 1, 1, 4);
bufferset->right = wlr_scene_buffer_create(tree, &rtexture_buffer->base);
struct lab_data_buffer *btexture_buffer =
buffer_create_from_data(borderset->bottom, 1, 1, 4);
bufferset->bottom = wlr_scene_buffer_create(tree, &btexture_buffer->base);
}
struct lab_data_buffer *tltexture_buffer =
buffer_create_from_data(borderset->tl, bw, bw, 4*bw);
bufferset->tl = wlr_scene_buffer_create(tree, &tltexture_buffer->base);
struct lab_data_buffer *trtexture_buffer =
buffer_create_from_data(borderset->tr, bw, bw, 4*bw);
bufferset->tr = wlr_scene_buffer_create(tree, &trtexture_buffer->base);
struct lab_data_buffer *bltexture_buffer =
buffer_create_from_data(borderset->bl, bw, bw, 4*bw);
bufferset->bl = wlr_scene_buffer_create(tree, &bltexture_buffer->base);
struct lab_data_buffer *brtexture_buffer =
buffer_create_from_data(borderset->br, bw, bw, 4*bw);
bufferset->br = wlr_scene_buffer_create(tree, &brtexture_buffer->base);
return bufferset;
}
void renderBufferset(struct bufferset *bufferset, int width, int height, int y)
{
wlr_scene_buffer_set_dest_size(bufferset->top,
width - 2 * bufferset->border_width, bufferset->border_width);
wlr_scene_node_set_position(&bufferset->top->node,
bufferset->border_width,y);
wlr_scene_buffer_set_dest_size(bufferset->bottom,
width - 2 * bufferset->border_width, bufferset->border_width);
wlr_scene_node_set_position(&bufferset->bottom->node,
bufferset->border_width, y+height - bufferset->border_width);
wlr_scene_buffer_set_dest_size(bufferset->left,
bufferset->border_width, height - bufferset->border_width * 2);
wlr_scene_node_set_position(&bufferset->left->node,
0, bufferset->border_width+y);
wlr_scene_buffer_set_dest_size(bufferset->right,
bufferset->border_width, height - bufferset->border_width * 2);
wlr_scene_node_set_position(&bufferset->right->node,
width - bufferset->border_width, y+ bufferset->border_width);
wlr_scene_buffer_set_dest_size(bufferset->tl,
bufferset->border_width, bufferset->border_width);
wlr_scene_node_set_position(&bufferset->tl->node,
0,y);
wlr_scene_buffer_set_dest_size(bufferset->tr,
bufferset->border_width, bufferset->border_width);
wlr_scene_node_set_position(&bufferset->tr->node,
width-bufferset->border_width, y);
wlr_scene_buffer_set_dest_size(bufferset->br,
bufferset->border_width, bufferset->border_width);
wlr_scene_node_set_position(&bufferset->br->node,
width-bufferset->border_width , y+height-bufferset->border_width);
wlr_scene_buffer_set_dest_size(bufferset->bl,
bufferset->border_width, bufferset->border_width);
wlr_scene_node_set_position(&bufferset->bl->node,
0, height-bufferset->border_width+y);
}
void clearBorderCache(struct borderset * borderset) void clearBorderCache(struct borderset * borderset)
{ {
if (borderset == NULL) if (borderset == NULL)

128
src/common/lab-scene-rect.c
View file

@ -7,12 +7,12 @@
#include "common/macros.h" #include "common/macros.h"
#include "common/borderset.h" #include "common/borderset.h"
#include "buffer.h" #include "buffer.h"
#include <stdio.h>
struct border_scene { struct border_scene {
struct wlr_scene_tree *tree; struct wlr_scene_tree *tree;
struct wlr_scene_rect *top, *bottom, *left, *right; struct wlr_scene_rect *top, *bottom, *left, *right;
struct wlr_scene_buffer *tlcorner, *trcorner, *blcorner, *brcorner, struct bufferset * texturedBorders;
*ttexture, *ltexture, *rtexture, *btexture;
}; };
static void static void
@ -42,77 +42,23 @@ lab_scene_rect_create(struct wlr_scene_tree *parent,
struct border_scene *border = &rect->borders[i]; struct border_scene *border = &rect->borders[i];
float *color = opts->border_colors[i]; float *color = opts->border_colors[i];
border->tree = lab_wlr_scene_tree_create(rect->tree); border->tree = lab_wlr_scene_tree_create(rect->tree);
// Beveled mode 0 = normal outline
// Beveled mode 1 = full bevel with sharp internal corners
if (opts->beveled > 0) {
border->top = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
border->right = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
border->bottom = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
border->left = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
if (opts->beveled) {
float r = color[0]; float r = color[0];
float g = color[1]; float g = color[1];
float b = color[2]; float b = color[2];
float a = color[3]; float a = color[3];
int bw = rect->border_width; int bw = rect->border_width;
uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255); uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255);
struct borderset * renderedborders = getBorders(colour32, bw, 1, 0); struct borderset * renderedborders = getBorders(colour32, bw, BORDER_SINGLE, 0);
border->texturedBorders = generateBufferset(border->tree, renderedborders, bw);
border->top = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
border->right = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
border->bottom = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
border->left = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
struct lab_data_buffer *ttexture_buffer =
buffer_create_from_data(renderedborders->top, 1, 1, 4);
border->ttexture = wlr_scene_buffer_create(border->tree, &ttexture_buffer->base);
struct lab_data_buffer *ltexture_buffer =
buffer_create_from_data(renderedborders->left, 1, 1, 4);
border->ltexture = wlr_scene_buffer_create(border->tree, &ltexture_buffer->base);
struct lab_data_buffer *rtexture_buffer =
buffer_create_from_data(renderedborders->right, 1, 1, 4);
border->rtexture = wlr_scene_buffer_create(border->tree, &rtexture_buffer->base);
struct lab_data_buffer *btexture_buffer =
buffer_create_from_data(renderedborders->bottom, 1, 1, 4);
border->btexture = wlr_scene_buffer_create(border->tree, &btexture_buffer->base);
struct lab_data_buffer *tltexture_buffer =
buffer_create_from_data(renderedborders->tl, bw, bw, 4*bw);
border->tlcorner = wlr_scene_buffer_create(border->tree, &tltexture_buffer->base);
struct lab_data_buffer *trtexture_buffer =
buffer_create_from_data(renderedborders->tr, bw, bw, 4*bw);
border->trcorner = wlr_scene_buffer_create(border->tree, &trtexture_buffer->base);
struct lab_data_buffer *bltexture_buffer =
buffer_create_from_data(renderedborders->bl, bw, bw, 4*bw);
border->blcorner = wlr_scene_buffer_create(border->tree, &bltexture_buffer->base);
struct lab_data_buffer *brtexture_buffer =
buffer_create_from_data(renderedborders->br, bw, bw, 4*bw);
border->brcorner = wlr_scene_buffer_create(border->tree, &brtexture_buffer->base);
} else { } else {
border->top = lab_wlr_scene_rect_create(border->tree, 0, 0, color); border->texturedBorders = NULL;
border->right = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
border->bottom = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
border->left = lab_wlr_scene_rect_create(border->tree, 0, 0, color);
border->tlcorner=NULL;
border->trcorner=NULL;
border->blcorner=NULL;
border->brcorner=NULL;
} }
@ -156,56 +102,8 @@ resize_border(struct border_scene *border, int border_width, int width, int heig
wlr_scene_rect_set_size(border->bottom, width, border_width); wlr_scene_rect_set_size(border->bottom, width, border_width);
wlr_scene_rect_set_size(border->left, border_width, height - border_width * 2); wlr_scene_rect_set_size(border->left, border_width, height - border_width * 2);
wlr_scene_rect_set_size(border->right, border_width, height - border_width * 2); wlr_scene_rect_set_size(border->right, border_width, height - border_width * 2);
if (border->texturedBorders != NULL) {
if (border->tlcorner != NULL) { renderBufferset(border->texturedBorders, width, height, 0);
wlr_scene_buffer_set_dest_size(border->ttexture,
width, border_width);
wlr_scene_node_set_position(&border->ttexture->node,
0,0);
wlr_scene_buffer_set_dest_size(border->btexture,
width, border_width);
wlr_scene_node_set_position(&border->btexture->node,
0, height - border_width);
wlr_scene_buffer_set_dest_size(border->ltexture,
border_width, height - border_width * 2);
wlr_scene_node_set_position(&border->ltexture->node,
0, border_width);
wlr_scene_buffer_set_dest_size(border->rtexture,
border_width, height - border_width * 2);
wlr_scene_node_set_position(&border->rtexture->node,
width - border_width, border_width);
wlr_scene_buffer_set_dest_size(border->tlcorner,
border_width, border_width);
wlr_scene_node_set_position(&border->tlcorner->node,
0,0);
wlr_scene_buffer_set_dest_size(border->trcorner,
border_width, border_width);
wlr_scene_node_set_position(&border->trcorner->node,
width-border_width, 0);
wlr_scene_buffer_set_dest_size(border->brcorner,
border_width, border_width);
wlr_scene_node_set_position(&border->brcorner->node,
width-border_width , height-border_width);
wlr_scene_buffer_set_dest_size(border->blcorner,
border_width, border_width);
wlr_scene_node_set_position(&border->blcorner->node,
0, height-border_width);
} }
} }

2
src/cycle/cycle.c
View file

@ -37,7 +37,7 @@ update_preview_outlines(struct view *view)
}, },
.nr_borders = 3, .nr_borders = 3,
.border_width = theme->osd_window_switcher_preview_border_width, .border_width = theme->osd_window_switcher_preview_border_width,
.beveled = 1, // Checked .beveled = true,
}; };
rect = lab_scene_rect_create(&server.scene->tree, &opts); rect = lab_scene_rect_create(&server.scene->tree, &opts);
wlr_scene_node_place_above(&rect->tree->node, wlr_scene_node_place_above(&rect->tree->node,

2
src/cycle/osd-classic.c
View file

@ -120,7 +120,7 @@ cycle_osd_classic_init(struct cycle_osd_output *osd_output)
.bg_color = bg_color, .bg_color = bg_color,
.width = w, .width = w,
.height = h, .height = h,
.beveled = 1, .beveled = true,
}; };
lab_scene_rect_create(osd_output->tree, &bg_opts); lab_scene_rect_create(osd_output->tree, &bg_opts);

2
src/cycle/osd-scroll.c
View file

@ -35,7 +35,7 @@ cycle_osd_scroll_init(struct cycle_osd_output *osd_output, struct wlr_box bar_ar
.bg_color = bg_color, .bg_color = bg_color,
.width = bar_area.width, .width = bar_area.width,
.height = bar_area.height * nr_visible_rows / nr_rows, .height = bar_area.height * nr_visible_rows / nr_rows,
.beveled = 1, .beveled = true,
}; };
scroll->bar = lab_scene_rect_create(scroll->bar_tree, &scrollbar_opts); scroll->bar = lab_scene_rect_create(scroll->bar_tree, &scrollbar_opts);
} }

4
src/cycle/osd-thumbnail.c
View file

@ -150,7 +150,7 @@ create_item_scene(struct wlr_scene_tree *parent, struct view *view,
.bg_color = switcher_theme->item_active_bg_color, .bg_color = switcher_theme->item_active_bg_color,
.width = switcher_theme->item_width, .width = switcher_theme->item_width,
.height = switcher_theme->item_height, .height = switcher_theme->item_height,
.beveled = 1, .beveled = true,
}; };
item->active_bg = lab_scene_rect_create(tree, &opts); item->active_bg = lab_scene_rect_create(tree, &opts);
@ -283,7 +283,7 @@ cycle_osd_thumbnail_init(struct cycle_osd_output *osd_output)
.bg_color = theme->osd_bg_color, .bg_color = theme->osd_bg_color,
.width = items_width + 2 * padding, .width = items_width + 2 * padding,
.height = items_height + 2 * padding, .height = items_height + 2 * padding,
.beveled = 1, .beveled = true,
}; };
struct lab_scene_rect *bg = struct lab_scene_rect *bg =
lab_scene_rect_create(osd_output->tree, &bg_opts); lab_scene_rect_create(osd_output->tree, &bg_opts);

113
src/menu/menu.c
View file

@ -169,7 +169,7 @@ item_create_scene_for_state(struct menuitem *item, float *text_color,
{ {
struct menu *menu = item->parent; struct menu *menu = item->parent;
struct theme *theme = rc.theme; struct theme *theme = rc.theme;
struct wlr_scene_buffer *top, *left, *right, *bottom, *tl, *tr, *bl, *br; struct bufferset * bufferset;
/* Tree to hold background and label buffers */ /* Tree to hold background and label buffers */
struct wlr_scene_tree *tree = lab_wlr_scene_tree_create(item->tree); struct wlr_scene_tree *tree = lab_wlr_scene_tree_create(item->tree);
@ -203,42 +203,8 @@ item_create_scene_for_state(struct menuitem *item, float *text_color,
uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255); uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255);
struct borderset * renderedborders = getBorders(colour32, bw, 3, 0); struct borderset * renderedborders = getBorders(colour32, bw, BORDER_INSET, 0);
struct lab_data_buffer *ttexture_buffer = bufferset = generateBufferset(tree, renderedborders, bw);
buffer_create_from_data(renderedborders->top, 1, 1, 4);
top = wlr_scene_buffer_create(tree, &ttexture_buffer->base);
struct lab_data_buffer *ltexture_buffer =
buffer_create_from_data(renderedborders->left, 1, 1, 4);
left = wlr_scene_buffer_create(tree, &ltexture_buffer->base);
struct lab_data_buffer *rtexture_buffer =
buffer_create_from_data(renderedborders->right, 1, 1, 4);
right = wlr_scene_buffer_create(tree, &rtexture_buffer->base);
struct lab_data_buffer *btexture_buffer =
buffer_create_from_data(renderedborders->bottom, 1, 1, 4);
bottom = wlr_scene_buffer_create(tree, &btexture_buffer->base);
struct lab_data_buffer *tltexture_buffer =
buffer_create_from_data(renderedborders->tl, bw, bw, 4*bw);
tl = wlr_scene_buffer_create(tree, &tltexture_buffer->base);
struct lab_data_buffer *trtexture_buffer =
buffer_create_from_data(renderedborders->tr, bw, bw, 4*bw);
tr = wlr_scene_buffer_create(tree, &trtexture_buffer->base);
struct lab_data_buffer *bltexture_buffer =
buffer_create_from_data(renderedborders->bl, bw, bw, 4*bw);
bl = wlr_scene_buffer_create(tree, &bltexture_buffer->base);
struct lab_data_buffer *brtexture_buffer =
buffer_create_from_data(renderedborders->br, bw, bw, 4*bw);
br = wlr_scene_buffer_create(tree, &brtexture_buffer->base);
} }
@ -275,55 +241,7 @@ item_create_scene_for_state(struct menuitem *item, float *text_color,
if (rc.theme->beveled_border && state) { if (rc.theme->beveled_border && state) {
renderBufferset(bufferset, bg_width, theme->menu_item_height, 0);
int height = theme->menu_item_height;
wlr_scene_buffer_set_dest_size(top,
bg_width, bw);
wlr_scene_node_set_position(&top->node,
0,0);
wlr_scene_buffer_set_dest_size(bottom,
bg_width, bw);
wlr_scene_node_set_position(&bottom->node,
0, height - bw);
wlr_scene_buffer_set_dest_size(left,
bw, height - bw * 2);
wlr_scene_node_set_position(&left->node,
0, bw);
wlr_scene_buffer_set_dest_size(right,
bw, height - bw * 2);
wlr_scene_node_set_position(&right->node,
bg_width - bw, bw);
wlr_scene_buffer_set_dest_size(tl,
bw, bw);
wlr_scene_node_set_position(&tl->node,
0,0);
wlr_scene_buffer_set_dest_size(tr,
bw, bw);
wlr_scene_node_set_position(&tr->node,
bg_width-bw, 0);
wlr_scene_buffer_set_dest_size(br,
bw, bw);
wlr_scene_node_set_position(&br->node,
bg_width-bw , height-bw);
wlr_scene_buffer_set_dest_size(bl,
bw, bw);
wlr_scene_node_set_position(&bl->node,
0, height-bw);
} }
@ -446,6 +364,8 @@ title_create_scene(struct menuitem *menuitem, int *item_y)
assert(menuitem->type == LAB_MENU_TITLE); assert(menuitem->type == LAB_MENU_TITLE);
struct menu *menu = menuitem->parent; struct menu *menu = menuitem->parent;
struct theme *theme = rc.theme; struct theme *theme = rc.theme;
struct bufferset * bufferset;
float *bg_color = theme->menu_title_bg_color; float *bg_color = theme->menu_title_bg_color;
float *text_color = theme->menu_title_text_color; float *text_color = theme->menu_title_text_color;
@ -465,6 +385,21 @@ title_create_scene(struct menuitem *menuitem, int *item_y)
goto error; goto error;
} }
int bw = theme->menu_border_width;
if (rc.theme->beveled_border) {
float r = bg_color[0];
float g = bg_color[1];
float b = bg_color[2];
float a = bg_color[3];
uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255);
struct borderset * renderedborders = getBorders(colour32, bw, BORDER_SINGLE, 0);
bufferset = generateBufferset(menuitem->tree, renderedborders, bw);
}
/* Background */ /* Background */
lab_wlr_scene_rect_create(menuitem->normal_tree, lab_wlr_scene_rect_create(menuitem->normal_tree,
bg_width, theme->menu_header_height, bg_color); bg_width, theme->menu_header_height, bg_color);
@ -493,6 +428,10 @@ title_create_scene(struct menuitem *menuitem, int *item_y)
int title_y = (theme->menu_header_height - title_font_buffer->height) / 2; int title_y = (theme->menu_header_height - title_font_buffer->height) / 2;
wlr_scene_node_set_position(&title_font_buffer->scene_buffer->node, wlr_scene_node_set_position(&title_font_buffer->scene_buffer->node,
title_x, title_y); title_x, title_y);
if (rc.theme->beveled_border) {
renderBufferset(bufferset, bg_width, theme->menu_item_height, 0);
}
error: error:
wlr_scene_node_set_position(&menuitem->tree->node, wlr_scene_node_set_position(&menuitem->tree->node,
theme->menu_border_width, *item_y); theme->menu_border_width, *item_y);
@ -565,7 +504,7 @@ menu_create_scene(struct menu *menu)
.border_width = theme->menu_border_width, .border_width = theme->menu_border_width,
.width = menu->size.width, .width = menu->size.width,
.height = menu->size.height, .height = menu->size.height,
.beveled = 1, .beveled = true,
}; };
struct lab_scene_rect *bg_rect = struct lab_scene_rect *bg_rect =
lab_scene_rect_create(menu->scene_tree, &opts); lab_scene_rect_create(menu->scene_tree, &opts);

92
src/ssd/resize-indicator.c
View file

@ -61,44 +61,8 @@ resize_indicator_init(struct view *view)
int bw = rc.theme->osd_border_width; int bw = rc.theme->osd_border_width;
uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255); uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255);
struct borderset * renderedborders = getBorders(colour32, bw, 1, 0); struct borderset * renderedborders = getBorders(colour32, bw, BORDER_SINGLE, 0);
struct lab_data_buffer *ttexture_buffer = indicator->texturedBorders = generateBufferset(indicator->tree, renderedborders, bw);
buffer_create_from_data(renderedborders->top, 1, 1, 4);
indicator->top = wlr_scene_buffer_create(indicator->tree, &ttexture_buffer->base);
struct lab_data_buffer *ltexture_buffer =
buffer_create_from_data(renderedborders->left, 1, 1, 4);
indicator->left = wlr_scene_buffer_create(indicator->tree, &ltexture_buffer->base);
struct lab_data_buffer *rtexture_buffer =
buffer_create_from_data(renderedborders->right, 1, 1, 4);
indicator->right = wlr_scene_buffer_create(indicator->tree, &rtexture_buffer->base);
struct lab_data_buffer *btexture_buffer =
buffer_create_from_data(renderedborders->bottom, 1, 1, 4);
indicator->bottom = wlr_scene_buffer_create(indicator->tree, &btexture_buffer->base);
struct lab_data_buffer *tltexture_buffer =
buffer_create_from_data(renderedborders->tl, bw, bw, 4*bw);
indicator->tl = wlr_scene_buffer_create(indicator->tree, &tltexture_buffer->base);
struct lab_data_buffer *trtexture_buffer =
buffer_create_from_data(renderedborders->tr, bw, bw, 4*bw);
indicator->tr = wlr_scene_buffer_create(indicator->tree, &trtexture_buffer->base);
struct lab_data_buffer *bltexture_buffer =
buffer_create_from_data(renderedborders->bl, bw, bw, 4*bw);
indicator->bl = wlr_scene_buffer_create(indicator->tree, &bltexture_buffer->base);
struct lab_data_buffer *brtexture_buffer =
buffer_create_from_data(renderedborders->br, bw, bw, 4*bw);
indicator->br = wlr_scene_buffer_create(indicator->tree, &brtexture_buffer->base);
} }
@ -172,57 +136,7 @@ resize_indicator_set_size(struct resize_indicator *indicator, int width)
indicator->height - 2 * rc.theme->osd_border_width); indicator->height - 2 * rc.theme->osd_border_width);
if (rc.theme->beveled_border) { if (rc.theme->beveled_border) {
renderBufferset(indicator->texturedBorders, indicator->width, indicator->height, 0);
int height = indicator->height;
int border_width = rc.theme->osd_border_width;
wlr_scene_buffer_set_dest_size(indicator->top,
indicator->width, border_width);
wlr_scene_node_set_position(&indicator->top->node,
0,0);
wlr_scene_buffer_set_dest_size(indicator->bottom,
indicator->width, border_width);
wlr_scene_node_set_position(&indicator->bottom->node,
0, height - border_width);
wlr_scene_buffer_set_dest_size(indicator->left,
border_width, height - border_width * 2);
wlr_scene_node_set_position(&indicator->left->node,
0, border_width);
wlr_scene_buffer_set_dest_size(indicator->right,
border_width, height - border_width * 2);
wlr_scene_node_set_position(&indicator->right->node,
indicator->width - border_width, border_width);
wlr_scene_buffer_set_dest_size(indicator->tl,
border_width, border_width);
wlr_scene_node_set_position(&indicator->tl->node,
0,0);
wlr_scene_buffer_set_dest_size(indicator->tr,
border_width, border_width);
wlr_scene_node_set_position(&indicator->tr->node,
indicator->width-border_width, 0);
wlr_scene_buffer_set_dest_size(indicator->br,
border_width, border_width);
wlr_scene_node_set_position(&indicator->br->node,
indicator->width-border_width , height-border_width);
wlr_scene_buffer_set_dest_size(indicator->bl,
border_width, border_width);
wlr_scene_node_set_position(&indicator->bl->node,
0, height-border_width);
} }
} }

93
src/ssd/ssd-border.c
View file

@ -63,56 +63,9 @@ ssd_border_create(struct ssd *ssd)
float a = color[3]; float a = color[3];
uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255); uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255);
struct borderset * renderedborders = getBorders(colour32, bw, 2, bevelSize); struct borderset * renderedborders = getBorders(colour32, bw, BORDER_DOUBLE, bevelSize);
subtree->texturedBorders = generateBufferset(subtree->tree, renderedborders, bw);
struct lab_data_buffer *ttexture_buffer =
buffer_create_from_data(renderedborders->top, 1,theme->border_width,
4);
subtree->ttexture = wlr_scene_buffer_create(parent, &ttexture_buffer->base);
struct lab_data_buffer *btexture_buffer =
buffer_create_from_data(renderedborders->bottom, 1,theme->border_width,
4);
subtree->btexture = wlr_scene_buffer_create(parent, &btexture_buffer->base);
struct lab_data_buffer *ltexture_buffer =
buffer_create_from_data(renderedborders->left, theme->border_width, 1,
4*theme->border_width);
subtree->ltexture = wlr_scene_buffer_create(parent, &ltexture_buffer->base);
struct lab_data_buffer *rtexture_buffer =
buffer_create_from_data(renderedborders->right, theme->border_width, 1,
4*theme->border_width);
subtree->rtexture = wlr_scene_buffer_create(parent, &rtexture_buffer->base);
struct lab_data_buffer *tltexture_buffer =
buffer_create_from_data(renderedborders->tl, theme->border_width, theme->border_width,
4*theme->border_width);
subtree->tlcorner = wlr_scene_buffer_create(parent, &tltexture_buffer->base);
struct lab_data_buffer *trtexture_buffer =
buffer_create_from_data(renderedborders->tr, theme->border_width, theme->border_width,
4*theme->border_width);
subtree->trcorner = wlr_scene_buffer_create(parent, &trtexture_buffer->base);
struct lab_data_buffer *bltexture_buffer =
buffer_create_from_data(renderedborders->bl, theme->border_width, theme->border_width,
4*theme->border_width);
subtree->blcorner = wlr_scene_buffer_create(parent, &bltexture_buffer->base);
struct lab_data_buffer *brtexture_buffer =
buffer_create_from_data(renderedborders->br, theme->border_width, theme->border_width,
4*theme->border_width);
subtree->brcorner = wlr_scene_buffer_create(parent, &brtexture_buffer->base);
} else { } else {
subtree->left = lab_wlr_scene_rect_create(parent, subtree->left = lab_wlr_scene_rect_create(parent,
theme->border_width, height, color); theme->border_width, height, color);
@ -220,47 +173,7 @@ ssd_border_update(struct ssd *ssd)
if (theme->beveled_border) { if (theme->beveled_border) {
wlr_scene_buffer_set_dest_size(subtree->ttexture, renderBufferset(subtree->texturedBorders, full_width, side_height+(ssd->titlebar.height + 2*theme->border_width), -ssd->titlebar.height-theme->border_width);
full_width, theme->border_width);
wlr_scene_node_set_position(&subtree->ttexture->node,
0, -(ssd->titlebar.height + theme->border_width));
wlr_scene_buffer_set_dest_size(subtree->rtexture,
theme->border_width, side_height+(ssd->titlebar.height + theme->border_width));
wlr_scene_node_set_position(&subtree->rtexture->node,
theme->border_width + width, -(ssd->titlebar.height + theme->border_width));
wlr_scene_buffer_set_dest_size(subtree->btexture,
full_width, theme->border_width);
wlr_scene_node_set_position(&subtree->btexture->node,
0, height);
wlr_scene_buffer_set_dest_size(subtree->ltexture,
theme->border_width, side_height+(ssd->titlebar.height + theme->border_width));
wlr_scene_node_set_position(&subtree->ltexture->node,
0, -(ssd->titlebar.height + theme->border_width));
wlr_scene_buffer_set_dest_size(subtree->tlcorner,
theme->border_width, theme->border_width);
wlr_scene_node_set_position(&subtree->tlcorner->node,
0, -(ssd->titlebar.height + theme->border_width));
wlr_scene_buffer_set_dest_size(subtree->trcorner,
theme->border_width, theme->border_width);
wlr_scene_node_set_position(&subtree->trcorner->node,
theme->border_width + width, -(ssd->titlebar.height + theme->border_width));
wlr_scene_buffer_set_dest_size(subtree->brcorner,
theme->border_width, theme->border_width);
wlr_scene_node_set_position(&subtree->brcorner->node,
theme->border_width + width, height);
wlr_scene_buffer_set_dest_size(subtree->blcorner,
theme->border_width, theme->border_width);
wlr_scene_node_set_position(&subtree->blcorner->node,
0, height);
} else { } else {
wlr_scene_rect_set_size(subtree->left, wlr_scene_rect_set_size(subtree->left,
theme->border_width, side_height); theme->border_width, side_height);

2
src/theme.c
View file

@ -532,7 +532,7 @@ static void
theme_builtin(struct theme *theme) theme_builtin(struct theme *theme)
{ {
theme->border_width = 1; theme->border_width = 1;
theme->beveled_border = FALSE; theme->beveled_border = false;
theme->border_bevel_width=0; theme->border_bevel_width=0;
theme->window_titlebar_padding_height = 0; theme->window_titlebar_padding_height = 0;
theme->window_titlebar_padding_width = 0; theme->window_titlebar_padding_width = 0;

2
src/workspaces.c
View file

@ -114,7 +114,7 @@ _osd_update(void)
float a = theme->osd_border_color[3]; float a = theme->osd_border_color[3];
uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255); uint32_t colour32 = (uint32_t)(a*255) << 24 | (uint32_t)(r*255) << 16 | (uint32_t)(g*255) << 8 | (uint32_t)(b*255);
struct borderset * renderedborders = getBorders(colour32, bw, 1, 0); struct borderset * renderedborders = getBorders(colour32, bw, BORDER_SINGLE, 0);
cairo_surface_t* top = cairo_image_surface_create_for_data((unsigned char *)renderedborders->top, CAIRO_FORMAT_ARGB32, 1, 1, 4); cairo_surface_t* top = cairo_image_surface_create_for_data((unsigned char *)renderedborders->top, CAIRO_FORMAT_ARGB32, 1, 1, 4);