forked from AuroraMiddleware/gtk
36edb5fbf6
We need to mark the prototypes in the headers so that they get exported properly from the reftest DLLs that we build, so that the reftest DLLs and program will link properly. Include gtk-reftest.h in reftest-snapshot.c so that the compiler picks up the export directives as needed.
278 lines
7.2 KiB
C
278 lines
7.2 KiB
C
/*
|
|
* Copyright (C) 2011 Red Hat Inc.
|
|
*
|
|
* Author:
|
|
* Benjamin Otte <otte@gnome.org>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library 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
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "reftest-snapshot.h"
|
|
|
|
#include "reftest-module.h"
|
|
#include "gtk-reftest.h"
|
|
|
|
#include <string.h>
|
|
|
|
typedef enum {
|
|
SNAPSHOT_WINDOW,
|
|
SNAPSHOT_DRAW
|
|
} SnapshotMode;
|
|
|
|
static GtkWidget *
|
|
builder_get_toplevel (GtkBuilder *builder)
|
|
{
|
|
GSList *list, *walk;
|
|
GtkWidget *window = NULL;
|
|
|
|
list = gtk_builder_get_objects (builder);
|
|
for (walk = list; walk; walk = walk->next)
|
|
{
|
|
if (GTK_IS_WINDOW (walk->data) &&
|
|
gtk_widget_get_parent (walk->data) == NULL)
|
|
{
|
|
window = walk->data;
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_slist_free (list);
|
|
|
|
return window;
|
|
}
|
|
|
|
static gboolean
|
|
quit_when_idle (gpointer loop)
|
|
{
|
|
g_main_loop_quit (loop);
|
|
|
|
return G_SOURCE_REMOVE;
|
|
}
|
|
|
|
static gint inhibit_count;
|
|
static GMainLoop *loop;
|
|
|
|
void
|
|
reftest_inhibit_snapshot (void)
|
|
{
|
|
inhibit_count++;
|
|
}
|
|
|
|
void
|
|
reftest_uninhibit_snapshot (void)
|
|
{
|
|
g_assert (inhibit_count > 0);
|
|
inhibit_count--;
|
|
|
|
if (inhibit_count == 0)
|
|
g_idle_add (quit_when_idle, loop);
|
|
}
|
|
|
|
static void
|
|
check_for_draw (GdkEvent *event, gpointer data)
|
|
{
|
|
if (event->type == GDK_EXPOSE)
|
|
{
|
|
reftest_uninhibit_snapshot ();
|
|
gdk_event_handler_set ((GdkEventFunc) gtk_main_do_event, NULL, NULL);
|
|
}
|
|
|
|
gtk_main_do_event (event);
|
|
}
|
|
|
|
static cairo_surface_t *
|
|
snapshot_widget (GtkWidget *widget, SnapshotMode mode)
|
|
{
|
|
cairo_surface_t *surface;
|
|
cairo_pattern_t *bg;
|
|
cairo_t *cr;
|
|
|
|
g_assert (gtk_widget_get_realized (widget));
|
|
|
|
loop = g_main_loop_new (NULL, FALSE);
|
|
|
|
/* We wait until the widget is drawn for the first time.
|
|
* We can not wait for a GtkWidget::draw event, because that might not
|
|
* happen if the window is fully obscured by windowed child widgets.
|
|
* Alternatively, we could wait for an expose event on widget's window.
|
|
* Both of these are rather hairy, not sure what's best.
|
|
*
|
|
* We also use an inhibit mechanism, to give module functions a chance
|
|
* to delay the snapshot.
|
|
*/
|
|
reftest_inhibit_snapshot ();
|
|
gdk_event_handler_set (check_for_draw, NULL, NULL);
|
|
g_main_loop_run (loop);
|
|
|
|
surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget),
|
|
CAIRO_CONTENT_COLOR,
|
|
gtk_widget_get_allocated_width (widget),
|
|
gtk_widget_get_allocated_height (widget));
|
|
|
|
cr = cairo_create (surface);
|
|
|
|
switch (mode)
|
|
{
|
|
case SNAPSHOT_WINDOW:
|
|
{
|
|
GdkWindow *window = gtk_widget_get_window (widget);
|
|
if (gdk_window_get_window_type (window) == GDK_WINDOW_TOPLEVEL ||
|
|
gdk_window_get_window_type (window) == GDK_WINDOW_FOREIGN)
|
|
{
|
|
/* give the WM/server some time to sync. They need it.
|
|
* Also, do use popups instead of toplevels in your tests
|
|
* whenever you can.
|
|
*/
|
|
gdk_display_sync (gdk_window_get_display (window));
|
|
g_timeout_add (500, quit_when_idle, loop);
|
|
g_main_loop_run (loop);
|
|
}
|
|
gdk_cairo_set_source_window (cr, window, 0, 0);
|
|
cairo_paint (cr);
|
|
}
|
|
break;
|
|
case SNAPSHOT_DRAW:
|
|
bg = gdk_window_get_background_pattern (gtk_widget_get_window (widget));
|
|
if (bg)
|
|
{
|
|
cairo_set_source (cr, bg);
|
|
cairo_paint (cr);
|
|
}
|
|
gtk_widget_draw (widget, cr);
|
|
break;
|
|
default:
|
|
g_assert_not_reached();
|
|
break;
|
|
}
|
|
|
|
cairo_destroy (cr);
|
|
g_main_loop_unref (loop);
|
|
gtk_widget_destroy (widget);
|
|
|
|
return surface;
|
|
}
|
|
|
|
static void
|
|
connect_signals (GtkBuilder *builder,
|
|
GObject *object,
|
|
const gchar *signal_name,
|
|
const gchar *handler_name,
|
|
GObject *connect_object,
|
|
GConnectFlags flags,
|
|
gpointer user_data)
|
|
{
|
|
ReftestModule *module;
|
|
const char *directory;
|
|
GCallback func;
|
|
GClosure *closure;
|
|
char **split;
|
|
|
|
directory = user_data;
|
|
split = g_strsplit (handler_name, ":", -1);
|
|
|
|
switch (g_strv_length (split))
|
|
{
|
|
case 1:
|
|
func = gtk_builder_lookup_callback_symbol (builder, split[0]);
|
|
|
|
if (func)
|
|
{
|
|
module = NULL;
|
|
}
|
|
else
|
|
{
|
|
module = reftest_module_new_self ();
|
|
if (module == NULL)
|
|
{
|
|
g_error ("glib compiled without module support.");
|
|
return;
|
|
}
|
|
func = reftest_module_lookup (module, split[0]);
|
|
if (!func)
|
|
{
|
|
g_error ("failed to lookup handler for name '%s' when connecting signals", split[0]);
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
if (g_getenv ("REFTEST_MODULE_DIR"))
|
|
directory = g_getenv ("REFTEST_MODULE_DIR");
|
|
module = reftest_module_new (directory, split[0]);
|
|
if (module == NULL)
|
|
{
|
|
g_error ("Could not load module '%s' from '%s' when looking up '%s'", split[0], directory, handler_name);
|
|
return;
|
|
}
|
|
func = reftest_module_lookup (module, split[1]);
|
|
if (!func)
|
|
{
|
|
g_error ("failed to lookup handler for name '%s' in module '%s'", split[1], split[0]);
|
|
return;
|
|
}
|
|
break;
|
|
default:
|
|
g_error ("Could not connect signal handler named '%s'", handler_name);
|
|
return;
|
|
}
|
|
|
|
g_strfreev (split);
|
|
|
|
if (connect_object)
|
|
{
|
|
if (flags & G_CONNECT_SWAPPED)
|
|
closure = g_cclosure_new_object_swap (func, connect_object);
|
|
else
|
|
closure = g_cclosure_new_object (func, connect_object);
|
|
}
|
|
else
|
|
{
|
|
if (flags & G_CONNECT_SWAPPED)
|
|
closure = g_cclosure_new_swap (func, NULL, NULL);
|
|
else
|
|
closure = g_cclosure_new (func, NULL, NULL);
|
|
}
|
|
|
|
if (module)
|
|
g_closure_add_finalize_notifier (closure, module, (GClosureNotify) reftest_module_unref);
|
|
|
|
g_signal_connect_closure (object, signal_name, closure, flags & G_CONNECT_AFTER ? TRUE : FALSE);
|
|
}
|
|
|
|
cairo_surface_t *
|
|
reftest_snapshot_ui_file (const char *ui_file)
|
|
{
|
|
GtkWidget *window;
|
|
GtkBuilder *builder;
|
|
GError *error = NULL;
|
|
char *directory;
|
|
|
|
directory = g_path_get_dirname (ui_file);
|
|
|
|
builder = gtk_builder_new ();
|
|
gtk_builder_add_from_file (builder, ui_file, &error);
|
|
g_assert_no_error (error);
|
|
gtk_builder_connect_signals_full (builder, connect_signals, directory);
|
|
window = builder_get_toplevel (builder);
|
|
g_object_unref (builder);
|
|
g_free (directory);
|
|
g_assert (window);
|
|
|
|
gtk_widget_show (window);
|
|
|
|
return snapshot_widget (window, SNAPSHOT_WINDOW);
|
|
}
|