470 lines
14 KiB
C
470 lines
14 KiB
C
|
/*
|
||
|
|
* bluroverlay.c
|
||
|
|
* This file is part of gtk
|
||
|
|
*
|
||
|
|
* Copyright (C) 2011 - Ignacio Casal Quinteiro, Mike Krüger
|
||
|
|
*
|
||
|
|
* This library is free software; you can redistribute it and/or
|
||
|
|
* modify it under the terms of the GNU Lesser General Public
|
||
|
|
* License as published by the Free Software Foundation; either
|
||
|
|
* version 2 of the License, or (at your option) any later version.
|
||
|
|
*
|
||
|
|
* This library is distributed in the hope that it will be useful,
|
||
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
|
|
* Lesser General Public License for more details.
|
||
|
|
*
|
||
|
|
* You should have received a copy of the GNU Lesser General Public
|
||
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "bluroverlay.h"
|
||
|
|
|
||
|
|
/*
|
||
|
|
* This is a cut-down copy of gtkoverlay.c with a custom snapshot
|
||
|
|
* function that support a limited form of blur-under.
|
||
|
|
*/
|
||
|
|
typedef struct _BlurOverlayChild BlurOverlayChild;
|
||
|
|
|
||
|
|
struct _BlurOverlayChild
|
||
|
|
{
|
||
|
|
double blur;
|
||
|
|
};
|
||
|
|
|
||
|
|
enum {
|
||
|
|
GET_CHILD_POSITION,
|
||
|
|
LAST_SIGNAL
|
||
|
|
};
|
||
|
|
|
||
|
|
static guint signals[LAST_SIGNAL] = { 0 };
|
||
|
|
static GQuark child_data_quark = 0;
|
||
|
|
|
||
|
|
G_DEFINE_TYPE (BlurOverlay, blur_overlay, GTK_TYPE_WIDGET)
|
||
|
|
|
||
|
|
static void
|
||
|
|
blur_overlay_set_overlay_child (GtkWidget *widget,
|
||
|
|
BlurOverlayChild *child_data)
|
||
|
|
{
|
||
|
|
g_object_set_qdata_full (G_OBJECT (widget), child_data_quark, child_data, g_free);
|
||
|
|
}
|
||
|
|
|
||
|
|
static BlurOverlayChild *
|
||
|
|
blur_overlay_get_overlay_child (GtkWidget *widget)
|
||
|
|
{
|
||
|
|
return (BlurOverlayChild *) g_object_get_qdata (G_OBJECT (widget), child_data_quark);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
blur_overlay_measure (GtkWidget *widget,
|
||
|
|
GtkOrientation orientation,
|
||
|
|
int for_size,
|
||
|
|
int *minimum,
|
||
|
|
int *natural,
|
||
|
|
int *minimum_baseline,
|
||
|
|
int *natural_baseline)
|
||
|
|
{
|
||
|
|
GtkWidget *child;
|
||
|
|
|
||
|
|
for (child = gtk_widget_get_first_child (widget);
|
||
|
|
child != NULL;
|
||
|
|
child = gtk_widget_get_next_sibling (child))
|
||
|
|
{
|
||
|
|
int child_min, child_nat, child_min_baseline, child_nat_baseline;
|
||
|
|
|
||
|
|
gtk_widget_measure (child,
|
||
|
|
orientation,
|
||
|
|
for_size,
|
||
|
|
&child_min, &child_nat,
|
||
|
|
&child_min_baseline, &child_nat_baseline);
|
||
|
|
|
||
|
|
*minimum = MAX (*minimum, child_min);
|
||
|
|
*natural = MAX (*natural, child_nat);
|
||
|
|
if (child_min_baseline > -1)
|
||
|
|
*minimum_baseline = MAX (*minimum_baseline, child_min_baseline);
|
||
|
|
if (child_nat_baseline > -1)
|
||
|
|
*natural_baseline = MAX (*natural_baseline, child_nat_baseline);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
blur_overlay_compute_child_allocation (BlurOverlay *overlay,
|
||
|
|
GtkWidget *widget,
|
||
|
|
BlurOverlayChild *child,
|
||
|
|
GtkAllocation *widget_allocation)
|
||
|
|
{
|
||
|
|
GtkAllocation allocation;
|
||
|
|
gboolean result;
|
||
|
|
|
||
|
|
g_signal_emit (overlay, signals[GET_CHILD_POSITION],
|
||
|
|
0, widget, &allocation, &result);
|
||
|
|
|
||
|
|
widget_allocation->x = allocation.x;
|
||
|
|
widget_allocation->y = allocation.y;
|
||
|
|
widget_allocation->width = allocation.width;
|
||
|
|
widget_allocation->height = allocation.height;
|
||
|
|
}
|
||
|
|
|
||
|
|
static GtkAlign
|
||
|
|
effective_align (GtkAlign align,
|
||
|
|
GtkTextDirection direction)
|
||
|
|
{
|
||
|
|
switch (align)
|
||
|
|
{
|
||
|
|
case GTK_ALIGN_START:
|
||
|
|
return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_END : GTK_ALIGN_START;
|
||
|
|
case GTK_ALIGN_END:
|
||
|
|
return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_START : GTK_ALIGN_END;
|
||
|
|
case GTK_ALIGN_FILL:
|
||
|
|
case GTK_ALIGN_CENTER:
|
||
|
|
case GTK_ALIGN_BASELINE_FILL:
|
||
|
|
case GTK_ALIGN_BASELINE_CENTER:
|
||
|
|
default:
|
||
|
|
return align;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
blur_overlay_child_update_style_classes (BlurOverlay *overlay,
|
||
|
|
GtkWidget *child,
|
||
|
|
GtkAllocation *child_allocation)
|
||
|
|
{
|
||
|
|
int width, height;
|
||
|
|
GtkAlign valign, halign;
|
||
|
|
gboolean is_left, is_right, is_top, is_bottom;
|
||
|
|
gboolean has_left, has_right, has_top, has_bottom;
|
||
|
|
|
||
|
|
has_left = gtk_widget_has_css_class (child, "left");
|
||
|
|
has_right = gtk_widget_has_css_class (child, "right");
|
||
|
|
has_top = gtk_widget_has_css_class (child, "top");
|
||
|
|
has_bottom = gtk_widget_has_css_class (child, "bottom");
|
||
|
|
|
||
|
|
is_left = is_right = is_top = is_bottom = FALSE;
|
||
|
|
|
||
|
|
width = gtk_widget_get_width (GTK_WIDGET (overlay));
|
||
|
|
height = gtk_widget_get_height (GTK_WIDGET (overlay));
|
||
|
|
|
||
|
|
halign = effective_align (gtk_widget_get_halign (child),
|
||
|
|
gtk_widget_get_direction (child));
|
||
|
|
|
||
|
|
if (halign == GTK_ALIGN_START)
|
||
|
|
is_left = (child_allocation->x == 0);
|
||
|
|
else if (halign == GTK_ALIGN_END)
|
||
|
|
is_right = (child_allocation->x + child_allocation->width == width);
|
||
|
|
|
||
|
|
valign = gtk_widget_get_valign (child);
|
||
|
|
|
||
|
|
if (valign == GTK_ALIGN_START)
|
||
|
|
is_top = (child_allocation->y == 0);
|
||
|
|
else if (valign == GTK_ALIGN_END)
|
||
|
|
is_bottom = (child_allocation->y + child_allocation->height == height);
|
||
|
|
|
||
|
|
if (has_left && !is_left)
|
||
|
|
gtk_widget_remove_css_class (child, "left");
|
||
|
|
else if (!has_left && is_left)
|
||
|
|
gtk_widget_add_css_class (child, "left");
|
||
|
|
|
||
|
|
if (has_right && !is_right)
|
||
|
|
gtk_widget_remove_css_class (child, "right");
|
||
|
|
else if (!has_right && is_right)
|
||
|
|
gtk_widget_add_css_class (child, "right");
|
||
|
|
|
||
|
|
if (has_top && !is_top)
|
||
|
|
gtk_widget_remove_css_class (child, "top");
|
||
|
|
else if (!has_top && is_top)
|
||
|
|
gtk_widget_add_css_class (child, "top");
|
||
|
|
|
||
|
|
if (has_bottom && !is_bottom)
|
||
|
|
gtk_widget_remove_css_class (child, "bottom");
|
||
|
|
else if (!has_bottom && is_bottom)
|
||
|
|
gtk_widget_add_css_class (child, "bottom");
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
blur_overlay_child_allocate (BlurOverlay *overlay,
|
||
|
|
GtkWidget *widget,
|
||
|
|
BlurOverlayChild *child)
|
||
|
|
{
|
||
|
|
GtkAllocation child_allocation;
|
||
|
|
|
||
|
|
if (!gtk_widget_get_visible (widget))
|
||
|
|
return;
|
||
|
|
|
||
|
|
blur_overlay_compute_child_allocation (overlay, widget, child, &child_allocation);
|
||
|
|
|
||
|
|
blur_overlay_child_update_style_classes (overlay, widget, &child_allocation);
|
||
|
|
gtk_widget_size_allocate (widget, &child_allocation, -1);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
blur_overlay_size_allocate (GtkWidget *widget,
|
||
|
|
int width,
|
||
|
|
int height,
|
||
|
|
int baseline)
|
||
|
|
{
|
||
|
|
BlurOverlay *overlay = BLUR_OVERLAY (widget);
|
||
|
|
GtkWidget *child;
|
||
|
|
GtkWidget *main_widget;
|
||
|
|
|
||
|
|
main_widget = overlay->main_widget;
|
||
|
|
if (main_widget && gtk_widget_get_visible (main_widget))
|
||
|
|
gtk_widget_size_allocate (main_widget,
|
||
|
|
&(GtkAllocation) {
|
||
|
|
0, 0,
|
||
|
|
width, height
|
||
|
|
}, -1);
|
||
|
|
|
||
|
|
for (child = gtk_widget_get_first_child (widget);
|
||
|
|
child != NULL;
|
||
|
|
child = gtk_widget_get_next_sibling (child))
|
||
|
|
{
|
||
|
|
if (child != main_widget)
|
||
|
|
{
|
||
|
|
BlurOverlayChild *child_data = blur_overlay_get_overlay_child (child);
|
||
|
|
blur_overlay_child_allocate (overlay, child, child_data);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static gboolean
|
||
|
|
blur_overlay_get_child_position (BlurOverlay *overlay,
|
||
|
|
GtkWidget *widget,
|
||
|
|
GtkAllocation *alloc)
|
||
|
|
{
|
||
|
|
GtkRequisition min, req;
|
||
|
|
GtkAlign halign;
|
||
|
|
GtkTextDirection direction;
|
||
|
|
int width, height;
|
||
|
|
|
||
|
|
gtk_widget_get_preferred_size (widget, &min, &req);
|
||
|
|
width = gtk_widget_get_width (GTK_WIDGET (overlay));
|
||
|
|
height = gtk_widget_get_height (GTK_WIDGET (overlay));
|
||
|
|
|
||
|
|
alloc->x = 0;
|
||
|
|
alloc->width = MAX (min.width, MIN (width, req.width));
|
||
|
|
|
||
|
|
direction = gtk_widget_get_direction (widget);
|
||
|
|
|
||
|
|
halign = gtk_widget_get_halign (widget);
|
||
|
|
switch (effective_align (halign, direction))
|
||
|
|
{
|
||
|
|
case GTK_ALIGN_START:
|
||
|
|
/* nothing to do */
|
||
|
|
break;
|
||
|
|
case GTK_ALIGN_FILL:
|
||
|
|
alloc->width = MAX (alloc->width, width);
|
||
|
|
break;
|
||
|
|
case GTK_ALIGN_CENTER:
|
||
|
|
alloc->x += width / 2 - alloc->width / 2;
|
||
|
|
break;
|
||
|
|
case GTK_ALIGN_END:
|
||
|
|
alloc->x += width - alloc->width;
|
||
|
|
break;
|
||
|
|
case GTK_ALIGN_BASELINE_FILL:
|
||
|
|
case GTK_ALIGN_BASELINE_CENTER:
|
||
|
|
default:
|
||
|
|
g_assert_not_reached ();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
alloc->y = 0;
|
||
|
|
alloc->height = MAX (min.height, MIN (height, req.height));
|
||
|
|
|
||
|
|
switch (gtk_widget_get_valign (widget))
|
||
|
|
{
|
||
|
|
case GTK_ALIGN_START:
|
||
|
|
/* nothing to do */
|
||
|
|
break;
|
||
|
|
case GTK_ALIGN_FILL:
|
||
|
|
alloc->height = MAX (alloc->height, height);
|
||
|
|
break;
|
||
|
|
case GTK_ALIGN_CENTER:
|
||
|
|
alloc->y += height / 2 - alloc->height / 2;
|
||
|
|
break;
|
||
|
|
case GTK_ALIGN_END:
|
||
|
|
alloc->y += height - alloc->height;
|
||
|
|
break;
|
||
|
|
case GTK_ALIGN_BASELINE_FILL:
|
||
|
|
case GTK_ALIGN_BASELINE_CENTER:
|
||
|
|
default:
|
||
|
|
g_assert_not_reached ();
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
blur_overlay_snapshot (GtkWidget *widget,
|
||
|
|
GtkSnapshot *snapshot)
|
||
|
|
{
|
||
|
|
GtkWidget *main_widget;
|
||
|
|
GskRenderNode *main_widget_node = NULL;
|
||
|
|
GtkWidget *child;
|
||
|
|
int width, height;
|
||
|
|
cairo_region_t *clip = NULL;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
main_widget = BLUR_OVERLAY (widget)->main_widget;
|
||
|
|
width = gtk_widget_get_width (widget);
|
||
|
|
height = gtk_widget_get_height (widget);
|
||
|
|
|
||
|
|
for (child = gtk_widget_get_first_child (widget);
|
||
|
|
child != NULL;
|
||
|
|
child = gtk_widget_get_next_sibling (child))
|
||
|
|
{
|
||
|
|
BlurOverlayChild *child_info = blur_overlay_get_overlay_child (child);
|
||
|
|
double blur = 0;
|
||
|
|
if (child_info)
|
||
|
|
blur = child_info->blur;
|
||
|
|
|
||
|
|
if (blur > 0)
|
||
|
|
{
|
||
|
|
cairo_rectangle_int_t rect;
|
||
|
|
graphene_rect_t bounds;
|
||
|
|
|
||
|
|
if (main_widget_node == NULL)
|
||
|
|
{
|
||
|
|
GtkSnapshot *child_snapshot;
|
||
|
|
|
||
|
|
child_snapshot = gtk_snapshot_new ();
|
||
|
|
gtk_widget_snapshot_child (widget, main_widget, child_snapshot);
|
||
|
|
main_widget_node = gtk_snapshot_free_to_node (child_snapshot);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!gtk_widget_compute_bounds (child, gtk_widget_get_parent (child), &bounds))
|
||
|
|
graphene_rect_init (&bounds, 0, 0, 0, 0);
|
||
|
|
gtk_snapshot_push_blur (snapshot, blur);
|
||
|
|
gtk_snapshot_push_clip (snapshot, &bounds);
|
||
|
|
gtk_snapshot_append_node (snapshot, main_widget_node);
|
||
|
|
gtk_snapshot_pop (snapshot);
|
||
|
|
gtk_snapshot_pop (snapshot);
|
||
|
|
|
||
|
|
if (clip == NULL)
|
||
|
|
{
|
||
|
|
rect.x = rect.y = 0;
|
||
|
|
rect.width = width;
|
||
|
|
rect.height = height;
|
||
|
|
clip = cairo_region_create_rectangle (&rect);
|
||
|
|
}
|
||
|
|
|
||
|
|
rect.x = floor (bounds.origin.x);
|
||
|
|
rect.y = floor (bounds.origin.y);
|
||
|
|
rect.width = ceil (bounds.origin.x + bounds.size.width - rect.x);
|
||
|
|
rect.height = ceil (bounds.origin.y + bounds.size.height - rect.y);
|
||
|
|
cairo_region_subtract_rectangle (clip, &rect);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (clip == NULL)
|
||
|
|
{
|
||
|
|
for (child = gtk_widget_get_first_child (widget);
|
||
|
|
child != NULL;
|
||
|
|
child = gtk_widget_get_next_sibling (child))
|
||
|
|
{
|
||
|
|
gtk_widget_snapshot_child (widget, child, snapshot);
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = 0; i < cairo_region_num_rectangles (clip); i++)
|
||
|
|
{
|
||
|
|
cairo_rectangle_int_t rect;
|
||
|
|
graphene_rect_t bounds;
|
||
|
|
|
||
|
|
cairo_region_get_rectangle (clip, i, &rect);
|
||
|
|
graphene_rect_init (&bounds, rect.x, rect.y, rect.width, rect.height);
|
||
|
|
gtk_snapshot_push_clip (snapshot, &bounds);
|
||
|
|
gtk_snapshot_append_node (snapshot, main_widget_node);
|
||
|
|
gtk_snapshot_pop (snapshot);
|
||
|
|
}
|
||
|
|
|
||
|
|
cairo_region_destroy (clip);
|
||
|
|
|
||
|
|
for (child = gtk_widget_get_first_child (widget);
|
||
|
|
child != NULL;
|
||
|
|
child = gtk_widget_get_next_sibling (child))
|
||
|
|
{
|
||
|
|
if (child != main_widget)
|
||
|
|
gtk_widget_snapshot_child (widget, child, snapshot);
|
||
|
|
}
|
||
|
|
|
||
|
|
gsk_render_node_unref (main_widget_node);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
blur_overlay_dispose (GObject *object)
|
||
|
|
{
|
||
|
|
BlurOverlay *overlay = BLUR_OVERLAY (object);
|
||
|
|
GtkWidget *child;
|
||
|
|
|
||
|
|
g_clear_pointer (&overlay->main_widget, gtk_widget_unparent);
|
||
|
|
|
||
|
|
while ((child = gtk_widget_get_first_child (GTK_WIDGET (overlay))))
|
||
|
|
gtk_widget_unparent (child);
|
||
|
|
|
||
|
|
G_OBJECT_CLASS (blur_overlay_parent_class)->dispose (object);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
blur_overlay_class_init (BlurOverlayClass *klass)
|
||
|
|
{
|
||
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
||
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
|
||
|
|
|
||
|
|
object_class->dispose = blur_overlay_dispose;
|
||
|
|
|
||
|
|
widget_class->measure = blur_overlay_measure;
|
||
|
|
widget_class->size_allocate = blur_overlay_size_allocate;
|
||
|
|
widget_class->snapshot = blur_overlay_snapshot;
|
||
|
|
|
||
|
|
klass->get_child_position = blur_overlay_get_child_position;
|
||
|
|
|
||
|
|
signals[GET_CHILD_POSITION] =
|
||
|
|
g_signal_new ("get-child-position",
|
||
|
|
G_TYPE_FROM_CLASS (object_class),
|
||
|
|
G_SIGNAL_RUN_LAST,
|
||
|
|
G_STRUCT_OFFSET (BlurOverlayClass, get_child_position),
|
||
|
|
g_signal_accumulator_true_handled, NULL,
|
||
|
|
NULL,
|
||
|
|
G_TYPE_BOOLEAN, 2,
|
||
|
|
GTK_TYPE_WIDGET,
|
||
|
|
GDK_TYPE_RECTANGLE | G_SIGNAL_TYPE_STATIC_SCOPE);
|
||
|
|
|
||
|
|
child_data_quark = g_quark_from_static_string ("gtk-overlay-child-data");
|
||
|
|
|
||
|
|
gtk_widget_class_set_css_name (widget_class, "overlay");
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
blur_overlay_init (BlurOverlay *overlay)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
GtkWidget *
|
||
|
|
blur_overlay_new (void)
|
||
|
|
{
|
||
|
|
return g_object_new (BLUR_TYPE_OVERLAY, NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
blur_overlay_add_overlay (BlurOverlay *overlay,
|
||
|
|
GtkWidget *widget,
|
||
|
|
double blur)
|
||
|
|
{
|
||
|
|
BlurOverlayChild *child = g_new0 (BlurOverlayChild, 1);
|
||
|
|
|
||
|
|
gtk_widget_insert_before (widget, GTK_WIDGET (overlay), NULL);
|
||
|
|
|
||
|
|
child->blur = blur;
|
||
|
|
|
||
|
|
blur_overlay_set_overlay_child (widget, child);
|
||
|
|
}
|
||
|
|
|
||
|
|
void
|
||
|
|
blur_overlay_set_child (BlurOverlay *overlay,
|
||
|
|
GtkWidget *widget)
|
||
|
|
{
|
||
|
|
gtk_widget_insert_after (widget, GTK_WIDGET (overlay), NULL);
|
||
|
|
overlay->main_widget = widget;
|
||
|
|
}
|