AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

GtkOffscreenWindow implementation for #604901

Browse Source
This commit is contained in:
Cody Russell 2009-12-18 13:43:11 +01:00 committed by Tristan Van Berkom
parent ddf4cde3af
commit 87487cea62
6 changed files with 337 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gtk/Makefile.am
View File

@ -260,6 +260,7 @@ gtk_public_h_sources = \
gtkmountoperation.h \
gtknotebook.h \
gtkobject.h \
gtkoffscreenwindow.h \
gtkorientable.h \
gtkpagesetup.h \
gtkpaned.h \
@ -528,6 +529,7 @@ gtk_base_c_sources = \
gtkmountoperation.c \
gtknotebook.c \
gtkobject.c \
gtkoffscreenwindow.c \
gtkorientable.c \
gtkpagesetup.c \
gtkpaned.c \

1
gtk/gtk.h
View File

@ -130,6 +130,7 @@
#include <gtk/gtkmountoperation.h>
#include <gtk/gtknotebook.h>
#include <gtk/gtkobject.h>
#include <gtk/gtkoffscreenwindow.h>
#include <gtk/gtkorientable.h>
#include <gtk/gtkpagesetup.h>
#include <gtk/gtkpapersize.h>

200
gtk/gtkoffscreenwindow.c Normal file
View File

@ -0,0 +1,200 @@
#include "gtkoffscreenwindow.h"
G_DEFINE_TYPE (GtkOffscreenWindow, gtk_offscreen_window, GTK_TYPE_WINDOW);
static void
gtk_offscreen_window_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
GtkBin *bin = GTK_BIN (widget);
gint border_width;
gint default_width, default_height;
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
requisition->width = border_width * 2;
requisition->height = border_width * 2;
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
GtkRequisition child_req;
gtk_widget_size_request (bin->child, &child_req);
requisition->width += child_req.width;
requisition->height += child_req.height;
}
gtk_window_get_default_size (GTK_WINDOW (widget),
&default_width, &default_height);
if (default_width > 0)
requisition->width = default_width;
if (default_height > 0)
requisition->height = default_height;
}
static void
gtk_offscreen_window_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkBin *bin = GTK_BIN (widget);
gint border_width;
widget->allocation = *allocation;
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
if (GTK_WIDGET_REALIZED (widget))
gdk_window_move_resize (widget->window,
allocation->x,
allocation->y,
allocation->width,
allocation->height);
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
GtkAllocation child_alloc;
child_alloc.x = border_width;
child_alloc.y = border_width;
child_alloc.width = allocation->width - 2 * border_width;
child_alloc.height = allocation->height - 2 * border_width;
gtk_widget_size_allocate (bin->child, &child_alloc);
}
gtk_widget_queue_draw (widget);
}
static void
gtk_offscreen_window_realize (GtkWidget *widget)
{
GtkBin *bin;
GdkWindowAttr attributes;
gint attributes_mask;
gint border_width;
bin = GTK_BIN (widget);
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.height = widget->allocation.height;
attributes.window_type = GDK_WINDOW_OFFSCREEN;
attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.wclass = GDK_INPUT_OUTPUT;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (widget->window, widget);
if (bin->child)
gtk_widget_set_parent_window (bin->child, widget->window);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
}
static void
gtk_offscreen_window_resize (GtkWidget *widget)
{
GtkAllocation allocation = { 0, 0 };
GtkRequisition requisition;
gtk_widget_size_request (widget, &requisition);
allocation.width = requisition.width;
allocation.height = requisition.height;
gtk_widget_size_allocate (widget, &allocation);
}
static void
move_focus (GtkWidget *widget,
GtkDirectionType dir)
{
gtk_widget_child_focus (widget, dir);
if (!GTK_CONTAINER (widget)->focus_child)
gtk_window_set_focus (GTK_WINDOW (widget), NULL);
}
static void
gtk_offscreen_window_show (GtkWidget *widget)
{
gboolean need_resize;
GtkContainer *container;
GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
container = GTK_CONTAINER (widget);
need_resize = container->need_resize || !GTK_WIDGET_REALIZED (widget);
container->need_resize = FALSE;
if (need_resize)
gtk_offscreen_window_resize (widget);
gtk_widget_map (widget);
/* Try to make sure that we have some focused widget */
if (!gtk_window_get_focus (GTK_WINDOW (widget)))
move_focus (widget, GTK_DIR_TAB_FORWARD);
}
static void
gtk_offscreen_window_hide (GtkWidget *widget)
{
GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
gtk_widget_unmap (widget);
}
static void
gtk_offscreen_window_check_resize (GtkContainer *container)
{
GtkWidget *widget = GTK_WIDGET (container);
if (GTK_WIDGET_VISIBLE (widget))
gtk_offscreen_window_resize (widget);
}
static void
gtk_offscreen_window_class_init (GtkOffscreenWindowClass *class)
{
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
widget_class = GTK_WIDGET_CLASS (class);
container_class = GTK_CONTAINER_CLASS (class);
widget_class->realize = gtk_offscreen_window_realize;
widget_class->show = gtk_offscreen_window_show;
widget_class->hide = gtk_offscreen_window_hide;
widget_class->size_request = gtk_offscreen_window_size_request;
widget_class->size_allocate = gtk_offscreen_window_size_allocate;
container_class->check_resize = gtk_offscreen_window_check_resize;
}
static void
gtk_offscreen_window_init (GtkOffscreenWindow *bin)
{
}
GtkWidget *
gtk_offscreen_window_new (void)
{
return g_object_new (gtk_offscreen_window_get_type (), NULL);
}
#define __GTK_OFFSCREEN_WINDOW_C__
#include "gtkaliasdef.c"

