mr4th
/
linux-windowing
0
Fork 0
Code Issues Releases Activity

[digesting_libdecor] swap out with fixed component indexes

main
Allen Webster 2026-02-28 11:34:43 -08:00
parent 4f8388f544
commit e0498157b9
2 changed files with 269 additions and 441 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

606
digesting_libdecor.c
View File

@ -105,8 +105,8 @@ pointer_enter(void *data, struct wl_pointer *wl_pointer, uint32_t serial,
seat->pointer_focus = surface; seat->pointer_focus = surface;
if (own_proxy(surface)){ if (own_proxy(surface)){
ctx.active = border_component_from_wl_surface(surface); ctx.active = component_slot_from_wl_surface(surface);
if (ctx.active){ if (ctx.active != 0){
draw_decoration(); draw_decoration();
wl_surface_commit(ctx.wl_surface); wl_surface_commit(ctx.wl_surface);
} }
@ -116,15 +116,10 @@ pointer_enter(void *data, struct wl_pointer *wl_pointer, uint32_t serial,
struct wl_cursor_image *image = seat->current_cursor->images[0]; struct wl_cursor_image *image = seat->current_cursor->images[0];
struct wl_buffer *buffer = wl_cursor_image_get_buffer(image); struct wl_buffer *buffer = wl_cursor_image_get_buffer(image);
wl_surface_attach(seat->cursor_surface, buffer, 0, 0); wl_surface_attach(seat->cursor_surface, buffer, 0, 0);
wl_surface_set_buffer_scale(seat->cursor_surface, seat->cursor_scale); wl_surface_set_buffer_scale(seat->cursor_surface, 1);
wl_surface_damage_buffer(seat->cursor_surface, 0, 0, wl_surface_damage_buffer(seat->cursor_surface, 0, 0, image->width, image->height);
image->width * seat->cursor_scale,
image->height * seat->cursor_scale);
wl_surface_commit(seat->cursor_surface); wl_surface_commit(seat->cursor_surface);
wl_pointer_set_cursor(seat->wl_pointer, seat->serial, wl_pointer_set_cursor(seat->wl_pointer, seat->serial, seat->cursor_surface, image->hotspot_x, image->hotspot_y);
seat->cursor_surface,
image->hotspot_x / seat->cursor_scale,
image->hotspot_y / seat->cursor_scale);
} }
} }
} }
@ -162,20 +157,15 @@ pointer_motion(void *data, struct wl_pointer *wl_pointer, uint32_t time,
struct wl_cursor_image *image = seat->current_cursor->images[0]; struct wl_cursor_image *image = seat->current_cursor->images[0];
struct wl_buffer *buffer = wl_cursor_image_get_buffer(image); struct wl_buffer *buffer = wl_cursor_image_get_buffer(image);
wl_surface_attach(seat->cursor_surface, buffer, 0, 0); wl_surface_attach(seat->cursor_surface, buffer, 0, 0);
wl_surface_set_buffer_scale(seat->cursor_surface, seat->cursor_scale); wl_surface_set_buffer_scale(seat->cursor_surface, 1);
wl_surface_damage_buffer(seat->cursor_surface, 0, 0, wl_surface_damage_buffer(seat->cursor_surface, 0, 0, image->width, image->height);
image->width * seat->cursor_scale,
image->height * seat->cursor_scale);
wl_surface_commit(seat->cursor_surface); wl_surface_commit(seat->cursor_surface);
wl_pointer_set_cursor(seat->wl_pointer, seat->serial, wl_pointer_set_cursor(seat->wl_pointer, seat->serial, seat->cursor_surface, image->hotspot_x, image->hotspot_y);
seat->cursor_surface,
image->hotspot_x / seat->cursor_scale,
image->hotspot_y / seat->cursor_scale);
} }
} }
/* avoid warnings after decoration has been turned off */ /* avoid warnings after decoration has been turned off */
if (!GTK_IS_WIDGET(ctx.header) || ctx.active->type != HEADER){ if (!GTK_IS_WIDGET(ctx.header) || ctx.active != COMPONENT_SLOT_HEADER){
ctx.hdr_focus.type = HEADER_NONE; ctx.hdr_focus.type = HEADER_NONE;
} }
@ -191,18 +181,14 @@ pointer_motion(void *data, struct wl_pointer *wl_pointer, uint32_t time,
draw_title_bar(); draw_title_bar();
wl_surface_commit(ctx.wl_surface); wl_surface_commit(ctx.wl_surface);
switch (ctx.titlebar_gesture.state) { if (ctx.titlebar_gesture.state == TITLEBAR_GESTURE_STATE_BUTTON_PRESSED){
case TITLEBAR_GESTURE_STATE_BUTTON_PRESSED:
if (ctx.titlebar_gesture.first_pressed_button == BTN_LEFT){ if (ctx.titlebar_gesture.first_pressed_button == BTN_LEFT){
if (ABS((double)seat->pointer_x - (double)ctx.titlebar_gesture.pressed_x) > ctx.drag_threshold || int xd = ABS(seat->pointer_x - ctx.titlebar_gesture.pressed_x);
ABS((double)seat->pointer_y - (double)ctx.titlebar_gesture.pressed_y) > ctx.drag_threshold){ int yd = ABS(seat->pointer_y - ctx.titlebar_gesture.pressed_y);
xdg_toplevel_move(ctx.xdg_toplevel, seat->wl_seat, ctx.titlebar_gesture.pressed_serial); if (xd > ctx.drag_threshold || yd > ctx.drag_threshold){
xdg_toplevel_move(ctx.xdg_toplevel, seat->wl_seat, ctx.titlebar_gesture.serial);
} }
} }
case TITLEBAR_GESTURE_STATE_INIT:
case TITLEBAR_GESTURE_STATE_CONSUMED:
case TITLEBAR_GESTURE_STATE_DISCARDED:
break;
} }
} }
} }
@ -212,17 +198,16 @@ pointer_button(void *data, struct wl_pointer *wl_pointer, uint32_t serial,
uint32_t time, uint32_t button, uint32_t state){ uint32_t time, uint32_t button, uint32_t state){
struct seat *seat = data; struct seat *seat = data;
if (seat->pointer_focus && own_proxy(seat->pointer_focus)){ if (seat->pointer_focus && own_proxy(seat->pointer_focus)){
switch (ctx.active->type) { switch (ctx.active){
case SHADOW: { case COMPONENT_SLOT_SHADOW: {
enum libdecor_resize_edge edge = enum libdecor_resize_edge edge = component_edge(COMPONENT_SLOT_SHADOW, seat->pointer_x, seat->pointer_y);
component_edge(ctx.active, seat->pointer_x, seat->pointer_y, SHADOW_MARGIN);
if (edge != LIBDECOR_RESIZE_EDGE_NONE && if (edge != LIBDECOR_RESIZE_EDGE_NONE &&
(ctx.frame_capabilities & LIBDECOR_ACTION_RESIZE)){ (ctx.frame_capabilities & LIBDECOR_ACTION_RESIZE)){
libdecor_frame_resize(seat->wl_seat, serial, edge); xdg_toplevel_resize(ctx.xdg_toplevel, seat->wl_seat, serial, xdg_edge_from_edge(edge));
} }
}break; }break;
case HEADER: { case COMPONENT_SLOT_HEADER: {
switch (ctx.titlebar_gesture.state){ switch (ctx.titlebar_gesture.state){
case TITLEBAR_GESTURE_STATE_INIT: { case TITLEBAR_GESTURE_STATE_INIT: {
if (state == WL_POINTER_BUTTON_STATE_PRESSED){ if (state == WL_POINTER_BUTTON_STATE_PRESSED){
@ -245,7 +230,7 @@ pointer_button(void *data, struct wl_pointer *wl_pointer, uint32_t serial,
ctx.titlebar_gesture.first_pressed_time = time; ctx.titlebar_gesture.first_pressed_time = time;
ctx.titlebar_gesture.pressed_x = seat->pointer_x; ctx.titlebar_gesture.pressed_x = seat->pointer_x;
ctx.titlebar_gesture.pressed_y = seat->pointer_y; ctx.titlebar_gesture.pressed_y = seat->pointer_y;
ctx.titlebar_gesture.pressed_serial = serial; ctx.titlebar_gesture.serial = serial;
ctx.titlebar_gesture.state = TITLEBAR_GESTURE_STATE_BUTTON_PRESSED; ctx.titlebar_gesture.state = TITLEBAR_GESTURE_STATE_BUTTON_PRESSED;
} }
} }
@ -361,7 +346,7 @@ touch_down(void *data, struct wl_touch *wl_touch, uint32_t serial,
if (surface != 0 && own_proxy(surface)){ if (surface != 0 && own_proxy(surface)){
seat->touch_focus = surface; seat->touch_focus = surface;
ctx.touch_active = border_component_from_wl_surface(surface); ctx.touch_active = component_slot_from_wl_surface(surface);
if (ctx.touch_active){ if (ctx.touch_active){
update_touch_focus(seat, x, y); update_touch_focus(seat, x, y);
@ -370,13 +355,16 @@ touch_down(void *data, struct wl_touch *wl_touch, uint32_t serial,
draw_decoration(); draw_decoration();
wl_surface_commit(ctx.wl_surface); wl_surface_commit(ctx.wl_surface);
enum libdecor_resize_edge edge = LIBDECOR_RESIZE_EDGE_NONE; switch (ctx.touch_active){
switch (ctx.touch_active->type) { case COMPONENT_SLOT_SHADOW: {
case SHADOW: { enum libdecor_resize_edge edge = component_edge(COMPONENT_SLOT_SHADOW, wl_fixed_to_int(x), wl_fixed_to_int(y));
edge = component_edge(ctx.touch_active, wl_fixed_to_int(x), wl_fixed_to_int(y), SHADOW_MARGIN); if (edge != LIBDECOR_RESIZE_EDGE_NONE &&
(ctx.frame_capabilities & LIBDECOR_ACTION_RESIZE)){
xdg_toplevel_resize(ctx.xdg_toplevel, seat->wl_seat, serial, xdg_edge_from_edge(edge));
}
}break; }break;
case HEADER: { case COMPONENT_SLOT_HEADER: {
switch (ctx.hdr_focus.type){ switch (ctx.hdr_focus.type){
case HEADER_MIN: case HEADER_MIN:
case HEADER_MAX: case HEADER_MAX:
@ -405,10 +393,6 @@ touch_down(void *data, struct wl_touch *wl_touch, uint32_t serial,
default: break; default: break;
} }
if (edge != LIBDECOR_RESIZE_EDGE_NONE &&
(ctx.frame_capabilities & LIBDECOR_ACTION_RESIZE)) {
libdecor_frame_resize(seat->wl_seat, serial, edge);
}
} }
} }
} }
@ -418,7 +402,7 @@ touch_up(void *data, struct wl_touch *wl_touch, uint32_t serial, uint32_t time,
struct seat *seat = data; struct seat *seat = data;
if (seat->touch_focus && own_proxy(seat->touch_focus)){ if (seat->touch_focus && own_proxy(seat->touch_focus)){
if (ctx.touch_active != 0){ if (ctx.touch_active != 0){
if (ctx.touch_active->type == HEADER){ if (ctx.touch_active == COMPONENT_SLOT_HEADER){
switch (ctx.hdr_focus.type) { switch (ctx.hdr_focus.type) {
case HEADER_MIN: { case HEADER_MIN: {
if (ctx.frame_capabilities & LIBDECOR_ACTION_MINIMIZE){ if (ctx.frame_capabilities & LIBDECOR_ACTION_MINIMIZE){
@ -562,7 +546,6 @@ wl_registry_global(void *data, struct wl_registry *wl_registry,
} }
seat = calloc(1, sizeof *seat); seat = calloc(1, sizeof *seat);
seat->cursor_scale = 1;
wl_list_insert(&ctx.seat_list, &seat->link); wl_list_insert(&ctx.seat_list, &seat->link);
seat->wl_seat = wl_registry_bind(ctx.wl_registry, name, &wl_seat_interface, 3); seat->wl_seat = wl_registry_bind(ctx.wl_registry, name, &wl_seat_interface, 3);
wl_seat_add_listener(seat->wl_seat, &seat_listener, seat); wl_seat_add_listener(seat->wl_seat, &seat_listener, seat);
@ -660,17 +643,16 @@ xdg_toplevel_close(void *user_data, struct xdg_toplevel *xdg_toplevel){
#ifdef XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION #ifdef XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION
static void static void
xdg_toplevel_configure_bounds(void *user_data, struct xdg_toplevel *xdg_toplevel, int32_t width, int32_t height){ xdg_toplevel_configure_bounds(void *user_data, struct xdg_toplevel *xdg_toplevel, int32_t w, int32_t h){
int left = 0, top = 0, right = 0, bottom = 0; int32_t inner_w = w;
int32_t inner_h = h;
if (ctx.visible != 0 && if (ctx.visible &&
ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){ ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){
libdecor_plugin_gtk_frame_get_border_size(0, &left, &right, &top, &bottom); Bounds2D border_size = border_size_from_window_state(0);
inner_w -= border_size.x[0] + border_size.x[1];
inner_h -= border_size.y[0] + border_size.y[1];
} }
// event to user (inner_w,inner_h)
width -= left + right;
height -= top + bottom;
//
} }
#endif #endif
@ -940,8 +922,10 @@ int main(){
zxdg_toplevel_decoration_v1_add_listener(ctx.toplevel_decoration, &xdg_toplevel_decoration_listener, 0); zxdg_toplevel_decoration_v1_add_listener(ctx.toplevel_decoration, &xdg_toplevel_decoration_listener, 0);
} }
ctx.content_limits.min_width = 80; ctx.size_bounds.x[0] = 80;
ctx.content_limits.min_height = 60; ctx.size_bounds.y[0] = 60;
ctx.size_bounds.x[1] = (1 << 30);
ctx.size_bounds.y[1] = (1 << 30);
xdg_toplevel_set_app_id(ctx.xdg_toplevel, "demo"); xdg_toplevel_set_app_id(ctx.xdg_toplevel, "demo");
xdg_toplevel_set_title(ctx.xdg_toplevel, "Example Window"); xdg_toplevel_set_title(ctx.xdg_toplevel, "Example Window");
@ -1140,56 +1124,32 @@ int main(){
//#include "libdecor.c" //#include "libdecor.c"
static void
constrain_content_size(int *width, int *height){
const struct libdecor_limits lim = ctx.content_limits;
if (lim.min_width > 0)
*width = MAX(lim.min_width, *width);
if (lim.max_width > 0)
*width = MIN(*width, lim.max_width);
if (lim.min_height > 0)
*height = MAX(lim.min_height, *height);
if (lim.max_height > 0)
*height = MIN(*height, lim.max_height);
}
static void static void
frame_get_window_size_for(struct libdecor_state *state, int *window_width, int *window_height){ frame_get_window_size_for(struct libdecor_state *state, int *window_width, int *window_height){
*window_width = state->content_width; *window_width = state->content_width;
*window_height = state->content_height; *window_height = state->content_height;
if (ctx.visible && ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){ if (ctx.visible && ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){
int left, right, top, bottom; Bounds2D border_size = border_size_from_window_state(ctx.frame_window_state);
libdecor_plugin_gtk_frame_get_border_size(ctx.frame_window_state, &left, &right, &top, &bottom); *window_width += border_size.x[0] + border_size.x[1];
*window_width += left + right; *window_height += border_size.y[0] + border_size.y[1];
*window_height += top + bottom;
} }
} }
static void static void
frame_set_window_geometry(int32_t content_width, int32_t content_height){ frame_set_window_geometry(int32_t w, int32_t h){
int x, y, width, height; Extent2D extent = {0};
extent.w = w;
extent.w = h;
if (ctx.visible != 0 && if (ctx.visible && ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){
ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){ Bounds2D border_size = border_size_from_window_state(ctx.frame_window_state);
int left, right, top, bottom; extent.x = -border_size.x[0];
libdecor_plugin_gtk_frame_get_border_size(ctx.frame_window_state, &left, &right, &top, &bottom); extent.y = -border_size.y[0];
x = -left; extent.w = w + border_size.x[0] + border_size.x[1];
y = -top; extent.h = h + border_size.y[0] + border_size.y[1];
width = content_width + left + right;
height = content_height + top + bottom;
}
else{
x = 0;
y = 0;
width = content_width;
height = content_height;
} }
xdg_surface_set_window_geometry(ctx.xdg_surface, x, y, width, height); xdg_surface_set_window_geometry(ctx.xdg_surface, extent.x, extent.y, extent.w, extent.h);
} }
bool bool
@ -1206,23 +1166,32 @@ libdecor_configuration_get_content_size(struct libdecor_configuration *configura
if (ctx.visible != 0 && if (ctx.visible != 0 &&
ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){ ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){
int left, right, top, bottom;
ctx.frame_window_state = configuration->window_state; ctx.frame_window_state = configuration->window_state;
if (configuration->has_window_state){ if (configuration->has_window_state){
libdecor_plugin_gtk_frame_get_border_size(configuration->window_state, &left, &right, &top, &bottom); Bounds2D border_size = border_size_from_window_state(configuration->window_state);
*width -= border_size.x[0] + border_size.x[1];
*height -= border_size.y[0] + border_size.y[1];
} }
else{ else{
return false; return false;
} }
*width -= (left + right);
*height -= (top + bottom);
} }
/* constrain content dimensions manually */ /* constrain content dimensions manually */
if (!(configuration->window_state & LIBDECOR_WINDOW_STATE_NON_FLOATING)) { if (!(configuration->window_state & LIBDECOR_WINDOW_STATE_NON_FLOATING)) {
constrain_content_size(width, height); // TODO(allen):
if (ctx.size_bounds.x[0] > 0){
*width = MAX(ctx.size_bounds.x[0], *width);
}
if (ctx.size_bounds.x[1] > 0){
*width = MIN(*width, ctx.size_bounds.x[1]);
}
if (ctx.size_bounds.y[0] > 0){
*height = MAX(ctx.size_bounds.y[0], *height);
}
if (ctx.size_bounds.y[1] > 0){
*height = MIN(*height, ctx.size_bounds.y[1]);
}
} }
return true; return true;
@ -1253,7 +1222,7 @@ libdecor_frame_set_visibility(bool visible){
ctx.frame_content_height > 0){ ctx.frame_content_height > 0){
if (ctx.visible != 0 && if (ctx.visible != 0 &&
ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){ ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){
libdecor_plugin_gtk_frame_commit(0, 0); libdecor_plugin_gtk_frame_commit();
} }
else{ else{
libdecor_plugin_gtk_frame_free(); libdecor_plugin_gtk_frame_free();
@ -1265,52 +1234,21 @@ libdecor_frame_set_visibility(bool visible){
} }
} }
void static enum xdg_toplevel_resize_edge
libdecor_frame_translate_coordinate(int content_x, int content_y, int *frame_x, int *frame_y){ xdg_edge_from_edge(enum libdecor_resize_edge edge){
*frame_x = content_x; enum xdg_toplevel_resize_edge result = XDG_TOPLEVEL_RESIZE_EDGE_NONE;
*frame_y = content_y;
if (ctx.visible != 0 &&
ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){
int left, top;
libdecor_plugin_gtk_frame_get_border_size(0, &left, 0, &top, 0);
*frame_x += left;
*frame_y += top;
}
}
enum xdg_toplevel_resize_edge
edge_to_xdg_edge(enum libdecor_resize_edge edge)
{
switch (edge) { switch (edge) {
case LIBDECOR_RESIZE_EDGE_NONE: default: case LIBDECOR_RESIZE_EDGE_NONE: break;
return XDG_TOPLEVEL_RESIZE_EDGE_NONE; case LIBDECOR_RESIZE_EDGE_TOP: result = XDG_TOPLEVEL_RESIZE_EDGE_TOP; break;
case LIBDECOR_RESIZE_EDGE_TOP: case LIBDECOR_RESIZE_EDGE_BOTTOM: result = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM; break;
return XDG_TOPLEVEL_RESIZE_EDGE_TOP; case LIBDECOR_RESIZE_EDGE_LEFT: result = XDG_TOPLEVEL_RESIZE_EDGE_LEFT; break;
case LIBDECOR_RESIZE_EDGE_BOTTOM: case LIBDECOR_RESIZE_EDGE_TOP_LEFT: result = XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT; break;
return XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM; case LIBDECOR_RESIZE_EDGE_BOTTOM_LEFT: result = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT; break;
case LIBDECOR_RESIZE_EDGE_LEFT: case LIBDECOR_RESIZE_EDGE_RIGHT: result = XDG_TOPLEVEL_RESIZE_EDGE_RIGHT; break;
return XDG_TOPLEVEL_RESIZE_EDGE_LEFT; case LIBDECOR_RESIZE_EDGE_TOP_RIGHT: result = XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT; break;
case LIBDECOR_RESIZE_EDGE_TOP_LEFT: case LIBDECOR_RESIZE_EDGE_BOTTOM_RIGHT: result = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT; break;
return XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT;
case LIBDECOR_RESIZE_EDGE_BOTTOM_LEFT:
return XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
case LIBDECOR_RESIZE_EDGE_RIGHT:
return XDG_TOPLEVEL_RESIZE_EDGE_RIGHT;
case LIBDECOR_RESIZE_EDGE_TOP_RIGHT:
return XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT;
case LIBDECOR_RESIZE_EDGE_BOTTOM_RIGHT:
return XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT;
} }
return(result);
abort();
}
void
libdecor_frame_resize(struct wl_seat *wl_seat, uint32_t serial, enum libdecor_resize_edge edge){
enum xdg_toplevel_resize_edge xdg_edge;
xdg_edge = edge_to_xdg_edge(edge);
xdg_toplevel_resize(ctx.xdg_toplevel, wl_seat, serial, xdg_edge);
} }
void void
@ -1344,19 +1282,19 @@ libdecor_frame_commit(int w, int h, struct libdecor_configuration *configuration
* configure event is received, we have to manually set the min/max * configure event is received, we have to manually set the min/max
* limits with the configured content size afterwards. */ * limits with the configured content size afterwards. */
if (!(ctx.frame_capabilities & LIBDECOR_ACTION_RESIZE)){ if (!(ctx.frame_capabilities & LIBDECOR_ACTION_RESIZE)){
ctx.content_limits.min_width = ctx.frame_content_width; ctx.size_bounds.x[0] = ctx.frame_content_width;
ctx.content_limits.min_height = ctx.frame_content_height; ctx.size_bounds.y[0] = ctx.frame_content_height;
ctx.content_limits.max_width = ctx.frame_content_width; ctx.size_bounds.x[1] = ctx.frame_content_width;
ctx.content_limits.max_height = ctx.frame_content_height; ctx.size_bounds.y[1] = ctx.frame_content_height;
} }
if (ctx.content_limits.min_width > 0 && if (ctx.size_bounds.x[0] > 0 &&
ctx.content_limits.min_height > 0){ ctx.size_bounds.y[0] > 0){
struct libdecor_state state_min; struct libdecor_state state_min;
int win_min_width, win_min_height; int win_min_width, win_min_height;
state_min.content_width = ctx.content_limits.min_width; state_min.content_width = ctx.size_bounds.x[0];
state_min.content_height = ctx.content_limits.min_height; state_min.content_height = ctx.size_bounds.y[0];
state_min.window_state = state.window_state; state_min.window_state = state.window_state;
frame_get_window_size_for(&state_min, &win_min_width, &win_min_height); frame_get_window_size_for(&state_min, &win_min_width, &win_min_height);
@ -1366,13 +1304,13 @@ libdecor_frame_commit(int w, int h, struct libdecor_configuration *configuration
xdg_toplevel_set_min_size(ctx.xdg_toplevel, 0, 0); xdg_toplevel_set_min_size(ctx.xdg_toplevel, 0, 0);
} }
if (ctx.content_limits.max_width > 0 && if (ctx.size_bounds.x[1] > 0 &&
ctx.content_limits.max_height > 0){ ctx.size_bounds.y[1] > 0){
struct libdecor_state state_max; struct libdecor_state state_max;
int win_max_width, win_max_height; int win_max_width, win_max_height;
state_max.content_width = ctx.content_limits.max_width; state_max.content_width = ctx.size_bounds.x[1];
state_max.content_height = ctx.content_limits.max_height; state_max.content_height = ctx.size_bounds.y[1];
state_max.window_state = state.window_state; state_max.window_state = state.window_state;
frame_get_window_size_for(&state_max, &win_max_width, &win_max_height); frame_get_window_size_for(&state_max, &win_max_width, &win_max_height);
@ -1384,9 +1322,9 @@ libdecor_frame_commit(int w, int h, struct libdecor_configuration *configuration
} }
/* switch between decoration modes */ /* switch between decoration modes */
if (ctx.visible != 0 && if (ctx.visible &&
ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){ ctx.decoration_mode == ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE){
libdecor_plugin_gtk_frame_commit(&state, configuration); libdecor_plugin_gtk_frame_commit();
} }
else{ else{
libdecor_plugin_gtk_frame_free(); libdecor_plugin_gtk_frame_free();
@ -1931,8 +1869,8 @@ libdecor_plugin_gtk_frame_free(void){
g_clear_pointer(&ctx.header, gtk_widget_destroy); g_clear_pointer(&ctx.header, gtk_widget_destroy);
g_clear_pointer(&ctx.window, gtk_widget_destroy); g_clear_pointer(&ctx.window, gtk_widget_destroy);
free_border_component(&ctx.headerbar); free_border_component(&ctx.component_slot[COMPONENT_SLOT_HEADER]);
free_border_component(&ctx.shadow); free_border_component(&ctx.component_slot[COMPONENT_SLOT_SHADOW]);
ctx.shadow_showing = false; ctx.shadow_showing = false;
g_clear_pointer(&ctx.shadow_blur, cairo_surface_destroy); g_clear_pointer(&ctx.shadow_blur, cairo_surface_destroy);
@ -1949,44 +1887,21 @@ hide_border_component(struct border_component *border_component){
} }
} }
static struct border_component * static enum component_slot
border_component_from_wl_surface(const struct wl_surface *surface){ component_slot_from_wl_surface(const struct wl_surface *surface){
struct border_component *result = 0; enum component_slot result = 0;
if (ctx.shadow.wl_surface == surface){ for (int i = 1; i < COMPONENT_SLOT_COUNT; i += 1){
result = &ctx.shadow; if (ctx.component_slot[i].wl_surface == surface){
result = i;
break;
} }
else if (ctx.headerbar.wl_surface == surface){
result = &ctx.headerbar;
} }
return(result); return(result);
} }
static void
redraw_scale(struct border_component *cmpnt){
struct surface_output *surface_output;
int scale = 1;
bool need_commit = false;
if (cmpnt->wl_surface != 0){
if (scale != cmpnt->scale){
cmpnt->scale = scale;
if ((ctx.decoration_type != DECORATION_TYPE_NONE) &&
(cmpnt->type != SHADOW || ctx.shadow_showing)){
draw_border_component(cmpnt);
need_commit = true;
}
}
}
if (need_commit){
wl_surface_commit(ctx.wl_surface);
}
}
static void static void
ensure_component(struct border_component *cmpnt){ ensure_component(struct border_component *cmpnt){
if (cmpnt->wl_surface == 0){ if (cmpnt->wl_surface == 0){
cmpnt->scale = 1;
cmpnt->wl_surface = wl_compositor_create_surface(ctx.wl_compositor); cmpnt->wl_surface = wl_compositor_create_surface(ctx.wl_compositor);
wl_proxy_set_tag((struct wl_proxy *)cmpnt->wl_surface, &libdecor_gtk_proxy_tag); wl_proxy_set_tag((struct wl_proxy *)cmpnt->wl_surface, &libdecor_gtk_proxy_tag);
cmpnt->wl_subsurface = wl_subcompositor_get_subsurface(ctx.wl_subcompositor, cmpnt->wl_surface, ctx.wl_surface); cmpnt->wl_subsurface = wl_subcompositor_get_subsurface(ctx.wl_subcompositor, cmpnt->wl_surface, ctx.wl_surface);
@ -1997,12 +1912,13 @@ static void
ensure_title_bar_surfaces(void){ ensure_title_bar_surfaces(void){
GtkStyleContext *context_hdr; GtkStyleContext *context_hdr;
ctx.headerbar.type = HEADER; ctx.component_slot[COMPONENT_SLOT_HEADER].slot = COMPONENT_SLOT_HEADER;
ctx.headerbar.opaque = false; ctx.component_slot[COMPONENT_SLOT_HEADER].opaque = false;
ensure_component(&ctx.headerbar); ensure_component(&ctx.component_slot[COMPONENT_SLOT_HEADER]);
if (ctx.shadow.wl_surface){ if (ctx.component_slot[COMPONENT_SLOT_SHADOW].wl_surface){
wl_subsurface_place_above(ctx.headerbar.wl_subsurface, ctx.shadow.wl_surface); wl_subsurface_place_above(ctx.component_slot[COMPONENT_SLOT_HEADER].wl_subsurface,
ctx.component_slot[COMPONENT_SLOT_SHADOW].wl_surface);
} }
if (GTK_IS_WIDGET(ctx.header)){ if (GTK_IS_WIDGET(ctx.header)){
@ -2038,7 +1954,7 @@ ensure_title_bar_surfaces(void){
} }
static Extent2D static Extent2D
extent2d_from_component(enum component component){ extent2d_from_component_type(enum component_slot slot){
Extent2D result = {0}; Extent2D result = {0};
int width = ctx.frame_content_width; int width = ctx.frame_content_width;
int height = ctx.frame_content_height; int height = ctx.frame_content_height;
@ -2048,17 +1964,17 @@ extent2d_from_component(enum component component){
title_height = gtk_widget_get_allocated_height(ctx.header); title_height = gtk_widget_get_allocated_height(ctx.header);
} }
switch (component){ switch (slot){
case NONE: break; default: case COMPONENT_SLOT_NONE: break;
case SHADOW: { case COMPONENT_SLOT_SHADOW: {
result.x = -(int)SHADOW_MARGIN; result.x = -(int)SHADOW_MARGIN;
result.y = -(int)(SHADOW_MARGIN + title_height); result.y = -(int)(SHADOW_MARGIN + title_height);
result.w = width + 2*SHADOW_MARGIN; result.w = width + 2*SHADOW_MARGIN;
result.h = title_height + height + 2*SHADOW_MARGIN; result.h = title_height + height + 2*SHADOW_MARGIN;
}break; }break;
case HEADER: { case COMPONENT_SLOT_HEADER: {
result.x = 0; result.x = 0;
result.y = -title_height; result.y = -title_height;
result.w = gtk_widget_get_allocated_width(ctx.header); result.w = gtk_widget_get_allocated_width(ctx.header);
@ -2217,9 +2133,9 @@ draw_header_button(cairo_t *cr, cairo_surface_t *surface,
static void static void
set_component_input_region(struct border_component *border_component){ set_component_input_region(struct border_component *border_component){
if (border_component->type == SHADOW && ctx.shadow_showing){ if (border_component->slot == COMPONENT_SLOT_SHADOW && ctx.shadow_showing){
struct wl_region *input_region; struct wl_region *input_region;
Extent2D extent = extent2d_from_component(border_component->type); Extent2D extent = extent2d_from_component_type(border_component->slot);
/* /*
* the input region is the outer surface size minus the inner * the input region is the outer surface size minus the inner
@ -2237,19 +2153,17 @@ static void
draw_border_component(struct border_component *border_component){ draw_border_component(struct border_component *border_component){
struct buffer *old_buffer; struct buffer *old_buffer;
struct buffer *buffer = 0; struct buffer *buffer = 0;
int scale = border_component->scale;
enum component component = border_component->type;
if (border_component->wl_surface != 0){ if (border_component->wl_surface != 0){
Extent2D extent = extent2d_from_component(component); Extent2D extent = extent2d_from_component_type(border_component->slot);
set_component_input_region(border_component); set_component_input_region(border_component);
old_buffer = border_component->buffer; old_buffer = border_component->buffer;
if (old_buffer != 0){ if (old_buffer != 0){
if (!old_buffer->in_use && if (!old_buffer->in_use &&
old_buffer->buffer_width == extent.w*scale && old_buffer->buffer_width == extent.w &&
old_buffer->buffer_height == extent.h*scale){ old_buffer->buffer_height == extent.h){
buffer = old_buffer; buffer = old_buffer;
} }
else{ else{
@ -2268,8 +2182,8 @@ draw_border_component(struct border_component *border_component){
void *data; void *data;
enum wl_shm_format buf_fmt; enum wl_shm_format buf_fmt;
buffer_width = width * scale; buffer_width = width;
buffer_height = height * scale; buffer_height = height;
stride = buffer_width * 4; stride = buffer_width * 4;
size = stride * buffer_height; size = stride * buffer_height;
@ -2292,7 +2206,6 @@ draw_border_component(struct border_component *border_component){
buffer->data_size = size; buffer->data_size = size;
buffer->width = width; buffer->width = width;
buffer->height = height; buffer->height = height;
buffer->scale = scale;
buffer->buffer_width = buffer_width; buffer->buffer_width = buffer_width;
buffer->buffer_height = buffer_height; buffer->buffer_height = buffer_height;
} }
@ -2308,12 +2221,12 @@ draw_border_component(struct border_component *border_component){
cairo_surface_t *surface = cairo_image_surface_create_for_data(buffer->data, CAIRO_FORMAT_ARGB32, cairo_surface_t *surface = cairo_image_surface_create_for_data(buffer->data, CAIRO_FORMAT_ARGB32,
buffer->buffer_width, buffer->buffer_height, stride); buffer->buffer_width, buffer->buffer_height, stride);
cairo_t *cr = cairo_create(surface); cairo_t *cr = cairo_create(surface);
cairo_surface_set_device_scale(surface, buffer->scale, buffer->scale); cairo_surface_set_device_scale(surface, 1, 1);
switch (component) { switch (border_component->slot){
case NONE: break; default: case COMPONENT_SLOT_NONE: break;
case SHADOW: { case COMPONENT_SLOT_SHADOW: {
render_shadow(cr, ctx.shadow_blur, render_shadow(cr, ctx.shadow_blur,
-(int)SHADOW_MARGIN/2, -(int)SHADOW_MARGIN/2, -(int)SHADOW_MARGIN/2, -(int)SHADOW_MARGIN/2,
buffer->width + SHADOW_MARGIN, buffer->height + SHADOW_MARGIN, buffer->width + SHADOW_MARGIN, buffer->height + SHADOW_MARGIN,
@ -2323,7 +2236,7 @@ draw_border_component(struct border_component *border_component){
cairo_fill(cr); cairo_fill(cr);
}break; }break;
case HEADER: { case COMPONENT_SLOT_HEADER: {
/* background */ /* background */
{ {
GtkAllocation allocation; GtkAllocation allocation;
@ -2381,10 +2294,10 @@ draw_border_component(struct border_component *border_component){
} }
wl_surface_attach(border_component->wl_surface, buffer->wl_buffer, 0, 0); wl_surface_attach(border_component->wl_surface, buffer->wl_buffer, 0, 0);
wl_surface_set_buffer_scale(border_component->wl_surface, buffer->scale); wl_surface_set_buffer_scale(border_component->wl_surface, 1);
buffer->in_use = true; buffer->in_use = true;
wl_surface_commit(border_component->wl_surface); wl_surface_commit(border_component->wl_surface);
wl_surface_damage_buffer(border_component->wl_surface, 0, 0, extent.w*scale, extent.h*scale); wl_surface_damage_buffer(border_component->wl_surface, 0, 0, extent.w, extent.h);
wl_subsurface_set_position(border_component->wl_subsurface, extent.x, extent.y); wl_subsurface_set_position(border_component->wl_subsurface, extent.x, extent.y);
border_component->buffer = buffer; border_component->buffer = buffer;
@ -2422,25 +2335,25 @@ draw_title_bar(void){
gtk_header_bar_set_title(GTK_HEADER_BAR(ctx.header), ""); gtk_header_bar_set_title(GTK_HEADER_BAR(ctx.header), "");
gtk_widget_get_preferred_width(ctx.header, NULL, &pref_width); gtk_widget_get_preferred_width(ctx.header, NULL, &pref_width);
gtk_header_bar_set_title(GTK_HEADER_BAR(ctx.header), ctx.title); gtk_header_bar_set_title(GTK_HEADER_BAR(ctx.header), ctx.title);
if (ctx.content_limits.min_width < pref_width){ if (ctx.size_bounds.x[0] < pref_width){
ctx.content_limits.min_width = pref_width; ctx.size_bounds.x[0] = pref_width;
} }
if (ctx.content_limits.max_width != 0 && if (ctx.size_bounds.x[1] != 0 &&
ctx.content_limits.max_width < ctx.content_limits.min_width){ ctx.size_bounds.x[1] < ctx.size_bounds.x[0]){
ctx.content_limits.max_width = ctx.content_limits.min_width; ctx.size_bounds.x[1] = ctx.size_bounds.x[0];
} }
W = ctx.frame_content_width; W = ctx.frame_content_width;
H = ctx.frame_content_height; H = ctx.frame_content_height;
if (W < ctx.content_limits.min_width){ if (W < ctx.size_bounds.x[0]){
W = ctx.content_limits.min_width; W = ctx.size_bounds.x[0];
libdecor_frame_commit(W, H, NULL); libdecor_frame_commit(W, H, NULL);
} }
else{ else{
/* set default height */ /* set default height */
gtk_widget_get_preferred_height(ctx.header, 0, &allocation.height); gtk_widget_get_preferred_height(ctx.header, 0, &allocation.height);
gtk_widget_size_allocate(ctx.header, &allocation); gtk_widget_size_allocate(ctx.header, &allocation);
draw_border_component(&ctx.headerbar); draw_border_component(&ctx.component_slot[COMPONENT_SLOT_HEADER]);
} }
} }
@ -2448,23 +2361,23 @@ static void
draw_decoration(void){ draw_decoration(void){
switch (ctx.decoration_type){ switch (ctx.decoration_type){
case DECORATION_TYPE_NONE: { case DECORATION_TYPE_NONE: {
hide_border_component(&ctx.shadow); hide_border_component(&ctx.component_slot[COMPONENT_SLOT_SHADOW]);
ctx.shadow_showing = false; ctx.shadow_showing = false;
hide_border_component(&ctx.headerbar); hide_border_component(&ctx.component_slot[COMPONENT_SLOT_HEADER]);
}break; }break;
case DECORATION_TYPE_ALL: { case DECORATION_TYPE_ALL: {
ctx.shadow.type = SHADOW; ctx.component_slot[COMPONENT_SLOT_SHADOW].slot = COMPONENT_SLOT_SHADOW;
ctx.shadow.opaque = false; ctx.component_slot[COMPONENT_SLOT_SHADOW].opaque = false;
ensure_component(&ctx.shadow); ensure_component(&ctx.component_slot[COMPONENT_SLOT_SHADOW]);
draw_border_component(&ctx.shadow); draw_border_component(&ctx.component_slot[COMPONENT_SLOT_SHADOW]);
ctx.shadow_showing = true; ctx.shadow_showing = true;
ensure_title_bar_surfaces(); ensure_title_bar_surfaces();
draw_title_bar(); draw_title_bar();
}break; }break;
case DECORATION_TYPE_TITLE_ONLY: { case DECORATION_TYPE_TITLE_ONLY: {
hide_border_component(&ctx.shadow); hide_border_component(&ctx.component_slot[COMPONENT_SLOT_SHADOW]);
ctx.shadow_showing = false; ctx.shadow_showing = false;
ensure_title_bar_surfaces(); ensure_title_bar_surfaces();
draw_title_bar(); draw_title_bar();
@ -2489,7 +2402,7 @@ decoration_type_from_window_state(enum libdecor_window_state window_state){
} }
static void static void
libdecor_plugin_gtk_frame_commit(struct libdecor_state *state, struct libdecor_configuration *configuration){ libdecor_plugin_gtk_frame_commit(void){
enum libdecor_window_state old_window_state; enum libdecor_window_state old_window_state;
enum libdecor_window_state new_window_state; enum libdecor_window_state new_window_state;
int old_content_width, old_content_height; int old_content_width, old_content_height;
@ -2522,63 +2435,24 @@ libdecor_plugin_gtk_frame_commit(struct libdecor_state *state, struct libdecor_c
/* set fixed window size */ /* set fixed window size */
if (!(ctx.frame_capabilities & LIBDECOR_ACTION_RESIZE)){ if (!(ctx.frame_capabilities & LIBDECOR_ACTION_RESIZE)){
ctx.content_limits.min_width = ctx.gtk_content_width; ctx.size_bounds.x[0] = ctx.gtk_content_width;
ctx.content_limits.min_height = ctx.gtk_content_height; ctx.size_bounds.y[0] = ctx.gtk_content_height;
ctx.content_limits.max_width = ctx.gtk_content_width; ctx.size_bounds.x[1] = ctx.gtk_content_width;
ctx.content_limits.max_height = ctx.gtk_content_height; ctx.size_bounds.y[1] = ctx.gtk_content_height;
} }
} }
} }
static void static Bounds2D
update_component_focus(struct wl_surface *surface, struct seat *seat){ border_size_from_window_state(enum libdecor_window_state window_state){
static struct border_component *border_component; Bounds2D border_size = {0};
static struct border_component *child_component;
static struct border_component *focus_component;
border_component = border_component_from_wl_surface(surface);
focus_component = border_component;
wl_list_for_each(child_component, &border_component->child_components, link) {
Extent2D extent = extent2d_from_component(child_component->type);
if (seat->pointer_x >= extent.x && seat->pointer_x < extent.x + extent.w &&
seat->pointer_y >= extent.y && seat->pointer_y < extent.y + extent.h) {
focus_component = child_component;
break;
}
}
if (ctx.grab){
ctx.active = ctx.grab;
}
else{
ctx.active = focus_component;
}
ctx.focus = focus_component;
}
static void
libdecor_plugin_gtk_frame_get_border_size(enum libdecor_window_state window_state,
int *left, int *right, int *top, int *bottom){
if (left){
*left = 0;
}
if (right){
*right = 0;
}
if (bottom){
*bottom = 0;
}
if (top) {
switch (decoration_type_from_window_state(window_state)) { switch (decoration_type_from_window_state(window_state)) {
case DECORATION_TYPE_NONE: { case DECORATION_TYPE_NONE: break;
*top = 0;
}break;
case DECORATION_TYPE_ALL: { case DECORATION_TYPE_ALL: {
ctx.shadow.type = SHADOW; ctx.component_slot[COMPONENT_SLOT_SHADOW].slot = COMPONENT_SLOT_SHADOW;
ctx.shadow.opaque = false; ctx.component_slot[COMPONENT_SLOT_SHADOW].opaque = false;
ensure_component(&ctx.shadow); ensure_component(&ctx.component_slot[COMPONENT_SLOT_SHADOW]);
} G_GNUC_FALLTHROUGH; } G_GNUC_FALLTHROUGH;
case DECORATION_TYPE_TITLE_ONLY: { case DECORATION_TYPE_TITLE_ONLY: {
@ -2586,118 +2460,88 @@ libdecor_plugin_gtk_frame_get_border_size(enum libdecor_window_state window_stat
ensure_title_bar_surfaces(); ensure_title_bar_surfaces();
} }
gtk_widget_show_all(ctx.window); gtk_widget_show_all(ctx.window);
gtk_widget_get_preferred_height(ctx.header, NULL, top); gtk_widget_get_preferred_height(ctx.header, 0, &border_size.y[0]);
}break; }break;
} }
} return(border_size);
} }
enum libdecor_resize_edge enum libdecor_resize_edge
component_edge(const struct border_component *cmpnt, component_edge(enum component_slot slot, int x, int y){
const int pointer_x, const int pointer_y, static const enum libdecor_resize_edge box[9] = {
const int margin){ LIBDECOR_RESIZE_EDGE_TOP_LEFT , LIBDECOR_RESIZE_EDGE_TOP , LIBDECOR_RESIZE_EDGE_TOP_RIGHT ,
const bool top = pointer_y < margin * 2; LIBDECOR_RESIZE_EDGE_LEFT, LIBDECOR_RESIZE_EDGE_NONE , LIBDECOR_RESIZE_EDGE_RIGHT ,
const bool bottom = pointer_y > (cmpnt->buffer->height - margin * 2); LIBDECOR_RESIZE_EDGE_BOTTOM_LEFT, LIBDECOR_RESIZE_EDGE_BOTTOM, LIBDECOR_RESIZE_EDGE_BOTTOM_RIGHT,
const bool left = pointer_x < margin * 2; };
const bool right = pointer_x > (cmpnt->buffer->width - margin * 2);
if (top){ enum libdecor_resize_edge result = 0;
if (left) struct buffer *buffer = 0;
return LIBDECOR_RESIZE_EDGE_TOP_LEFT;
else if (right) if (slot < COMPONENT_SLOT_COUNT){
return LIBDECOR_RESIZE_EDGE_TOP_RIGHT; buffer = ctx.component_slot[slot].buffer;
else
return LIBDECOR_RESIZE_EDGE_TOP;
}
else if (bottom){
if (left)
return LIBDECOR_RESIZE_EDGE_BOTTOM_LEFT;
else if (right)
return LIBDECOR_RESIZE_EDGE_BOTTOM_RIGHT;
else
return LIBDECOR_RESIZE_EDGE_BOTTOM;
}
else if (left){
return LIBDECOR_RESIZE_EDGE_LEFT;
}
else if (right){
return LIBDECOR_RESIZE_EDGE_RIGHT;
}
else{
return LIBDECOR_RESIZE_EDGE_NONE;
}
} }
static bool if (buffer != 0){
update_local_cursor(struct seat *seat){ int w = buffer->width;
bool result = false; int h = buffer->height;
if (seat->pointer_focus == 0){ int top = (y < 2*SHADOW_MARGIN);
seat->current_cursor = seat->cursor_left_ptr; int bottom = (!top && y > (w - 2*SHADOW_MARGIN));
} int left = (x < 2*SHADOW_MARGIN);
else{ int right = (!left && x > (h - 2*SHADOW_MARGIN));
if (own_proxy(seat->pointer_focus)){
if (!ctx.active){
seat->current_cursor = seat->cursor_left_ptr;
}
else{
bool theme_updated = false;
{
int scale = 1;
if (seat->cursor_theme == 0 || seat->cursor_scale != scale){
struct wl_cursor_theme *theme;
seat->cursor_scale = scale; int i = 4 + 3*(bottom - top) + (right - left);
theme = wl_cursor_theme_load(ctx.cursor_theme_name, ctx.cursor_size*scale, ctx.wl_shm); result = box[i];
if (theme != 0){
if (seat->cursor_theme){
wl_cursor_theme_destroy(seat->cursor_theme);
}
seat->cursor_theme = theme;
for (unsigned int i = 0; i < ARRAY_LENGTH(cursor_names); i++) {
seat->cursors[i] = wl_cursor_theme_get_cursor(seat->cursor_theme, cursor_names[i]);
}
seat->cursor_left_ptr = wl_cursor_theme_get_cursor(seat->cursor_theme, "left_ptr");
seat->current_cursor = seat->cursor_left_ptr;
theme_updated = true;
}
}
}
struct wl_cursor *wl_cursor = NULL;
if (ctx.active->type == SHADOW && ctx.shadow_showing &&
(ctx.frame_capabilities & LIBDECOR_ACTION_RESIZE)){
enum libdecor_resize_edge edge;
edge = component_edge(ctx.active, seat->pointer_x, seat->pointer_y, SHADOW_MARGIN);
if (edge != LIBDECOR_RESIZE_EDGE_NONE){
wl_cursor = seat->cursors[edge - 1];
}
}
else{
wl_cursor = seat->cursor_left_ptr;
}
if (seat->current_cursor != wl_cursor) {
seat->current_cursor = wl_cursor;
result = true;
}
else{
result = theme_updated;
}
}
}
} }
return(result); return(result);
} }
static bool
update_local_cursor(struct seat *seat){
bool cursor_updated = false;
seat->current_cursor = seat->cursor_left_ptr;
if (own_proxy(seat->pointer_focus)){
if (ctx.active != 0){
if (seat->cursor_theme == 0){
struct wl_cursor_theme *theme = wl_cursor_theme_load(ctx.cursor_theme_name, ctx.cursor_size, ctx.wl_shm);
if (theme != 0){
seat->cursor_theme = theme;
for (unsigned int i = 0; i < ARRAY_LENGTH(cursor_names); i += 1){
seat->cursors[i] = wl_cursor_theme_get_cursor(theme, cursor_names[i]);
}
seat->cursor_left_ptr = wl_cursor_theme_get_cursor(seat->cursor_theme, "left_ptr");
seat->current_cursor = seat->cursor_left_ptr;
cursor_updated = true;
}
}
struct wl_cursor *wl_cursor = seat->cursor_left_ptr;
if (ctx.active == COMPONENT_SLOT_SHADOW &&
(ctx.frame_capabilities & LIBDECOR_ACTION_RESIZE)){
enum libdecor_resize_edge edge = component_edge(COMPONENT_SLOT_SHADOW, seat->pointer_x, seat->pointer_y);
if (edge != LIBDECOR_RESIZE_EDGE_NONE){
wl_cursor = seat->cursors[edge - 1];
}
}
if (seat->current_cursor != wl_cursor) {
seat->current_cursor = wl_cursor;
cursor_updated = true;
}
}
}
return(cursor_updated);
}
static void static void
update_touch_focus(struct seat *seat, wl_fixed_t x, wl_fixed_t y){ update_touch_focus(struct seat *seat, wl_fixed_t x, wl_fixed_t y){
if (GTK_IS_WIDGET(ctx.header) && ctx.touch_active->type == HEADER){ if (GTK_IS_WIDGET(ctx.header) && ctx.touch_active == COMPONENT_SLOT_HEADER){
struct header_element_data new_focus = get_header_focus(GTK_HEADER_BAR(ctx.header), wl_fixed_to_int(x), wl_fixed_to_int(y)); struct header_element_data new_focus = get_header_focus(GTK_HEADER_BAR(ctx.header), wl_fixed_to_int(x), wl_fixed_to_int(y));
if (ctx.hdr_focus.widget != new_focus.widget){ if (ctx.hdr_focus.widget != new_focus.widget){
ctx.hdr_focus = new_focus; ctx.hdr_focus = new_focus;

72
digesting_libdecor.h
View File

@ -59,6 +59,11 @@ typedef struct Extent2D{
int h; int h;
} Extent2D; } Extent2D;
typedef struct Bounds2D{
int x[2];
int y[2];
} Bounds2D;
// libdecor.h // libdecor.h
struct libdecor_configuration; struct libdecor_configuration;
@ -122,13 +127,6 @@ enum libdecor_wm_capabilities {
// libdecor-plugin.h // libdecor-plugin.h
struct libdecor_limits {
int min_width;
int min_height;
int max_width;
int max_height;
};
enum header_element { enum header_element {
HEADER_NONE, HEADER_NONE,
HEADER_FULL, /* entire header bar */ HEADER_FULL, /* entire header bar */
@ -159,22 +157,19 @@ enum decoration_type {
DECORATION_TYPE_TITLE_ONLY DECORATION_TYPE_TITLE_ONLY
}; };
enum component { enum component_slot {
NONE = 0, COMPONENT_SLOT_NONE,
SHADOW, COMPONENT_SLOT_SHADOW,
HEADER, COMPONENT_SLOT_HEADER,
COMPONENT_SLOT_COUNT
}; };
struct border_component { struct border_component {
enum component type; enum component_slot slot;
struct wl_surface *wl_surface; struct wl_surface *wl_surface;
struct wl_subsurface *wl_subsurface; struct wl_subsurface *wl_subsurface;
struct buffer *buffer; struct buffer *buffer;
bool opaque; bool opaque;
int scale;
struct wl_list child_components; /* border_component::link */
struct wl_list link; /* border_component::child_components */
}; };
// #include "libdecor.c" // #include "libdecor.c"
@ -228,7 +223,6 @@ struct seat {
struct wl_surface *cursor_surface; struct wl_surface *cursor_surface;
struct wl_cursor *current_cursor; struct wl_cursor *current_cursor;
int cursor_scale;
struct wl_cursor_theme *cursor_theme; struct wl_cursor_theme *cursor_theme;
/* cursors for resize edges and corners */ /* cursors for resize edges and corners */
@ -259,7 +253,6 @@ struct buffer {
size_t data_size; size_t data_size;
int width; int width;
int height; int height;
int scale;
int buffer_width; int buffer_width;
int buffer_height; int buffer_height;
}; };
@ -275,14 +268,9 @@ enum titlebar_gesture {
void libdecor_frame_set_visibility(bool visible); void libdecor_frame_set_visibility(bool visible);
void libdecor_frame_show_window_menu(struct wl_seat *wl_seat, uint32_t serial, int x, int y); void libdecor_frame_show_window_menu(struct wl_seat *wl_seat, uint32_t serial, int x, int y);
void libdecor_frame_translate_coordinate(int surface_x, int surface_y, int *frame_x, int *frame_y);
void libdecor_frame_resize(struct wl_seat *wl_seat, uint32_t serial, enum libdecor_resize_edge edge);
void libdecor_frame_move(struct wl_seat *wl_seat, uint32_t serial);
void libdecor_frame_commit(int w, int h, struct libdecor_configuration *configuration); void libdecor_frame_commit(int w, int h, struct libdecor_configuration *configuration);
void libdecor_frame_set_fullscreen(struct wl_output *output); void libdecor_frame_set_fullscreen(struct wl_output *output);
void libdecor_frame_unset_fullscreen(void); void libdecor_frame_unset_fullscreen(void);
void libdecor_frame_map(void);
bool libdecor_configuration_get_content_size(struct libdecor_configuration *configuration, int *width, int *height); bool libdecor_configuration_get_content_size(struct libdecor_configuration *configuration, int *width, int *height);
@ -313,24 +301,25 @@ static void do_map(void);
static const char *libdecor_gtk_proxy_tag = "libdecor-gtk"; static const char *libdecor_gtk_proxy_tag = "libdecor-gtk";
static void libdecor_plugin_gtk_frame_free(void); static void libdecor_plugin_gtk_frame_free(void);
static void libdecor_plugin_gtk_frame_commit(struct libdecor_state *state, struct libdecor_configuration *configuration); static void libdecor_plugin_gtk_frame_commit(void);
static void libdecor_plugin_gtk_frame_get_border_size(enum libdecor_window_state window_state, int *left, int *right, int *top, int *bottom); static Bounds2D border_size_from_window_state(enum libdecor_window_state window_state);
static bool update_local_cursor(struct seat *seat); static bool update_local_cursor(struct seat *seat);
static void draw_decoration(void); static void draw_decoration(void);
static void draw_header_button(cairo_t *cr, cairo_surface_t *surface, enum header_element button_type); static void draw_header_button(cairo_t *cr, cairo_surface_t *surface, enum header_element button_type);
static void redraw_scale(struct border_component *cmpnt);
static void buffer_free(struct buffer *buffer); static void buffer_free(struct buffer *buffer);
static void draw_border_component(struct border_component *border_component); static void draw_border_component(struct border_component *border_component);
static bool own_proxy(void *proxy); static bool own_proxy(void *proxy);
static struct border_component * border_component_from_wl_surface(const struct wl_surface *surface); static enum component_slot component_slot_from_wl_surface(const struct wl_surface *surface);
static struct header_element_data get_header_focus(const GtkHeaderBar *header_bar, const int x, const int y); static struct header_element_data get_header_focus(const GtkHeaderBar *header_bar, const int x, const int y);
static void draw_title_bar(void); static void draw_title_bar(void);
enum libdecor_resize_edge component_edge(const struct border_component *cmpnt, const int pointer_x, const int pointer_y, const int margin); enum libdecor_resize_edge component_edge(const enum component_slot slot, const int pointer_x, const int pointer_y);
static void toggle_maximized(void); static void toggle_maximized(void);
static void update_touch_focus(struct seat *seat, wl_fixed_t x, wl_fixed_t y); static void update_touch_focus(struct seat *seat, wl_fixed_t x, wl_fixed_t y);
static enum xdg_toplevel_resize_edge xdg_edge_from_edge(enum libdecor_resize_edge edge);
// digesting_libdecor // digesting_libdecor
typedef struct Ctx{ typedef struct Ctx{
@ -375,7 +364,7 @@ typedef struct Ctx{
//struct libdecor_frame_private; //struct libdecor_frame_private;
char *title; char *title;
struct libdecor_limits content_limits; Bounds2D size_bounds;
struct xdg_toplevel *parent; struct xdg_toplevel *parent;
struct libdecor_configuration *pending_configuration; struct libdecor_configuration *pending_configuration;
@ -391,8 +380,6 @@ typedef struct Ctx{
enum libdecor_capabilities frame_capabilities; enum libdecor_capabilities frame_capabilities;
enum libdecor_wm_capabilities wm_capabilities; enum libdecor_wm_capabilities wm_capabilities;
/* original limits for interactive resize */
struct libdecor_limits interactive_limits;
bool visible; bool visible;
//struct libdecor_frame_gtk; //struct libdecor_frame_gtk;
@ -405,20 +392,17 @@ typedef struct Ctx{
enum libdecor_capabilities gtk_capabilities; enum libdecor_capabilities gtk_capabilities;
struct border_component *active; enum component_slot active;
struct border_component *touch_active; enum component_slot touch_active;
struct border_component *focus; enum component_slot focus;
struct border_component *grab; enum component_slot grab;
struct border_component component_slot[COMPONENT_SLOT_COUNT];
bool shadow_showing; bool shadow_showing;
struct border_component shadow; GtkWidget *window;
GtkWidget *header;
GtkWidget *window; /* offscreen window for rendering */
GtkWidget *header; /* header bar with widgets */
struct border_component headerbar;
struct header_element_data hdr_focus; struct header_element_data hdr_focus;
/* store pre-processed shadow tile */
cairo_surface_t *shadow_blur; cairo_surface_t *shadow_blur;
struct { struct {
@ -426,9 +410,9 @@ typedef struct Ctx{
int button_pressed_count; int button_pressed_count;
uint32_t first_pressed_button; uint32_t first_pressed_button;
uint32_t first_pressed_time; uint32_t first_pressed_time;
double pressed_x; int pressed_x;
double pressed_y; int pressed_y;
uint32_t pressed_serial; uint32_t serial;
} titlebar_gesture; } titlebar_gesture;
} Ctx; } Ctx;