forked from AuroraMiddleware/gtk
d9c9259861
It doesn't make sense to keep them separate as GtkSizeRequest requires a GtkWidget and GtkWidget implements GtkSizeRequest, so you can never have one without the other. It also makes the code a lot easier because no casts are required when calling functions. Also, the names would translate to gtk_widget_get_width() and people agreed that this would be a too generic name, so a "preferred" was added to the names. So this patch moves the functions: gtk_size_request_get_request_mode() => gtk_widget_get_request_mode() gtk_size_request_get_width() => gtk_widget_get_preferred_width() gtk_size_request_get_height() => gtk_widget_get_preferred_height() gtk_size_request_get_size() => gtk_widget_get_preferred_size() gtk_size_request_get_width_for_height() => gtk_widget_get_preferred_width_for_height() gtk_size_request_get_height_for_width() => gtk_widget_get_preferred_height_for_width() ... and moves the corresponding vfuncs to the GtkWidgetClass. The patch also renames the implementations of the vfuncs in widgets to include the word "preferrred".
501 lines
16 KiB
C
501 lines
16 KiB
C
/* Offscreen windows/Effects
|
|
*
|
|
* Offscreen windows can be used to render elements multiple times to achieve
|
|
* various effects.
|
|
*/
|
|
#include <gtk/gtk.h>
|
|
|
|
#define GTK_TYPE_MIRROR_BIN (gtk_mirror_bin_get_type ())
|
|
#define GTK_MIRROR_BIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MIRROR_BIN, GtkMirrorBin))
|
|
#define GTK_MIRROR_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MIRROR_BIN, GtkMirrorBinClass))
|
|
#define GTK_IS_MIRROR_BIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MIRROR_BIN))
|
|
#define GTK_IS_MIRROR_BIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MIRROR_BIN))
|
|
#define GTK_MIRROR_BIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MIRROR_BIN, GtkMirrorBinClass))
|
|
|
|
typedef struct _GtkMirrorBin GtkMirrorBin;
|
|
typedef struct _GtkMirrorBinClass GtkMirrorBinClass;
|
|
|
|
struct _GtkMirrorBin
|
|
{
|
|
GtkContainer container;
|
|
|
|
GtkWidget *child;
|
|
GdkWindow *offscreen_window;
|
|
};
|
|
|
|
struct _GtkMirrorBinClass
|
|
{
|
|
GtkContainerClass parent_class;
|
|
};
|
|
|
|
GType gtk_mirror_bin_get_type (void) G_GNUC_CONST;
|
|
GtkWidget* gtk_mirror_bin_new (void);
|
|
|
|
/*** implementation ***/
|
|
|
|
static void gtk_mirror_bin_realize (GtkWidget *widget);
|
|
static void gtk_mirror_bin_unrealize (GtkWidget *widget);
|
|
static void gtk_mirror_bin_size_request (GtkWidget *widget,
|
|
GtkRequisition *requisition);
|
|
static void gtk_mirror_bin_size_allocate (GtkWidget *widget,
|
|
GtkAllocation *allocation);
|
|
static gboolean gtk_mirror_bin_damage (GtkWidget *widget,
|
|
GdkEventExpose *event);
|
|
static gboolean gtk_mirror_bin_draw (GtkWidget *widget,
|
|
cairo_t *cr);
|
|
|
|
static void gtk_mirror_bin_add (GtkContainer *container,
|
|
GtkWidget *child);
|
|
static void gtk_mirror_bin_remove (GtkContainer *container,
|
|
GtkWidget *widget);
|
|
static void gtk_mirror_bin_forall (GtkContainer *container,
|
|
gboolean include_internals,
|
|
GtkCallback callback,
|
|
gpointer callback_data);
|
|
static GType gtk_mirror_bin_child_type (GtkContainer *container);
|
|
|
|
G_DEFINE_TYPE (GtkMirrorBin, gtk_mirror_bin, GTK_TYPE_CONTAINER);
|
|
|
|
static void
|
|
to_child (GtkMirrorBin *bin,
|
|
double widget_x,
|
|
double widget_y,
|
|
double *x_out,
|
|
double *y_out)
|
|
{
|
|
*x_out = widget_x;
|
|
*y_out = widget_y;
|
|
}
|
|
|
|
static void
|
|
to_parent (GtkMirrorBin *bin,
|
|
double offscreen_x,
|
|
double offscreen_y,
|
|
double *x_out,
|
|
double *y_out)
|
|
{
|
|
*x_out = offscreen_x;
|
|
*y_out = offscreen_y;
|
|
}
|
|
|
|
static void
|
|
gtk_mirror_bin_class_init (GtkMirrorBinClass *klass)
|
|
{
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
|
|
GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
|
|
|
|
widget_class->realize = gtk_mirror_bin_realize;
|
|
widget_class->unrealize = gtk_mirror_bin_unrealize;
|
|
widget_class->size_request = gtk_mirror_bin_size_request;
|
|
widget_class->size_allocate = gtk_mirror_bin_size_allocate;
|
|
widget_class->draw = gtk_mirror_bin_draw;
|
|
|
|
g_signal_override_class_closure (g_signal_lookup ("damage-event", GTK_TYPE_WIDGET),
|
|
GTK_TYPE_MIRROR_BIN,
|
|
g_cclosure_new (G_CALLBACK (gtk_mirror_bin_damage),
|
|
NULL, NULL));
|
|
|
|
container_class->add = gtk_mirror_bin_add;
|
|
container_class->remove = gtk_mirror_bin_remove;
|
|
container_class->forall = gtk_mirror_bin_forall;
|
|
container_class->child_type = gtk_mirror_bin_child_type;
|
|
}
|
|
|
|
static void
|
|
gtk_mirror_bin_init (GtkMirrorBin *bin)
|
|
{
|
|
gtk_widget_set_has_window (GTK_WIDGET (bin), TRUE);
|
|
}
|
|
|
|
GtkWidget *
|
|
gtk_mirror_bin_new (void)
|
|
{
|
|
return g_object_new (GTK_TYPE_MIRROR_BIN, NULL);
|
|
}
|
|
|
|
static GdkWindow *
|
|
pick_offscreen_child (GdkWindow *offscreen_window,
|
|
double widget_x,
|
|
double widget_y,
|
|
GtkMirrorBin *bin)
|
|
{
|
|
GtkAllocation child_area;
|
|
double x, y;
|
|
|
|
if (bin->child && gtk_widget_get_visible (bin->child))
|
|
{
|
|
to_child (bin, widget_x, widget_y, &x, &y);
|
|
|
|
gtk_widget_get_allocation (bin->child, &child_area);
|
|
|
|
if (x >= 0 && x < child_area.width &&
|
|
y >= 0 && y < child_area.height)
|
|
return bin->offscreen_window;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
offscreen_window_to_parent (GdkWindow *offscreen_window,
|
|
double offscreen_x,
|
|
double offscreen_y,
|
|
double *parent_x,
|
|
double *parent_y,
|
|
GtkMirrorBin *bin)
|
|
{
|
|
to_parent (bin, offscreen_x, offscreen_y, parent_x, parent_y);
|
|
}
|
|
|
|
static void
|
|
offscreen_window_from_parent (GdkWindow *window,
|
|
double parent_x,
|
|
double parent_y,
|
|
double *offscreen_x,
|
|
double *offscreen_y,
|
|
GtkMirrorBin *bin)
|
|
{
|
|
to_child (bin, parent_x, parent_y, offscreen_x, offscreen_y);
|
|
}
|
|
|
|
static void
|
|
gtk_mirror_bin_realize (GtkWidget *widget)
|
|
{
|
|
GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
|
|
GtkAllocation allocation;
|
|
GtkStyle *style;
|
|
GdkWindow *window;
|
|
GdkWindowAttr attributes;
|
|
gint attributes_mask;
|
|
guint border_width;
|
|
GtkRequisition child_requisition;
|
|
|
|
gtk_widget_set_realized (widget, TRUE);
|
|
|
|
gtk_widget_get_allocation (widget, &allocation);
|
|
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
|
|
|
|
attributes.x = allocation.x + border_width;
|
|
attributes.y = allocation.y + border_width;
|
|
attributes.width = allocation.width - 2 * border_width;
|
|
attributes.height = allocation.height - 2 * border_width;
|
|
attributes.window_type = GDK_WINDOW_CHILD;
|
|
attributes.event_mask = gtk_widget_get_events (widget)
|
|
| GDK_EXPOSURE_MASK
|
|
| GDK_POINTER_MOTION_MASK
|
|
| GDK_BUTTON_PRESS_MASK
|
|
| GDK_BUTTON_RELEASE_MASK
|
|
| GDK_SCROLL_MASK
|
|
| GDK_ENTER_NOTIFY_MASK
|
|
| GDK_LEAVE_NOTIFY_MASK;
|
|
|
|
attributes.visual = gtk_widget_get_visual (widget);
|
|
attributes.wclass = GDK_INPUT_OUTPUT;
|
|
|
|
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
|
|
|
|
window = gdk_window_new (gtk_widget_get_parent_window (widget),
|
|
&attributes, attributes_mask);
|
|
gtk_widget_set_window (widget, window);
|
|
gdk_window_set_user_data (window, widget);
|
|
g_signal_connect (window, "pick-embedded-child",
|
|
G_CALLBACK (pick_offscreen_child), bin);
|
|
|
|
attributes.window_type = GDK_WINDOW_OFFSCREEN;
|
|
|
|
child_requisition.width = child_requisition.height = 0;
|
|
if (bin->child && gtk_widget_get_visible (bin->child))
|
|
{
|
|
GtkAllocation child_allocation;
|
|
|
|
gtk_widget_get_allocation (bin->child, &child_allocation);
|
|
attributes.width = child_allocation.width;
|
|
attributes.height = child_allocation.height;
|
|
}
|
|
bin->offscreen_window = gdk_window_new (gtk_widget_get_root_window (widget),
|
|
&attributes, attributes_mask);
|
|
gdk_window_set_user_data (bin->offscreen_window, widget);
|
|
if (bin->child)
|
|
gtk_widget_set_parent_window (bin->child, bin->offscreen_window);
|
|
gdk_offscreen_window_set_embedder (bin->offscreen_window, window);
|
|
g_signal_connect (bin->offscreen_window, "to-embedder",
|
|
G_CALLBACK (offscreen_window_to_parent), bin);
|
|
g_signal_connect (bin->offscreen_window, "from-embedder",
|
|
G_CALLBACK (offscreen_window_from_parent), bin);
|
|
|
|
gtk_widget_style_attach (widget);
|
|
style = gtk_widget_get_style (widget);
|
|
gtk_style_set_background (style, window, GTK_STATE_NORMAL);
|
|
gtk_style_set_background (style, bin->offscreen_window, GTK_STATE_NORMAL);
|
|
gdk_window_show (bin->offscreen_window);
|
|
}
|
|
|
|
static void
|
|
gtk_mirror_bin_unrealize (GtkWidget *widget)
|
|
{
|
|
GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
|
|
|
|
gdk_window_set_user_data (bin->offscreen_window, NULL);
|
|
gdk_window_destroy (bin->offscreen_window);
|
|
bin->offscreen_window = NULL;
|
|
|
|
GTK_WIDGET_CLASS (gtk_mirror_bin_parent_class)->unrealize (widget);
|
|
}
|
|
|
|
static GType
|
|
gtk_mirror_bin_child_type (GtkContainer *container)
|
|
{
|
|
GtkMirrorBin *bin = GTK_MIRROR_BIN (container);
|
|
|
|
if (bin->child)
|
|
return G_TYPE_NONE;
|
|
|
|
return GTK_TYPE_WIDGET;
|
|
}
|
|
|
|
static void
|
|
gtk_mirror_bin_add (GtkContainer *container,
|
|
GtkWidget *widget)
|
|
{
|
|
GtkMirrorBin *bin = GTK_MIRROR_BIN (container);
|
|
|
|
if (!bin->child)
|
|
{
|
|
gtk_widget_set_parent_window (widget, bin->offscreen_window);
|
|
gtk_widget_set_parent (widget, GTK_WIDGET (bin));
|
|
bin->child = widget;
|
|
}
|
|
else
|
|
g_warning ("GtkMirrorBin cannot have more than one child\n");
|
|
}
|
|
|
|
static void
|
|
gtk_mirror_bin_remove (GtkContainer *container,
|
|
GtkWidget *widget)
|
|
{
|
|
GtkMirrorBin *bin = GTK_MIRROR_BIN (container);
|
|
gboolean was_visible;
|
|
|
|
was_visible = gtk_widget_get_visible (widget);
|
|
|
|
if (bin->child == widget)
|
|
{
|
|
gtk_widget_unparent (widget);
|
|
|
|
bin->child = NULL;
|
|
|
|
if (was_visible && gtk_widget_get_visible (GTK_WIDGET (container)))
|
|
gtk_widget_queue_resize (GTK_WIDGET (container));
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_mirror_bin_forall (GtkContainer *container,
|
|
gboolean include_internals,
|
|
GtkCallback callback,
|
|
gpointer callback_data)
|
|
{
|
|
GtkMirrorBin *bin = GTK_MIRROR_BIN (container);
|
|
|
|
g_return_if_fail (callback != NULL);
|
|
|
|
if (bin->child)
|
|
(*callback) (bin->child, callback_data);
|
|
}
|
|
|
|
static void
|
|
gtk_mirror_bin_size_request (GtkWidget *widget,
|
|
GtkRequisition *requisition)
|
|
{
|
|
GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
|
|
GtkRequisition child_requisition;
|
|
guint border_width;
|
|
|
|
child_requisition.width = 0;
|
|
child_requisition.height = 0;
|
|
|
|
if (bin->child && gtk_widget_get_visible (bin->child))
|
|
gtk_widget_get_preferred_size ( (bin->child),
|
|
&child_requisition, NULL);
|
|
|
|
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
|
|
requisition->width = border_width * 2 + child_requisition.width + 10;
|
|
requisition->height = border_width * 2 + child_requisition.height * 2 + 10;
|
|
}
|
|
|
|
static void
|
|
gtk_mirror_bin_size_allocate (GtkWidget *widget,
|
|
GtkAllocation *allocation)
|
|
{
|
|
GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
|
|
gint w, h;
|
|
guint border_width;
|
|
|
|
gtk_widget_set_allocation (widget, allocation);
|
|
|
|
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
|
|
|
|
w = allocation->width - border_width * 2;
|
|
h = allocation->height - border_width * 2;
|
|
|
|
if (gtk_widget_get_realized (widget))
|
|
gdk_window_move_resize (gtk_widget_get_window (widget),
|
|
allocation->x + border_width,
|
|
allocation->y + border_width,
|
|
w, h);
|
|
|
|
if (bin->child && gtk_widget_get_visible (bin->child))
|
|
{
|
|
GtkRequisition child_requisition;
|
|
GtkAllocation child_allocation;
|
|
|
|
gtk_widget_get_preferred_size (bin->child,
|
|
&child_requisition, NULL);
|
|
child_allocation.x = 0;
|
|
child_allocation.y = 0;
|
|
child_allocation.height = child_requisition.height;
|
|
child_allocation.width = child_requisition.width;
|
|
|
|
if (gtk_widget_get_realized (widget))
|
|
gdk_window_move_resize (bin->offscreen_window,
|
|
allocation->x + border_width,
|
|
allocation->y + border_width,
|
|
child_allocation.width, child_allocation.height);
|
|
gtk_widget_size_allocate (bin->child, &child_allocation);
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
gtk_mirror_bin_damage (GtkWidget *widget,
|
|
GdkEventExpose *event)
|
|
{
|
|
gdk_window_invalidate_rect (gtk_widget_get_window (widget),
|
|
NULL, FALSE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gtk_mirror_bin_draw (GtkWidget *widget,
|
|
cairo_t *cr)
|
|
{
|
|
GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
|
|
GdkWindow *window;
|
|
|
|
window = gtk_widget_get_window (widget);
|
|
if (gtk_cairo_should_draw_window (cr, window))
|
|
{
|
|
cairo_surface_t *surface;
|
|
cairo_matrix_t matrix;
|
|
cairo_pattern_t *mask;
|
|
int height;
|
|
|
|
if (bin->child && gtk_widget_get_visible (bin->child))
|
|
{
|
|
surface = gdk_offscreen_window_get_surface (bin->offscreen_window);
|
|
height = gdk_window_get_height (bin->offscreen_window);
|
|
|
|
/* paint the offscreen child */
|
|
cairo_set_source_surface (cr, surface, 0, 0);
|
|
cairo_paint (cr);
|
|
|
|
cairo_matrix_init (&matrix, 1.0, 0.0, 0.3, 1.0, 0.0, 0.0);
|
|
cairo_matrix_scale (&matrix, 1.0, -1.0);
|
|
cairo_matrix_translate (&matrix, -10, - 3 * height - 10);
|
|
cairo_transform (cr, &matrix);
|
|
|
|
cairo_set_source_surface (cr, surface, 0, height);
|
|
|
|
/* create linear gradient as mask-pattern to fade out the source */
|
|
mask = cairo_pattern_create_linear (0.0, height, 0.0, 2*height);
|
|
cairo_pattern_add_color_stop_rgba (mask, 0.0, 0.0, 0.0, 0.0, 0.0);
|
|
cairo_pattern_add_color_stop_rgba (mask, 0.25, 0.0, 0.0, 0.0, 0.01);
|
|
cairo_pattern_add_color_stop_rgba (mask, 0.5, 0.0, 0.0, 0.0, 0.25);
|
|
cairo_pattern_add_color_stop_rgba (mask, 0.75, 0.0, 0.0, 0.0, 0.5);
|
|
cairo_pattern_add_color_stop_rgba (mask, 1.0, 0.0, 0.0, 0.0, 1.0);
|
|
|
|
/* paint the reflection */
|
|
cairo_mask (cr, mask);
|
|
|
|
cairo_pattern_destroy (mask);
|
|
}
|
|
}
|
|
else if (gtk_cairo_should_draw_window (cr, bin->offscreen_window))
|
|
{
|
|
gtk_paint_flat_box (gtk_widget_get_style (widget), cr,
|
|
GTK_STATE_NORMAL, GTK_SHADOW_NONE,
|
|
widget, "blah",
|
|
0, 0,
|
|
gdk_window_get_width (bin->offscreen_window),
|
|
gdk_window_get_height (bin->offscreen_window));
|
|
|
|
if (bin->child)
|
|
gtk_container_propagate_draw (GTK_CONTAINER (widget),
|
|
bin->child,
|
|
cr);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*** ***/
|
|
|
|
static GtkWidget *window = NULL;
|
|
|
|
GtkWidget *
|
|
do_offscreen_window2 (GtkWidget *do_widget)
|
|
{
|
|
if (!window)
|
|
{
|
|
GtkWidget *bin, *vbox;
|
|
GtkWidget *hbox, *entry, *applybutton, *backbutton;
|
|
GtkSizeGroup *group;
|
|
|
|
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
|
gtk_window_set_screen (GTK_WINDOW (window),
|
|
gtk_widget_get_screen (do_widget));
|
|
gtk_window_set_title (GTK_WINDOW (window), "Effects");
|
|
|
|
g_signal_connect (window, "destroy",
|
|
G_CALLBACK (gtk_widget_destroyed), &window);
|
|
|
|
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
|
|
|
|
vbox = gtk_vbox_new (0, FALSE);
|
|
|
|
bin = gtk_mirror_bin_new ();
|
|
|
|
group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
|
|
|
|
hbox = gtk_hbox_new (FALSE, 6);
|
|
backbutton = gtk_button_new ();
|
|
gtk_container_add (GTK_CONTAINER (backbutton),
|
|
gtk_image_new_from_stock (GTK_STOCK_GO_BACK, 4));
|
|
gtk_size_group_add_widget (group, backbutton);
|
|
entry = gtk_entry_new ();
|
|
gtk_size_group_add_widget (group, entry);
|
|
applybutton = gtk_button_new ();
|
|
gtk_size_group_add_widget (group, applybutton);
|
|
gtk_container_add (GTK_CONTAINER (applybutton),
|
|
gtk_image_new_from_stock (GTK_STOCK_APPLY, 4));
|
|
|
|
gtk_container_add (GTK_CONTAINER (window), vbox);
|
|
gtk_box_pack_start (GTK_BOX (vbox), bin, TRUE, TRUE, 0);
|
|
gtk_container_add (GTK_CONTAINER (bin), hbox);
|
|
gtk_box_pack_start (GTK_BOX (hbox), backbutton, FALSE, FALSE, 0);
|
|
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
|
|
gtk_box_pack_start (GTK_BOX (hbox), applybutton, FALSE, FALSE, 0);
|
|
}
|
|
|
|
if (!gtk_widget_get_visible (window))
|
|
gtk_widget_show_all (window);
|
|
else
|
|
{
|
|
gtk_widget_destroy (window);
|
|
window = NULL;
|
|
}
|
|
|
|
return window;
|
|
}
|
|
|