36
gtk/gtkoffscreenwindow.h Normal file
View File

@ -0,0 +1,36 @@
#if defined(GTK_DISABLE_SINGLE_INCLUDES) && !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
#error "Only <gtk/gtk.h> can be included directly."
#endif
#ifndef __GTK_OFFSCREEN_WINDOW_H__
#define __GTK_OFFSCREEN_WINDOW_H__
#include <gtk/gtkwindow.h>
G_BEGIN_DECLS
#define GTK_TYPE_OFFSCREEN_WINDOW (gtk_offscreen_window_get_type ())
#define GTK_OFFSCREEN_WINDOW(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_OFFSCREEN_WINDOW, GtkOffscreenWindow))
#define GTK_OFFSCREEN_WINDOW_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_OFFSCREEN_WINDOW, GtkOffscreenWindowClass))
#define GTK_IS_OFFSCREEN_WINDOW(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_OFFSCREEN_WINDOW))
#define GTK_IS_OFFSCREEN_WINDOW_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_OFFSCREEN_WINDOW))
#define GTK_OFFSCREEN_WINDOW_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_OFFSCREEN_WINDOW, GtkOffscreenWindowClass))
typedef struct _GtkOffscreenWindow GtkOffscreenWindow;
typedef struct _GtkOffscreenWindowClass GtkOffscreenWindowClass;
struct _GtkOffscreenWindow
{
GtkWindow parent_object;
};
struct _GtkOffscreenWindowClass
{
GtkWindowClass parent_class;
};
GType gtk_offscreen_window_get_type () G_GNUC_CONST;
G_END_DECLS
#endif /* __GTK_OFFSCREEN_WINDOW_H__ */

6
tests/Makefile.am
View File

@ -60,6 +60,7 @@ noinst_PROGRAMS = $(TEST_PROGS) \
testnotebookdnd \
testnouiprint \
testoffscreen \
testoffscreenwindow \
testorientable \
testprint \
testrgb \
@ -143,6 +144,7 @@ testmultiscreen_DEPENDENCIES = $(TEST_DEPS)
testnotebookdnd_DEPENDENCIES = $(TEST_DEPS)
testnouiprint_DEPENDENCIES = $(TEST_DEPS)
testoffscreen_DEPENDENCIES = $(TEST_DEPS)
testoffscreenwindow_DEPENDENCIES = $(TEST_DEPS)
testorientable_DEPENDENCIES = $(TEST_DEPS)
testprint_DEPENDENCIES = $(TEST_DEPS)
testrecentchooser_DEPENDENCIES = $(TEST_DEPS)
@ -207,6 +209,7 @@ testmultiscreen_LDADD = $(LDADDS)
testnotebookdnd_LDADD = $(LDADDS)
testnouiprint_LDADD = $(LDADDS)
testoffscreen_LDADD = $(LDADDS)
testoffscreenwindow_LDADD = $(LDADDS)
testorientable_LDADD = $(LDADDS)
testprint_LDADD = $(LDADDS)
testrecentchooser_LDADD = $(LDADDS)
@ -343,6 +346,9 @@ testoffscreen_SOURCES = \
gtkoffscreenbox.h \
testoffscreen.c
testoffscreenwindnow_SOURCES = \
testoffscreenwindow.c
testwindow_SOURCES = \
testwindows.c

92
tests/testoffscreenwindow.c Normal file
View File

@ -0,0 +1,92 @@
#include <gtk/gtk.h>
static gboolean
da_expose (GtkWidget *widget,
GdkEventExpose *event,
gpointer user_data)
{
GtkOffscreenWindow *offscreen = (GtkOffscreenWindow *)user_data;
GdkPixmap *pixmap;
cairo_t *cr;
if (GTK_WIDGET_DRAWABLE (widget))
{
pixmap = gdk_offscreen_window_get_pixmap (GTK_WIDGET (offscreen)->window);
cr = gdk_cairo_create (widget->window);
gdk_cairo_set_source_pixmap (cr, pixmap, 50, 50);
cairo_paint (cr);
cairo_destroy (cr);
}
return FALSE;
}
static gboolean
offscreen_damage (GtkWidget *widget,
GdkEventExpose *event,
GtkWidget *da)
{
gtk_widget_queue_draw (da);
return TRUE;
}
static gboolean
da_button_press (GtkWidget *area, GdkEventButton *event, GtkWidget *button)
{
gtk_widget_set_size_request (button, 150, 60);
return TRUE;
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *offscreen;
GtkWidget *da;
gtk_init (&argc, &argv);
offscreen = gtk_offscreen_window_new ();
button = gtk_button_new_with_label ("Test");
gtk_widget_set_size_request (button, 50, 50);
gtk_container_add (GTK_CONTAINER (offscreen), button);
gtk_widget_show (button);
gtk_widget_show (offscreen);
/* Queue exposures and ensure they are handled so
* that the result is uptodate for the first
* expose of the window. If you want to get further
* changes, also track damage on the offscreen
* as done above.
*/
gtk_widget_draw (offscreen, NULL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
da = gtk_drawing_area_new ();
gtk_container_add (GTK_CONTAINER (window), da);
g_signal_connect (da,
"expose-event",
G_CALLBACK (da_expose),
offscreen);
g_signal_connect (offscreen,
"damage-event",
G_CALLBACK (offscreen_damage),
da);
gtk_widget_add_events (da, GDK_BUTTON_PRESS_MASK);
g_signal_connect (da, "button_press_event", G_CALLBACK (da_button_press),
button);
gtk_widget_show_all (window);
gtk_main();
return 0;
}