--- a/make/sun/xawt/FILES_c_unix.gmk	Thu Aug 11 17:22:31 2011 +0200
+++ b/make/sun/xawt/FILES_c_unix.gmk	Fri Aug 12 09:18:57 2011 +0100
@@ -83,3 +83,8 @@
 	sun_awt_X11_GtkFileDialogPeer.c \
 	XRSurfaceData.c \
 	XRBackendNative.c
+
+ifndef USE_SYSTEM_GTK
+FILES_c += \
+	gtk_fp.c
+endif

--- a/make/sun/xawt/Makefile	Thu Aug 11 17:22:31 2011 +0200
+++ b/make/sun/xawt/Makefile	Fri Aug 12 09:18:57 2011 +0100
@@ -92,9 +92,17 @@
 vpath %.c   $(PLATFORM_SRC)/native/sun/java2d/opengl
 vpath %.c   $(PLATFORM_SRC)/native/sun/java2d/x11
 
+ifndef USE_SYSTEM_GTK
+vpath %.c   $(PLATFORM_SRC)/native/sun/awt/gtk2
+endif
+
 OTHER_LDLIBS = $(LIBM) -lawt -lXext -lX11 -lXrender -ldl \
                    $(LDFLAGS_COMMON) $(AWT_RUNPATH) $(OTHER_LDFLAGS) -lXtst -lXi
 
+ifdef USE_SYSTEM_GTK
+  OTHER_LDLIBS += $(GTK_LIBS)
+endif
+
 ifeq  ($(PLATFORM), solaris)
 CPPFLAGS += -DFUNCPROTO=15
 dummy := $(shell $(MKDIR) -p $(LIB_LOCATION))
@@ -128,6 +136,12 @@
         -I$(SHARE_SRC)/native/sun/awt \
         -I$(PLATFORM_SRC)/native/sun/awt
 
+ifdef USE_SYSTEM_GTK
+  CPPFLAGS += $(GTK_CFLAGS) -DUSE_SYSTEM_GTK
+else
+  CPPFLAGS += -I$(PLATFORM_SRC)/native/sun/awt/gtk2
+endif
+
 ifeq ($(PLATFORM), linux)
   ifndef CROSS_COMPILE_ARCH
     # Allows for builds on Debian GNU Linux, X11 is in a different place 

--- a/src/solaris/native/sun/awt/awt_UNIXToolkit.c	Thu Aug 11 17:22:31 2011 +0200
+++ b/src/solaris/native/sun/awt/awt_UNIXToolkit.c	Fri Aug 12 09:18:57 2011 +0100
@@ -101,13 +101,13 @@
 
     if (pixbuf != NULL)
     {
-        guchar *pixbuf_data = (*fp_gdk_pixbuf_get_pixels)(pixbuf);
-        int row_stride = (*fp_gdk_pixbuf_get_rowstride)(pixbuf);
-        int width = (*fp_gdk_pixbuf_get_width)(pixbuf);
-        int height = (*fp_gdk_pixbuf_get_height)(pixbuf);
-        int bps = (*fp_gdk_pixbuf_get_bits_per_sample)(pixbuf);
-        int channels = (*fp_gdk_pixbuf_get_n_channels)(pixbuf);
-        gboolean alpha = (*fp_gdk_pixbuf_get_has_alpha)(pixbuf);
+        guchar *pixbuf_data = gdk_pixbuf_get_pixels (pixbuf);
+        int row_stride = gdk_pixbuf_get_rowstride (pixbuf);
+        int width = gdk_pixbuf_get_width (pixbuf);
+        int height = gdk_pixbuf_get_height (pixbuf);
+        int bps = gdk_pixbuf_get_bits_per_sample (pixbuf);
+        int channels = gdk_pixbuf_get_n_channels (pixbuf);
+        gboolean alpha = gdk_pixbuf_get_has_alpha (pixbuf);
 
         /* Copy the data array into a Java structure so we can pass it back. */
         jbyteArray data = (*env)->NewByteArray(env, (row_stride * height));
@@ -115,7 +115,7 @@
                                    (jbyte *)pixbuf_data);
 
         /* Release the pixbuf. */
-        (*fp_g_object_unref)(pixbuf);
+        g_object_unref (pixbuf);
 
         /* Call the callback method to create the image on the Java side. */
         (*env)->CallVoidMethod(env, this, icon_upcall_method, data,
@@ -154,7 +154,7 @@
         return JNI_FALSE;
     }
     (*env)->GetStringUTFRegion(env, filename, 0, len, filename_str);
-    pixbuf = (*fp_gdk_pixbuf_new_from_file)(filename_str, error);
+    pixbuf = gdk_pixbuf_new_from_file (filename_str, error);
 
     /* Release the strings we've allocated. */
     free(filename_str);
@@ -272,7 +272,7 @@
 {
     char *ret;
 
-    ret = fp_gtk_check_version(major, minor, micro);
+    ret = gtk_check_version(major, minor, micro);
     if (ret == NULL) {
         return TRUE;
     }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/solaris/native/sun/awt/gtk2/gtk/gtk.h	Fri Aug 12 09:18:57 2011 +0100
@@ -0,0 +1,567 @@
+/*
+ * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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 General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+#ifndef __GTK_H__
+#define __GTK_H__
+
+#define _G_TYPE_CIC(ip, gt, ct)       ((ct*) ip)
+#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type)    (_G_TYPE_CIC ((instance), (g_type), c_type))
+#define GTK_TYPE_FILE_CHOOSER             (fp_gtk_file_chooser_get_type ())
+#define GTK_FILE_CHOOSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER, GtkFileChooser))
+#define fp_g_signal_connect(instance, detailed_signal, c_handler, data) \
+    fp_g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, (GConnectFlags) 0)
+#define G_CALLBACK(f) ((GCallback) (f))
+#define G_TYPE_FUNDAMENTAL_SHIFT (2)
+#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT))
+#define G_TYPE_OBJECT G_TYPE_MAKE_FUNDAMENTAL (20)
+#define G_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_OBJECT, GObject))
+#define GTK_STOCK_CANCEL           "gtk-cancel"
+#define GTK_STOCK_SAVE             "gtk-save"
+#define GTK_STOCK_OPEN             "gtk-open"
+
+/* GTK types, here to eliminate need for GTK headers at compile time */
+
+#ifndef FALSE
+#define FALSE           (0)
+#define TRUE            (!FALSE)
+#endif
+
+#define GTK_HAS_FOCUS   (1 << 12)
+#define GTK_HAS_DEFAULT (1 << 14)
+
+
+/* basic types */
+typedef char    gchar;
+typedef short   gshort;
+typedef int     gint;
+typedef long    glong;
+typedef float   gfloat;
+typedef double  gdouble;
+typedef void*   gpointer;
+typedef gint    gboolean;
+
+typedef signed char  gint8;
+typedef signed short gint16;
+typedef signed int   gint32;
+
+typedef unsigned char  guchar;
+typedef unsigned char  guint8;
+typedef unsigned short gushort;
+typedef unsigned short guint16;
+typedef unsigned int   guint;
+typedef unsigned int   guint32;
+typedef unsigned int   gsize;
+typedef unsigned long  gulong;
+
+typedef signed long long   gint64;
+typedef unsigned long long guint64;
+
+/* enumerated constants */
+typedef enum
+{
+  GTK_ARROW_UP,
+  GTK_ARROW_DOWN,
+  GTK_ARROW_LEFT,
+  GTK_ARROW_RIGHT
+} GtkArrowType;
+
+typedef enum {
+  GDK_COLORSPACE_RGB
+} GdkColorspace;
+
+typedef enum
+{
+  GTK_EXPANDER_COLLAPSED,
+  GTK_EXPANDER_SEMI_COLLAPSED,
+  GTK_EXPANDER_SEMI_EXPANDED,
+  GTK_EXPANDER_EXPANDED
+} GtkExpanderStyle;
+
+typedef enum
+{
+  GTK_ICON_SIZE_INVALID,
+  GTK_ICON_SIZE_MENU,
+  GTK_ICON_SIZE_SMALL_TOOLBAR,
+  GTK_ICON_SIZE_LARGE_TOOLBAR,
+  GTK_ICON_SIZE_BUTTON,
+  GTK_ICON_SIZE_DND,
+  GTK_ICON_SIZE_DIALOG
+} GtkIconSize;
+
+typedef enum
+{
+  GTK_ORIENTATION_HORIZONTAL,
+  GTK_ORIENTATION_VERTICAL
+} GtkOrientation;
+
+typedef enum
+{
+  GTK_POS_LEFT,
+  GTK_POS_RIGHT,
+  GTK_POS_TOP,
+  GTK_POS_BOTTOM
+} GtkPositionType;
+
+typedef enum
+{
+  GTK_SHADOW_NONE,
+  GTK_SHADOW_IN,
+  GTK_SHADOW_OUT,
+  GTK_SHADOW_ETCHED_IN,
+  GTK_SHADOW_ETCHED_OUT
+} GtkShadowType;
+
+typedef enum
+{
+  GTK_STATE_NORMAL,
+  GTK_STATE_ACTIVE,
+  GTK_STATE_PRELIGHT,
+  GTK_STATE_SELECTED,
+  GTK_STATE_INSENSITIVE
+} GtkStateType;
+
+typedef enum
+{
+  GTK_TEXT_DIR_NONE,
+  GTK_TEXT_DIR_LTR,
+  GTK_TEXT_DIR_RTL
+} GtkTextDirection;
+
+typedef enum
+{
+  GTK_WINDOW_TOPLEVEL,
+  GTK_WINDOW_POPUP
+} GtkWindowType;
+
+typedef enum
+{
+  G_PARAM_READABLE            = 1 << 0,
+  G_PARAM_WRITABLE            = 1 << 1,
+  G_PARAM_CONSTRUCT           = 1 << 2,
+  G_PARAM_CONSTRUCT_ONLY      = 1 << 3,
+  G_PARAM_LAX_VALIDATION      = 1 << 4,
+  G_PARAM_PRIVATE             = 1 << 5
+} GParamFlags;
+
+/* We define all structure pointers to be void* */
+typedef void GError;
+typedef void GMainContext;
+
+typedef struct _GSList GSList;
+struct _GSList
+{
+  gpointer data;
+  GSList *next;
+};
+
+typedef void GdkColormap;
+typedef void GdkDrawable;
+typedef void GdkGC;
+typedef void GdkPixbuf;
+typedef void GdkPixmap;
+typedef void GdkWindow;
+
+typedef void GtkFixed;
+typedef void GtkMenuItem;
+typedef void GtkMenuShell;
+typedef void GtkWidgetClass;
+typedef void PangoFontDescription;
+typedef void GtkSettings;
+
+/* Some real structures */
+typedef struct
+{
+  guint32 pixel;
+  guint16 red;
+  guint16 green;
+  guint16 blue;
+} GdkColor;
+
+typedef struct {
+  gint      fd;
+  gushort   events;
+  gushort   revents;
+} GPollFD;
+
+typedef struct {
+  gint x;
+  gint y;
+  gint width;
+  gint height;
+} GdkRectangle;
+
+typedef struct {
+  gint x;
+  gint y;
+  gint width;
+  gint height;
+} GtkAllocation;
+
+typedef struct {
+  gint width;
+  gint height;
+} GtkRequisition;
+
+typedef struct {
+  GtkWidgetClass *g_class;
+} GTypeInstance;
+
+typedef struct {
+  gint left;
+  gint right;
+  gint top;
+  gint bottom;
+} GtkBorder;
+
+/******************************************************
+ * FIXME: it is more safe to include gtk headers for
+ * the precise type definition of GType and other
+ * structures. This is a place where getting rid of gtk
+ * headers may be dangerous.
+ ******************************************************/
+typedef gulong         GType;
+
+typedef struct
+{
+  GType         g_type;
+
+  union {
+    gint        v_int;
+    guint       v_uint;
+    glong       v_long;
+    gulong      v_ulong;
+    gint64      v_int64;
+    guint64     v_uint64;
+    gfloat      v_float;
+    gdouble     v_double;
+    gpointer    v_pointer;
+  } data[2];
+} GValue;
+
+typedef struct
+{
+  GTypeInstance  g_type_instance;
+
+  gchar         *name;
+  GParamFlags    flags;
+  GType          value_type;
+  GType          owner_type;
+} GParamSpec;
+
+typedef struct {
+  GTypeInstance g_type_instance;
+  guint         ref_count;
+  void         *qdata;
+} GObject;
+
+typedef struct {
+  GObject parent_instance;
+  guint32 flags;
+} GtkObject;
+
+typedef struct
+{
+  GObject parent_instance;
+
+  GdkColor fg[5];
+  GdkColor bg[5];
+  GdkColor light[5];
+  GdkColor dark[5];
+  GdkColor mid[5];
+  GdkColor text[5];
+  GdkColor base[5];
+  GdkColor text_aa[5];          /* Halfway between text/base */
+
+  GdkColor black;
+  GdkColor white;
+  PangoFontDescription *font_desc;
+
+  gint xthickness;
+  gint ythickness;
+
+  GdkGC *fg_gc[5];
+  GdkGC *bg_gc[5];
+  GdkGC *light_gc[5];
+  GdkGC *dark_gc[5];
+  GdkGC *mid_gc[5];
+  GdkGC *text_gc[5];
+  GdkGC *base_gc[5];
+  GdkGC *text_aa_gc[5];
+  GdkGC *black_gc;
+  GdkGC *white_gc;
+
+  GdkPixmap *bg_pixmap[5];
+} GtkStyle;
+
+typedef struct _GtkWidget GtkWidget;
+struct _GtkWidget
+{
+  GtkObject object;
+  guint16 private_flags;
+  guint8 state;
+  guint8 saved_state;
+  gchar *name;
+  GtkStyle *style;
+  GtkRequisition requisition;
+  GtkAllocation allocation;
+  GdkWindow *window;
+  GtkWidget *parent;
+};
+
+typedef struct
+{
+  GtkWidget widget;
+
+  gfloat xalign;
+  gfloat yalign;
+
+  guint16 xpad;
+  guint16 ypad;
+} GtkMisc;
+
+typedef struct {
+  GtkWidget widget;
+  GtkWidget *focus_child;
+  guint border_width : 16;
+  guint need_resize : 1;
+  guint resize_mode : 2;
+  guint reallocate_redraws : 1;
+  guint has_focus_chain : 1;
+} GtkContainer;
+
+typedef struct {
+  GtkContainer container;
+  GtkWidget *child;
+} GtkBin;
+
+typedef struct {
+  GtkBin bin;
+  GdkWindow *event_window;
+  gchar *label_text;
+  guint activate_timeout;
+  guint constructed : 1;
+  guint in_button : 1;
+  guint button_down : 1;
+  guint relief : 2;
+  guint use_underline : 1;
+  guint use_stock : 1;
+  guint depressed : 1;
+  guint depress_on_activate : 1;
+  guint focus_on_click : 1;
+} GtkButton;
+
+typedef struct {
+  GtkButton button;
+  guint active : 1;
+  guint draw_indicator : 1;
+  guint inconsistent : 1;
+} GtkToggleButton;
+
+typedef struct _GtkAdjustment GtkAdjustment;
+struct _GtkAdjustment
+{
+  GtkObject parent_instance;
+
+  gdouble lower;
+  gdouble upper;
+  gdouble value;
+  gdouble step_increment;
+  gdouble page_increment;
+  gdouble page_size;
+};
+
+typedef enum
+{
+  GTK_UPDATE_CONTINUOUS,
+  GTK_UPDATE_DISCONTINUOUS,
+  GTK_UPDATE_DELAYED
+} GtkUpdateType;
+
+typedef struct _GtkRange GtkRange;
+struct _GtkRange
+{
+  GtkWidget widget;
+  GtkAdjustment *adjustment;
+  GtkUpdateType update_policy;
+  guint inverted : 1;
+  /*< protected >*/
+  guint flippable : 1;
+  guint has_stepper_a : 1;
+  guint has_stepper_b : 1;
+  guint has_stepper_c : 1;
+  guint has_stepper_d : 1;
+  guint need_recalc : 1;
+  guint slider_size_fixed : 1;
+  gint min_slider_size;
+  GtkOrientation orientation;
+  GdkRectangle range_rect;
+  gint slider_start, slider_end;
+  gint round_digits;
+  /*< private >*/
+  guint trough_click_forward : 1;
+  guint update_pending : 1;
+  /*GtkRangeLayout * */ void *layout;
+  /*GtkRangeStepTimer * */ void* timer;
+  gint slide_initial_slider_position;
+  gint slide_initial_coordinate;
+  guint update_timeout_id;
+  GdkWindow *event_window;
+};
+
+typedef struct _GtkProgressBar       GtkProgressBar;
+
+typedef enum
+{
+  GTK_PROGRESS_CONTINUOUS,
+  GTK_PROGRESS_DISCRETE
+} GtkProgressBarStyle;
+
+typedef enum
+{
+  GTK_PROGRESS_LEFT_TO_RIGHT,
+  GTK_PROGRESS_RIGHT_TO_LEFT,
+  GTK_PROGRESS_BOTTOM_TO_TOP,
+  GTK_PROGRESS_TOP_TO_BOTTOM
+} GtkProgressBarOrientation;
+
+typedef struct _GtkProgress       GtkProgress;
+
+struct _GtkProgress
+{
+  GtkWidget widget;
+  GtkAdjustment *adjustment;
+  GdkPixmap     *offscreen_pixmap;
+  gchar         *format;
+  gfloat         x_align;
+  gfloat         y_align;
+  guint          show_text : 1;
+  guint          activity_mode : 1;
+  guint          use_text_format : 1;
+};
+
+struct _GtkProgressBar
+{
+  GtkProgress progress;
+  GtkProgressBarStyle bar_style;
+  GtkProgressBarOrientation orientation;
+  guint blocks;
+  gint  in_block;
+  gint  activity_pos;
+  guint activity_step;
+  guint activity_blocks;
+  gdouble pulse_fraction;
+  guint activity_dir : 1;
+  guint ellipsize : 3;
+};
+
+typedef enum {
+  GTK_RESPONSE_NONE = -1,
+  GTK_RESPONSE_REJECT = -2,
+  GTK_RESPONSE_ACCEPT = -3,
+  GTK_RESPONSE_DELETE_EVENT = -4,
+  GTK_RESPONSE_OK = -5,
+  GTK_RESPONSE_CANCEL = -6,
+  GTK_RESPONSE_CLOSE = -7,
+  GTK_RESPONSE_YES = -8,
+  GTK_RESPONSE_NO = -9,
+  GTK_RESPONSE_APPLY = -10,
+  GTK_RESPONSE_HELP = -11
+} GtkResponseType;
+
+typedef struct _GtkWindow GtkWindow;
+
+typedef struct _GtkFileChooser GtkFileChooser;
+
+typedef enum {
+  GTK_FILE_CHOOSER_ACTION_OPEN,
+  GTK_FILE_CHOOSER_ACTION_SAVE,
+  GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
+  GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
+} GtkFileChooserAction;
+
+typedef struct _GtkFileFilter GtkFileFilter;
+
+typedef enum {
+  GTK_FILE_FILTER_FILENAME = 1 << 0,
+  GTK_FILE_FILTER_URI = 1 << 1,
+  GTK_FILE_FILTER_DISPLAY_NAME = 1 << 2,
+  GTK_FILE_FILTER_MIME_TYPE = 1 << 3
+} GtkFileFilterFlags;
+
+typedef struct {
+  GtkFileFilterFlags contains;
+  const gchar *filename;
+  const gchar *uri;
+  const gchar *display_name;
+  const gchar *mime_type;
+} GtkFileFilterInfo;
+
+typedef gboolean (*GtkFileFilterFunc)(const GtkFileFilterInfo *filter_info,
+    gpointer data);
+
+typedef void (*GDestroyNotify)(gpointer data);
+
+typedef void (*GCallback)(void);
+
+typedef struct _GClosure GClosure;
+
+typedef void (*GClosureNotify)(gpointer data, GClosure *closure);
+
+typedef enum {
+  G_CONNECT_AFTER = 1 << 0, G_CONNECT_SWAPPED = 1 << 1
+} GConnectFlags;
+
+typedef struct _GThreadFunctions GThreadFunctions;
+
+#define G_TYPE_INVALID                  G_TYPE_MAKE_FUNDAMENTAL (0)
+#define G_TYPE_NONE                     G_TYPE_MAKE_FUNDAMENTAL (1)
+#define G_TYPE_INTERFACE                G_TYPE_MAKE_FUNDAMENTAL (2)
+#define G_TYPE_CHAR                     G_TYPE_MAKE_FUNDAMENTAL (3)
+#define G_TYPE_UCHAR                    G_TYPE_MAKE_FUNDAMENTAL (4)
+#define G_TYPE_BOOLEAN                  G_TYPE_MAKE_FUNDAMENTAL (5)
+#define G_TYPE_INT                      G_TYPE_MAKE_FUNDAMENTAL (6)
+#define G_TYPE_UINT                     G_TYPE_MAKE_FUNDAMENTAL (7)
+#define G_TYPE_LONG                     G_TYPE_MAKE_FUNDAMENTAL (8)
+#define G_TYPE_ULONG                    G_TYPE_MAKE_FUNDAMENTAL (9)
+#define G_TYPE_INT64                    G_TYPE_MAKE_FUNDAMENTAL (10)
+#define G_TYPE_UINT64                   G_TYPE_MAKE_FUNDAMENTAL (11)
+#define G_TYPE_ENUM                     G_TYPE_MAKE_FUNDAMENTAL (12)
+#define G_TYPE_FLAGS                    G_TYPE_MAKE_FUNDAMENTAL (13)
+#define G_TYPE_FLOAT                    G_TYPE_MAKE_FUNDAMENTAL (14)
+#define G_TYPE_DOUBLE                   G_TYPE_MAKE_FUNDAMENTAL (15)
+#define G_TYPE_STRING                   G_TYPE_MAKE_FUNDAMENTAL (16)
+#define G_TYPE_POINTER                  G_TYPE_MAKE_FUNDAMENTAL (17)
+#define G_TYPE_BOXED                    G_TYPE_MAKE_FUNDAMENTAL (18)
+#define G_TYPE_PARAM                    G_TYPE_MAKE_FUNDAMENTAL (19)
+#define G_TYPE_OBJECT                   G_TYPE_MAKE_FUNDAMENTAL (20)
+
+#define GTK_TYPE_BORDER                 gtk_border_get_type()
+
+#define G_TYPE_FUNDAMENTAL_SHIFT        (2)
+#define G_TYPE_MAKE_FUNDAMENTAL(x)      ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT))
+
+#define g_signal_connect(instance, detailed_signal, c_handler, data) \
+ g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, (GConnectFlags) 0)
+
+#endif /* __GTK_H__ */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/solaris/native/sun/awt/gtk2/gtk_fp.c	Fri Aug 12 09:18:57 2011 +0100
@@ -0,0 +1,385 @@
+/*
+ * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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 General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+#include <dlfcn.h>
+#include <setjmp.h>
+#include <stddef.h>
+
+#include "gtk_fp.h"
+
+#define GTK2_LIB "libgtk-x11-2.0.so.0"
+#define GTHREAD_LIB "libgthread-2.0.so.0"
+#define NO_SYMBOL_EXCEPTION 1
+
+static gboolean new_combo_used = TRUE;
+static void *gtk2_libhandle = NULL;
+static void *gthread_libhandle = NULL;
+static jmp_buf j;
+
+/* This is a workaround for the bug:
+ * http://sourceware.org/bugzilla/show_bug.cgi?id=1814
+ * (dlsym/dlopen clears dlerror state)
+ * This bug is specific to Linux, but there is no harm in
+ * applying this workaround on Solaris as well.
+ */
+static void* dl_symbol(const char* name)
+{
+    void* result = dlsym(gtk2_libhandle, name);
+    if (!result)
+        longjmp(j, NO_SYMBOL_EXCEPTION);
+
+    return result;
+}
+
+static void* dl_symbol_gthread(const char* name)
+{
+    void* result = dlsym(gthread_libhandle, name);
+    if (!result)
+        longjmp(j, NO_SYMBOL_EXCEPTION);
+
+    return result;
+}
+
+gboolean gtk2_check_dlversion()
+{
+    if (gtk2_libhandle != NULL) {
+        /* We've already successfully opened the GTK libs, so return true. */
+        return TRUE;
+    }
+    void *lib = NULL;
+    gboolean result = FALSE;
+    
+    lib = dlopen(GTK2_LIB, RTLD_LAZY | RTLD_LOCAL);
+    if (lib == NULL) {
+      return FALSE;
+    }
+    
+    fp_gtk_check_version = dlsym(lib, "gtk_check_version");
+    /* Check for GTK 2.2+ */
+    if (!fp_gtk_check_version(2, 2, 0)) {
+      result = TRUE;
+    }
+    
+    dlclose(lib);
+    
+    return result;
+}
+
+/**
+ * Functions for sun_awt_X11_GtkFileDialogPeer.c
+ */
+void gtk2_file_chooser_load()
+{
+    fp_gtk_file_chooser_get_filename = dl_symbol(
+            "gtk_file_chooser_get_filename");
+    fp_gtk_file_chooser_dialog_new = dl_symbol("gtk_file_chooser_dialog_new");
+    fp_gtk_file_chooser_set_current_folder = dl_symbol(
+            "gtk_file_chooser_set_current_folder");
+    fp_gtk_file_chooser_set_filename = dl_symbol(
+            "gtk_file_chooser_set_filename");
+    fp_gtk_file_chooser_set_current_name = dl_symbol(
+            "gtk_file_chooser_set_current_name");
+    fp_gtk_file_filter_add_custom = dl_symbol("gtk_file_filter_add_custom");
+    fp_gtk_file_chooser_set_filter = dl_symbol("gtk_file_chooser_set_filter");
+    fp_gtk_file_chooser_get_type = dl_symbol("gtk_file_chooser_get_type");
+    fp_gtk_file_filter_new = dl_symbol("gtk_file_filter_new");
+    if (fp_gtk_check_version(2, 8, 0) == NULL) {
+        fp_gtk_file_chooser_set_do_overwrite_confirmation = dl_symbol(
+                "gtk_file_chooser_set_do_overwrite_confirmation");
+    }
+    fp_gtk_file_chooser_set_select_multiple = dl_symbol(
+            "gtk_file_chooser_set_select_multiple");
+    fp_gtk_file_chooser_get_current_folder = dl_symbol(
+            "gtk_file_chooser_get_current_folder");
+    fp_gtk_file_chooser_get_filenames = dl_symbol(
+            "gtk_file_chooser_get_filenames");
+    fp_gtk_g_slist_length = dl_symbol("g_slist_length");
+}
+
+gboolean gtk2_dlload()
+{
+    gtk2_libhandle = dlopen(GTK2_LIB, RTLD_LAZY | RTLD_LOCAL);
+    gthread_libhandle = dlopen(GTHREAD_LIB, RTLD_LAZY | RTLD_LOCAL);
+
+    if (gtk2_libhandle == NULL || gthread_libhandle == NULL)
+        return FALSE;
+
+    if (setjmp(j) == 0)
+    {
+        fp_gtk_check_version = dl_symbol("gtk_check_version");
+        /* Check for GTK 2.2+ */
+        if (fp_gtk_check_version(2, 2, 0)) {
+            longjmp(j, NO_SYMBOL_EXCEPTION);
+        }
+
+        /* GLib */
+        fp_g_free = dl_symbol("g_free");
+        fp_g_object_unref = dl_symbol("g_object_unref");
+
+        fp_g_main_context_iteration =
+            dl_symbol("g_main_context_iteration");
+
+        fp_g_value_init = dl_symbol("g_value_init");
+        fp_g_type_is_a = dl_symbol("g_type_is_a");
+
+        fp_g_value_get_boolean = dl_symbol("g_value_get_boolean");
+        fp_g_value_get_char = dl_symbol("g_value_get_char");
+        fp_g_value_get_uchar = dl_symbol("g_value_get_uchar");
+        fp_g_value_get_int = dl_symbol("g_value_get_int");
+        fp_g_value_get_uint = dl_symbol("g_value_get_uint");
+        fp_g_value_get_long = dl_symbol("g_value_get_long");
+        fp_g_value_get_ulong = dl_symbol("g_value_get_ulong");
+        fp_g_value_get_int64 = dl_symbol("g_value_get_int64");
+        fp_g_value_get_uint64 = dl_symbol("g_value_get_uint64");
+        fp_g_value_get_float = dl_symbol("g_value_get_float");
+        fp_g_value_get_double = dl_symbol("g_value_get_double");
+        fp_g_value_get_string = dl_symbol("g_value_get_string");
+        fp_g_value_get_enum = dl_symbol("g_value_get_enum");
+        fp_g_value_get_flags = dl_symbol("g_value_get_flags");
+        fp_g_value_get_param = dl_symbol("g_value_get_param");
+        fp_g_value_get_boxed = dl_symbol("g_value_get_boxed");
+        fp_g_value_get_pointer = dl_symbol("g_value_get_pointer");
+        fp_g_value_get_object = dl_symbol("g_value_get_object");
+        fp_g_param_spec_int = dl_symbol("g_param_spec_int");
+        fp_g_object_get = dl_symbol("g_object_get");
+        fp_g_object_set = dl_symbol("g_object_set");
+
+        /* GDK */
+        fp_gdk_pixmap_new = dl_symbol("gdk_pixmap_new");
+        fp_gdk_pixbuf_get_from_drawable =
+            dl_symbol("gdk_pixbuf_get_from_drawable");
+        fp_gdk_gc_new = dl_symbol("gdk_gc_new");
+        fp_gdk_rgb_gc_set_foreground =
+            dl_symbol("gdk_rgb_gc_set_foreground");
+        fp_gdk_draw_rectangle = dl_symbol("gdk_draw_rectangle");
+        fp_gdk_drawable_get_size = dl_symbol("gdk_drawable_get_size");
+
+        /* Pixbuf */
+        fp_gdk_pixbuf_new = dl_symbol("gdk_pixbuf_new");
+        fp_gdk_pixbuf_new_from_file =
+                dl_symbol("gdk_pixbuf_new_from_file");
+        fp_gdk_pixbuf_get_width = dl_symbol("gdk_pixbuf_get_width");
+        fp_gdk_pixbuf_get_height = dl_symbol("gdk_pixbuf_get_height");
+        fp_gdk_pixbuf_get_pixels = dl_symbol("gdk_pixbuf_get_pixels");
+        fp_gdk_pixbuf_get_rowstride =
+                dl_symbol("gdk_pixbuf_get_rowstride");
+        fp_gdk_pixbuf_get_has_alpha =
+                dl_symbol("gdk_pixbuf_get_has_alpha");
+        fp_gdk_pixbuf_get_bits_per_sample =
+                dl_symbol("gdk_pixbuf_get_bits_per_sample");
+        fp_gdk_pixbuf_get_n_channels =
+                dl_symbol("gdk_pixbuf_get_n_channels");
+
+        /* GTK painting */
+        fp_gtk_init_check = dl_symbol("gtk_init_check");
+        fp_gtk_paint_hline = dl_symbol("gtk_paint_hline");
+        fp_gtk_paint_vline = dl_symbol("gtk_paint_vline");
+        fp_gtk_paint_shadow = dl_symbol("gtk_paint_shadow");
+        fp_gtk_paint_arrow = dl_symbol("gtk_paint_arrow");
+        fp_gtk_paint_diamond = dl_symbol("gtk_paint_diamond");
+        fp_gtk_paint_box = dl_symbol("gtk_paint_box");
+        fp_gtk_paint_flat_box = dl_symbol("gtk_paint_flat_box");
+        fp_gtk_paint_check = dl_symbol("gtk_paint_check");
+        fp_gtk_paint_option = dl_symbol("gtk_paint_option");
+        fp_gtk_paint_box_gap = dl_symbol("gtk_paint_box_gap");
+        fp_gtk_paint_extension = dl_symbol("gtk_paint_extension");
+        fp_gtk_paint_focus = dl_symbol("gtk_paint_focus");
+        fp_gtk_paint_slider = dl_symbol("gtk_paint_slider");
+        fp_gtk_paint_handle = dl_symbol("gtk_paint_handle");
+        fp_gtk_paint_expander = dl_symbol("gtk_paint_expander");
+        fp_gtk_style_apply_default_background =
+                dl_symbol("gtk_style_apply_default_background");
+
+        /* GTK widgets */
+        fp_gtk_arrow_new = dl_symbol("gtk_arrow_new");
+        fp_gtk_button_new = dl_symbol("gtk_button_new");
+        fp_gtk_spin_button_new = dl_symbol("gtk_spin_button_new");
+        fp_gtk_check_button_new = dl_symbol("gtk_check_button_new");
+        fp_gtk_check_menu_item_new =
+                dl_symbol("gtk_check_menu_item_new");
+        fp_gtk_color_selection_dialog_new =
+                dl_symbol("gtk_color_selection_dialog_new");
+        fp_gtk_entry_new = dl_symbol("gtk_entry_new");
+        fp_gtk_fixed_new = dl_symbol("gtk_fixed_new");
+        fp_gtk_handle_box_new = dl_symbol("gtk_handle_box_new");
+        fp_gtk_image_new = dl_symbol("gtk_image_new");
+        fp_gtk_hpaned_new = dl_symbol("gtk_hpaned_new");
+        fp_gtk_vpaned_new = dl_symbol("gtk_vpaned_new");
+        fp_gtk_hscale_new = dl_symbol("gtk_hscale_new");
+        fp_gtk_vscale_new = dl_symbol("gtk_vscale_new");
+        fp_gtk_hscrollbar_new = dl_symbol("gtk_hscrollbar_new");
+        fp_gtk_vscrollbar_new = dl_symbol("gtk_vscrollbar_new");
+        fp_gtk_hseparator_new = dl_symbol("gtk_hseparator_new");
+        fp_gtk_vseparator_new = dl_symbol("gtk_vseparator_new");
+        fp_gtk_label_new = dl_symbol("gtk_label_new");
+        fp_gtk_menu_new = dl_symbol("gtk_menu_new");
+        fp_gtk_menu_bar_new = dl_symbol("gtk_menu_bar_new");
+        fp_gtk_menu_item_new = dl_symbol("gtk_menu_item_new");
+        fp_gtk_menu_item_set_submenu =
+                dl_symbol("gtk_menu_item_set_submenu");
+        fp_gtk_notebook_new = dl_symbol("gtk_notebook_new");
+        fp_gtk_progress_bar_new =
+            dl_symbol("gtk_progress_bar_new");
+        fp_gtk_progress_bar_set_orientation =
+            dl_symbol("gtk_progress_bar_set_orientation");
+        fp_gtk_radio_button_new =
+            dl_symbol("gtk_radio_button_new");
+        fp_gtk_radio_menu_item_new =
+            dl_symbol("gtk_radio_menu_item_new");
+        fp_gtk_scrolled_window_new =
+            dl_symbol("gtk_scrolled_window_new");
+        fp_gtk_separator_menu_item_new =
+            dl_symbol("gtk_separator_menu_item_new");
+        fp_gtk_text_view_new = dl_symbol("gtk_text_view_new");
+        fp_gtk_toggle_button_new =
+            dl_symbol("gtk_toggle_button_new");
+        fp_gtk_toolbar_new = dl_symbol("gtk_toolbar_new");
+        fp_gtk_tree_view_new = dl_symbol("gtk_tree_view_new");
+        fp_gtk_viewport_new = dl_symbol("gtk_viewport_new");
+        fp_gtk_window_new = dl_symbol("gtk_window_new");
+        fp_gtk_window_present = dl_symbol("gtk_window_present");
+        fp_gtk_window_move = dl_symbol("gtk_window_move");
+        fp_gtk_window_resize = dl_symbol("gtk_window_resize");
+
+          fp_gtk_dialog_new = dl_symbol("gtk_dialog_new");
+        fp_gtk_frame_new = dl_symbol("gtk_frame_new");
+
+        fp_gtk_adjustment_new = dl_symbol("gtk_adjustment_new");
+        fp_gtk_container_add = dl_symbol("gtk_container_add");
+        fp_gtk_menu_shell_append =
+            dl_symbol("gtk_menu_shell_append");
+        fp_gtk_widget_realize = dl_symbol("gtk_widget_realize");
+        fp_gtk_widget_destroy = dl_symbol("gtk_widget_destroy");
+        fp_gtk_widget_render_icon =
+            dl_symbol("gtk_widget_render_icon");
+        fp_gtk_widget_set_name =
+            dl_symbol("gtk_widget_set_name");
+        fp_gtk_widget_set_parent =
+            dl_symbol("gtk_widget_set_parent");
+        fp_gtk_widget_set_direction =
+            dl_symbol("gtk_widget_set_direction");
+        fp_gtk_widget_style_get =
+            dl_symbol("gtk_widget_style_get");
+        fp_gtk_widget_class_install_style_property =
+            dl_symbol("gtk_widget_class_install_style_property");
+        fp_gtk_widget_class_find_style_property =
+            dl_symbol("gtk_widget_class_find_style_property");
+        fp_gtk_widget_style_get_property =
+            dl_symbol("gtk_widget_style_get_property");
+        fp_pango_font_description_to_string =
+            dl_symbol("pango_font_description_to_string");
+        fp_gtk_settings_get_default =
+            dl_symbol("gtk_settings_get_default");
+        fp_gtk_widget_get_settings =
+            dl_symbol("gtk_widget_get_settings");
+        fp_gtk_border_get_type =  dl_symbol("gtk_border_get_type");
+        fp_gtk_arrow_set = dl_symbol("gtk_arrow_set");
+        fp_gtk_widget_size_request =
+            dl_symbol("gtk_widget_size_request");
+        fp_gtk_range_get_adjustment =
+            dl_symbol("gtk_range_get_adjustment");
+
+        fp_gtk_widget_hide = dl_symbol("gtk_widget_hide");
+        fp_gtk_main_quit = dl_symbol("gtk_main_quit");
+        fp_g_signal_connect_data = dl_symbol("g_signal_connect_data");
+        fp_gtk_widget_show = dl_symbol("gtk_widget_show");
+        fp_gtk_main = dl_symbol("gtk_main");
+
+        /**
+         * GLib thread system
+         */
+        fp_g_thread_init = dl_symbol_gthread("g_thread_init");
+        fp_gdk_threads_init = dl_symbol("gdk_threads_init");
+        fp_gdk_threads_enter = dl_symbol("gdk_threads_enter");
+        fp_gdk_threads_leave = dl_symbol("gdk_threads_leave");
+
+        /**
+         * Functions for sun_awt_X11_GtkFileDialogPeer.c
+         */
+        if (fp_gtk_check_version(2, 4, 0) == NULL) {
+            // The current GtkFileChooser is available from GTK+ 2.4
+            gtk2_file_chooser_load();
+        }
+
+        /* Some functions may be missing in pre-2.4 GTK.
+           We handle them specially here.
+         */
+        fp_gtk_combo_box_new = dlsym(gtk2_libhandle, "gtk_combo_box_new");
+        if (fp_gtk_combo_box_new == NULL) {
+            fp_gtk_combo_box_new = dl_symbol("gtk_combo_new");
+        }
+
+        fp_gtk_combo_box_entry_new =
+            dlsym(gtk2_libhandle, "gtk_combo_box_entry_new");
+        if (fp_gtk_combo_box_entry_new == NULL) {
+            fp_gtk_combo_box_entry_new = dl_symbol("gtk_combo_new");
+            new_combo_used = FALSE;
+        }
+
+        fp_gtk_separator_tool_item_new =
+            dlsym(gtk2_libhandle, "gtk_separator_tool_item_new");
+        if (fp_gtk_separator_tool_item_new == NULL) {
+            fp_gtk_separator_tool_item_new =
+                dl_symbol("gtk_vseparator_new");
+        }
+    }
+    /* Now we have only one kind of exceptions: NO_SYMBOL_EXCEPTION
+     * Otherwise we can check the return value of setjmp method.
+     */
+    else
+    {
+        dlclose(gtk2_libhandle);
+        gtk2_libhandle = NULL;
+
+        dlclose(gthread_libhandle);
+        gthread_libhandle = NULL;
+
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+int gtk2_dlunload()
+{
+    char *gtk2_error;
+
+    if (!gtk2_libhandle)
+        return TRUE;
+
+    dlerror();
+    dlclose(gtk2_libhandle);
+    dlclose(gthread_libhandle);
+    if ((gtk2_error = dlerror()) != NULL)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+gboolean new_combo()
+{
+  return new_combo_used;
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/solaris/native/sun/awt/gtk2/gtk_fp.h	Fri Aug 12 09:18:57 2011 +0100
@@ -0,0 +1,469 @@
+/*
+ * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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 General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+#ifndef __GTK_FP_H__
+#define __GTK_FP_H__
+
+#include <gtk/gtk.h>
+
+gboolean gtk2_check_dlversion();
+gboolean gtk2_dlload();
+int gtk2_dlunload();
+gboolean new_combo();
+
+/*************************
+ * Glib function pointers
+ *************************/
+
+gboolean (*fp_g_main_context_iteration)(GMainContext *context,
+                                             gboolean may_block);
+
+GValue*      (*fp_g_value_init)(GValue *value, GType g_type);
+gboolean     (*fp_g_type_is_a)(GType type, GType is_a_type);
+gboolean     (*fp_g_value_get_boolean)(const GValue *value);
+gchar        (*fp_g_value_get_char)(const GValue *value);
+guchar       (*fp_g_value_get_uchar)(const GValue *value);
+gint         (*fp_g_value_get_int)(const GValue *value);
+guint        (*fp_g_value_get_uint)(const GValue *value);
+glong        (*fp_g_value_get_long)(const GValue *value);
+gulong       (*fp_g_value_get_ulong)(const GValue *value);
+gint64       (*fp_g_value_get_int64)(const GValue *value);
+guint64      (*fp_g_value_get_uint64)(const GValue *value);
+gfloat       (*fp_g_value_get_float)(const GValue *value);
+gdouble      (*fp_g_value_get_double)(const GValue *value);
+const gchar* (*fp_g_value_get_string)(const GValue *value);
+gint         (*fp_g_value_get_enum)(const GValue *value);
+guint        (*fp_g_value_get_flags)(const GValue *value);
+GParamSpec*  (*fp_g_value_get_param)(const GValue *value);
+gpointer*    (*fp_g_value_get_boxed)(const GValue *value);
+gpointer*    (*fp_g_value_get_pointer)(const GValue *value);
+GObject*     (*fp_g_value_get_object)(const GValue *value);
+GParamSpec*  (*fp_g_param_spec_int)(const gchar *name,
+        const gchar *nick, const gchar *blurb,
+        gint minimum, gint maximum, gint default_value,
+        GParamFlags flags);
+void         (*fp_g_object_get)(gpointer object,
+                                       const gchar* fpn, ...);
+void         (*fp_g_object_set)(gpointer object,
+                                       const gchar *first_property_name,
+                                       ...);
+/************************
+ * GDK function pointers
+ ************************/
+GdkPixmap *(*fp_gdk_pixmap_new)(GdkDrawable *drawable,
+        gint width, gint height, gint depth);
+GdkGC *(*fp_gdk_gc_new)(GdkDrawable*);
+void (*fp_gdk_rgb_gc_set_foreground)(GdkGC*, guint32);
+void (*fp_gdk_draw_rectangle)(GdkDrawable*, GdkGC*, gboolean,
+        gint, gint, gint, gint);
+GdkPixbuf *(*fp_gdk_pixbuf_new)(GdkColorspace colorspace,
+        gboolean has_alpha, int bits_per_sample, int width, int height);
+GdkPixbuf *(*fp_gdk_pixbuf_get_from_drawable)(GdkPixbuf *dest,
+        GdkDrawable *src, GdkColormap *cmap, int src_x, int src_y,
+        int dest_x, int dest_y, int width, int height);
+void (*fp_gdk_drawable_get_size)(GdkDrawable *drawable,
+        gint* width, gint* height);
+
+/************************
+ * Gtk function pointers
+ ************************/
+gboolean (*fp_gtk_init_check)(int* argc, char** argv);
+
+/* Painting */
+void (*fp_gtk_paint_hline)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GdkRectangle* area, GtkWidget* widget,
+        const gchar* detail, gint x1, gint x2, gint y);
+void (*fp_gtk_paint_vline)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GdkRectangle* area, GtkWidget* widget,
+        const gchar* detail, gint y1, gint y2, gint x);
+void (*fp_gtk_paint_shadow)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        gint x, gint y, gint width, gint height);
+void (*fp_gtk_paint_arrow)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        GtkArrowType arrow_type, gboolean fill, gint x, gint y,
+        gint width, gint height);
+void (*fp_gtk_paint_diamond)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        gint x, gint y, gint width, gint height);
+void (*fp_gtk_paint_box)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        gint x, gint y, gint width, gint height);
+void (*fp_gtk_paint_flat_box)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        gint x, gint y, gint width, gint height);
+void (*fp_gtk_paint_check)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        gint x, gint y, gint width, gint height);
+void (*fp_gtk_paint_option)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        gint x, gint y, gint width, gint height);
+void (*fp_gtk_paint_box_gap)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        gint x, gint y, gint width, gint height,
+        GtkPositionType gap_side, gint gap_x, gint gap_width);
+void (*fp_gtk_paint_extension)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        gint x, gint y, gint width, gint height, GtkPositionType gap_side);
+void (*fp_gtk_paint_focus)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GdkRectangle* area, GtkWidget* widget,
+        const gchar* detail, gint x, gint y, gint width, gint height);
+void (*fp_gtk_paint_slider)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        gint x, gint y, gint width, gint height, GtkOrientation orientation);
+void (*fp_gtk_paint_handle)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GtkShadowType shadow_type,
+        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
+        gint x, gint y, gint width, gint height, GtkOrientation orientation);
+void (*fp_gtk_paint_expander)(GtkStyle* style, GdkWindow* window,
+        GtkStateType state_type, GdkRectangle* area, GtkWidget* widget,
+        const gchar* detail, gint x, gint y, GtkExpanderStyle expander_style);
+void (*fp_gtk_style_apply_default_background)(GtkStyle* style,
+        GdkWindow* window, gboolean set_bg, GtkStateType state_type,
+        GdkRectangle* area, gint x, gint y, gint width, gint height);
+
+/* Widget creation */
+GtkWidget* (*fp_gtk_arrow_new)(GtkArrowType arrow_type,
+                                      GtkShadowType shadow_type);
+GtkWidget* (*fp_gtk_button_new)();
+GtkWidget* (*fp_gtk_check_button_new)();
+GtkWidget* (*fp_gtk_check_menu_item_new)();
+GtkWidget* (*fp_gtk_color_selection_dialog_new)(const gchar* title);
+GtkWidget* (*fp_gtk_combo_box_new)();
+GtkWidget* (*fp_gtk_combo_box_entry_new)();
+GtkWidget* (*fp_gtk_entry_new)();
+GtkWidget* (*fp_gtk_fixed_new)();
+GtkWidget* (*fp_gtk_handle_box_new)();
+GtkWidget* (*fp_gtk_hpaned_new)();
+GtkWidget* (*fp_gtk_vpaned_new)();
+GtkWidget* (*fp_gtk_hscale_new)(GtkAdjustment* adjustment);
+GtkWidget* (*fp_gtk_vscale_new)(GtkAdjustment* adjustment);
+GtkWidget* (*fp_gtk_hscrollbar_new)(GtkAdjustment* adjustment);
+GtkWidget* (*fp_gtk_vscrollbar_new)(GtkAdjustment* adjustment);
+GtkWidget* (*fp_gtk_hseparator_new)();
+GtkWidget* (*fp_gtk_vseparator_new)();
+GtkWidget* (*fp_gtk_image_new)();
+GtkWidget* (*fp_gtk_label_new)(const gchar* str);
+GtkWidget* (*fp_gtk_menu_new)();
+GtkWidget* (*fp_gtk_menu_bar_new)();
+GtkWidget* (*fp_gtk_menu_item_new)();
+GtkWidget* (*fp_gtk_notebook_new)();
+GtkWidget* (*fp_gtk_progress_bar_new)();
+GtkWidget* (*fp_gtk_progress_bar_set_orientation)(
+        GtkProgressBar *pbar,
+        GtkProgressBarOrientation orientation);
+GtkWidget* (*fp_gtk_radio_button_new)(GSList *group);
+GtkWidget* (*fp_gtk_radio_menu_item_new)(GSList *group);
+GtkWidget* (*fp_gtk_scrolled_window_new)(GtkAdjustment *hadjustment,
+        GtkAdjustment *vadjustment);
+GtkWidget* (*fp_gtk_separator_menu_item_new)();
+GtkWidget* (*fp_gtk_separator_tool_item_new)();
+GtkWidget* (*fp_gtk_text_view_new)();
+GtkWidget* (*fp_gtk_toggle_button_new)();
+GtkWidget* (*fp_gtk_toolbar_new)();
+GtkWidget* (*fp_gtk_tree_view_new)();
+GtkWidget* (*fp_gtk_viewport_new)(GtkAdjustment *hadjustment,
+        GtkAdjustment *vadjustment);
+GtkWidget* (*fp_gtk_window_new)(GtkWindowType type);
+GtkWidget* (*fp_gtk_dialog_new)();
+GtkWidget* (*fp_gtk_spin_button_new)(GtkAdjustment *adjustment,
+        gdouble climb_rate, guint digits);
+GtkWidget* (*fp_gtk_frame_new)(const gchar *label);
+
+/* Other widget operations */
+GtkObject* (*fp_gtk_adjustment_new)(gdouble value,
+        gdouble lower, gdouble upper, gdouble step_increment,
+        gdouble page_increment, gdouble page_size);
+void (*fp_gtk_container_add)(GtkContainer *window, GtkWidget *widget);
+void (*fp_gtk_menu_shell_append)(GtkMenuShell *menu_shell,
+        GtkWidget *child);
+void (*fp_gtk_menu_item_set_submenu)(GtkMenuItem *menu_item,
+        GtkWidget *submenu);
+void (*fp_gtk_widget_realize)(GtkWidget *widget);
+GdkPixbuf* (*fp_gtk_widget_render_icon)(GtkWidget *widget,
+        const gchar *stock_id, GtkIconSize size, const gchar *detail);
+void (*fp_gtk_widget_set_name)(GtkWidget *widget, const gchar *name);
+void (*fp_gtk_widget_set_parent)(GtkWidget *widget, GtkWidget *parent);
+void (*fp_gtk_widget_set_direction)(GtkWidget *widget,
+        GtkTextDirection direction);
+void (*fp_gtk_widget_style_get)(GtkWidget *widget,
+        const gchar *first_property_name, ...);
+void (*fp_gtk_widget_class_install_style_property)(
+        GtkWidgetClass* class, GParamSpec *pspec);
+GParamSpec* (*fp_gtk_widget_class_find_style_property)(
+        GtkWidgetClass* class, const gchar* property_name);
+void (*fp_gtk_widget_style_get_property)(GtkWidget* widget,
+        const gchar* property_name, GValue* value);
+char* (*fp_pango_font_description_to_string)(
+        const PangoFontDescription* fd);
+GtkSettings* (*fp_gtk_settings_get_default)();
+GtkSettings* (*fp_gtk_widget_get_settings)(GtkWidget *widget);
+GType        (*fp_gtk_border_get_type)();
+void (*fp_gtk_arrow_set)(GtkWidget* arrow,
+                                GtkArrowType arrow_type,
+                                GtkShadowType shadow_type);
+void (*fp_gtk_widget_size_request)(GtkWidget *widget,
+                                          GtkRequisition *requisition);
+GtkAdjustment* (*fp_gtk_range_get_adjustment)(GtkRange* range);
+
+void (*fp_g_free)(gpointer mem);
+void (*fp_g_object_unref)(gpointer object);
+int (*fp_gdk_pixbuf_get_bits_per_sample)(const GdkPixbuf *pixbuf);
+guchar *(*fp_gdk_pixbuf_get_pixels)(const GdkPixbuf *pixbuf);
+gboolean (*fp_gdk_pixbuf_get_has_alpha)(const GdkPixbuf *pixbuf);
+int (*fp_gdk_pixbuf_get_height)(const GdkPixbuf *pixbuf);
+int (*fp_gdk_pixbuf_get_n_channels)(const GdkPixbuf *pixbuf);
+int (*fp_gdk_pixbuf_get_rowstride)(const GdkPixbuf *pixbuf);
+int (*fp_gdk_pixbuf_get_width)(const GdkPixbuf *pixbuf);
+GdkPixbuf *(*fp_gdk_pixbuf_new_from_file)(const char *filename, GError **error);
+void (*fp_gtk_widget_destroy)(GtkWidget *widget);
+void (*fp_gtk_window_present)(GtkWindow *window);
+void (*fp_gtk_window_move)(GtkWindow *window, gint x, gint y);
+void (*fp_gtk_window_resize)(GtkWindow *window, gint width, gint height);
+
+/**
+ * Function Pointers for GtkFileChooser
+ */
+gchar* (*fp_gtk_file_chooser_get_filename)(GtkFileChooser *chooser);
+void (*fp_gtk_widget_hide)(GtkWidget *widget);
+void (*fp_gtk_main_quit)(void);
+GtkWidget* (*fp_gtk_file_chooser_dialog_new)(const gchar *title,
+    GtkWindow *parent, GtkFileChooserAction action,
+    const gchar *first_button_text, ...);
+gboolean (*fp_gtk_file_chooser_set_current_folder)(GtkFileChooser *chooser,
+    const gchar *filename);
+gboolean (*fp_gtk_file_chooser_set_filename)(GtkFileChooser *chooser,
+    const char *filename);
+void (*fp_gtk_file_chooser_set_current_name)(GtkFileChooser *chooser,
+    const gchar *name);
+void (*fp_gtk_file_filter_add_custom)(GtkFileFilter *filter,
+    GtkFileFilterFlags needed, GtkFileFilterFunc func, gpointer data,
+    GDestroyNotify notify);
+void (*fp_gtk_file_chooser_set_filter)(GtkFileChooser *chooser,
+    GtkFileFilter *filter);
+GType (*fp_gtk_file_chooser_get_type)(void);
+GtkFileFilter* (*fp_gtk_file_filter_new)(void);
+void (*fp_gtk_file_chooser_set_do_overwrite_confirmation)(
+    GtkFileChooser *chooser, gboolean do_overwrite_confirmation);
+void (*fp_gtk_file_chooser_set_select_multiple)(
+    GtkFileChooser *chooser, gboolean select_multiple);
+gchar* (*fp_gtk_file_chooser_get_current_folder)(GtkFileChooser *chooser);
+GSList* (*fp_gtk_file_chooser_get_filenames)(GtkFileChooser *chooser);
+guint (*fp_gtk_g_slist_length)(GSList *list);
+gulong (*fp_g_signal_connect_data)(gpointer instance,
+    const gchar *detailed_signal, GCallback c_handler, gpointer data,
+    GClosureNotify destroy_data, GConnectFlags connect_flags);
+void (*fp_gtk_widget_show)(GtkWidget *widget);
+void (*fp_gtk_main)(void);
+guint (*fp_gtk_main_level)(void);
+
+/**
+ * Returns :
+ * NULL if the GTK+ library is compatible with the given version, or a string
+ * describing the version mismatch.
+ */
+gchar* (*fp_gtk_check_version)(guint required_major, guint required_minor,
+				      guint required_micro);
+
+void (*fp_g_thread_init)(GThreadFunctions *vtable);
+void (*fp_gdk_threads_init)(void);
+void (*fp_gdk_threads_enter)(void);
+void (*fp_gdk_threads_leave)(void);
+
+/* Glib */
+#define g_main_context_iteration (*fp_g_main_context_iteration)
+#define g_value_init (*fp_g_value_init)
+#define g_type_is_a (*fp_g_type_is_a)
+#define g_value_get_boolean (*fp_g_value_get_boolean)
+#define g_value_get_char (*fp_g_value_get_char)
+#define g_value_get_uchar (*fp_g_value_get_uchar)
+#define g_value_get_int (*fp_g_value_get_int)
+#define g_value_get_uint (*fp_g_value_get_uint)
+#define g_value_get_long (*fp_g_value_get_long)
+#define g_value_get_ulong (*fp_g_value_get_ulong)
+#define g_value_get_int64 (*fp_g_value_get_int64)
+#define g_value_get_uint64 (*fp_g_value_get_uint64)
+#define g_value_get_float (*fp_g_value_get_float)
+#define g_value_get_double (*fp_g_value_get_double)
+#define g_value_get_string (*fp_g_value_get_string)
+#define g_value_get_enum (*fp_g_value_get_enum)
+#define g_value_get_flags (*fp_g_value_get_flags)
+#define g_value_get_param (*fp_g_value_get_param)
+#define g_value_get_boxed (*fp_g_value_get_boxed)
+#define g_value_get_object (*fp_g_value_get_object)
+#define g_param_spec_int (*fp_g_param_spec_int)
+#define g_object_get (*fp_g_object_get)
+#define g_object_set (*fp_g_object_set)
+#define g_thread_init (*fp_g_thread_init)
+#define g_object_unref (*fp_g_object_unref)
+#define g_free (*fp_g_free)
+#define g_slist_length (*fp_gtk_g_slist_length)
+#define g_signal_connect_data (*fp_g_signal_connect_data)
+
+/* GDK */
+#define gdk_pixmap_new (*fp_gdk_pixmap_new)
+#define gdk_gc_new (*fp_gdk_gc_new)
+#define gdk_rgb_gc_set_foreground (*fp_gdk_rgb_gc_set_foreground)
+#define gdk_draw_rectangle (*fp_gdk_draw_rectangle)
+#define gdk_pixbuf_get_from_drawable (*fp_gdk_pixbuf_get_from_drawable)
+#define gdk_drawable_get_size (*fp_gdk_drawable_get_size)
+#define gdk_threads_leave (*fp_gdk_threads_leave)
+#define gdk_threads_init (*fp_gdk_threads_init)
+#define gdk_threads_enter (*fp_gdk_threads_enter)
+
+/************************
+ * Gtk function pointers
+ ************************/
+#define gtk_init_check (*fp_gtk_init_check)
+
+/* Painting */
+#define gtk_paint_hline (*fp_gtk_paint_hline)
+#define gtk_paint_vline (*fp_gtk_paint_vline)
+#define gtk_paint_shadow (*fp_gtk_paint_shadow)
+#define gtk_paint_arrow (*fp_gtk_paint_arrow)
+#define gtk_paint_diamond (*fp_gtk_paint_diamond)
+#define gtk_paint_box (*fp_gtk_paint_box)
+#define gtk_paint_flat_box (*fp_gtk_paint_flat_box)
+#define gtk_paint_check (*fp_gtk_paint_check)
+#define gtk_paint_option (*fp_gtk_paint_option)
+#define gtk_paint_box_gap (*fp_gtk_paint_box_gap)
+#define gtk_paint_extension (*fp_gtk_paint_extension)
+#define gtk_paint_focus (*fp_gtk_paint_focus)
+#define gtk_paint_slider (*fp_gtk_paint_slider)
+#define gtk_paint_handle (*fp_gtk_paint_handle)
+#define gtk_paint_expander (*fp_gtk_paint_expander)
+#define gtk_style_apply_default_background (*fp_gtk_style_apply_default_background)
+
+/* Widget creation */
+#define gtk_arrow_new (*fp_gtk_arrow_new)
+#define gtk_button_new (*fp_gtk_button_new)
+#define gtk_check_button_new (*fp_gtk_check_button_new)
+#define gtk_check_menu_item_new (*fp_gtk_check_menu_item_new)
+#define gtk_color_selection_dialog_new (*fp_gtk_color_selection_dialog_new)
+#define gtk_combo_box_new (*fp_gtk_combo_box_new)
+#define gtk_combo_box_entry_new (*fp_gtk_combo_box_entry_new)
+#define gtk_entry_new (*fp_gtk_entry_new)
+#define gtk_fixed_new (*fp_gtk_fixed_new)
+#define gtk_handle_box_new (*fp_gtk_handle_box_new)
+#define gtk_hpaned_new (*fp_gtk_hpaned_new)
+#define gtk_vpaned_new (*fp_gtk_vpaned_new)
+#define gtk_hscale_new (*fp_gtk_hscale_new)
+#define gtk_vscale_new (*fp_gtk_vscale_new)
+#define gtk_hscrollbar_new (*fp_gtk_hscrollbar_new)
+#define gtk_vscrollbar_new (*fp_gtk_vscrollbar_new)
+#define gtk_hseparator_new (*fp_gtk_hseparator_new)
+#define gtk_vseparator_new (*fp_gtk_vseparator_new)
+#define gtk_image_new (*fp_gtk_image_new)
+#define gtk_label_new (*fp_gtk_label_new)
+#define gtk_menu_new (*fp_gtk_menu_new)
+#define gtk_menu_bar_new (*fp_gtk_menu_bar_new)
+#define gtk_menu_item_new (*fp_gtk_menu_item_new)
+#define gtk_notebook_new (*fp_gtk_notebook_new)
+#define gtk_progress_bar_new (*fp_gtk_progress_bar_new)
+#define gtk_progress_bar_set_orientation (*fp_gtk_progress_bar_set_orientation)
+#define gtk_radio_button_new (*fp_gtk_radio_button_new)
+#define gtk_radio_menu_item_new (*fp_gtk_radio_menu_item_new)
+#define gtk_scrolled_window_new (*fp_gtk_scrolled_window_new)
+#define gtk_separator_menu_item_new (*fp_gtk_separator_menu_item_new)
+#define gtk_separator_tool_item_new (*fp_gtk_separator_tool_item_new)
+#define gtk_text_view_new (*fp_gtk_text_view_new)
+#define gtk_toggle_button_new (*fp_gtk_toggle_button_new)
+#define gtk_toolbar_new (*fp_gtk_toolbar_new)
+#define gtk_tree_view_new (*fp_gtk_tree_view_new)
+#define gtk_viewport_new (*fp_gtk_viewport_new)
+#define gtk_window_new (*fp_gtk_window_new)
+#define gtk_dialog_new (*fp_gtk_dialog_new)
+#define gtk_spin_button_new (*fp_gtk_spin_button_new)
+#define gtk_frame_new (*fp_gtk_frame_new)
+
+/* Other widget operations */
+#define gtk_adjustment_new (*fp_gtk_adjustment_new)
+#define gtk_container_add (*fp_gtk_container_add)
+#define gtk_menu_shell_append (*fp_gtk_menu_shell_append)
+#define gtk_menu_item_set_submenu (*fp_gtk_menu_item_set_submenu)
+#define gtk_widget_realize (*fp_gtk_widget_realize)
+#define gtk_widget_render_icon (*fp_gtk_widget_render_icon)
+#define gtk_widget_set_name (*fp_gtk_widget_set_name)
+#define gtk_widget_set_parent (*fp_gtk_widget_set_parent)
+#define gtk_widget_set_direction (*fp_gtk_widget_set_direction)
+#define gtk_widget_style_get (*fp_gtk_widget_style_get)
+#define gtk_widget_class_install_style_property (*fp_gtk_widget_class_install_style_property)
+#define gtk_widget_class_find_style_property (*fp_gtk_widget_class_find_style_property)
+#define gtk_widget_style_get_property (*fp_gtk_widget_style_get_property)
+#define pango_font_description_to_string (*fp_pango_font_description_to_string)
+#define gtk_settings_get_default (*fp_gtk_settings_get_default)
+#define gtk_widget_get_settings (*fp_gtk_widget_get_settings)
+#define gtk_border_get_type (*fp_gtk_border_get_type)
+#define gtk_arrow_set (*fp_gtk_arrow_set)
+#define gtk_widget_size_request (*fp_gtk_widget_size_request)
+#define gtk_range_get_adjustment (*fp_gtk_range_get_adjustment)
+#define gtk_widget_destroy (*fp_gtk_widget_destroy)
+#define gtk_window_present (*fp_gtk_window_present)
+#define gtk_window_move (*fp_gtk_window_move)
+#define gtk_window_resize (*fp_gtk_window_resize)
+#define gtk_widget_show (*fp_gtk_widget_show)
+#define gtk_widget_hide (*fp_gtk_widget_hide)
+#define gtk_main (*fp_gtk_main)
+#define gtk_main_level (*fp_gtk_main_level)
+#define gtk_main_quit (*fp_gtk_main_quit)
+#define gtk_check_version (*fp_gtk_check_version)
+#define gtk_init_check (*fp_gtk_init_check)
+
+/* GdkPixbuf */
+#define gdk_pixbuf_get_bits_per_sample (*fp_gdk_pixbuf_get_bits_per_sample)
+#define gdk_pixbuf_get_pixels (*fp_gdk_pixbuf_get_pixels)
+#define gdk_pixbuf_get_has_alpha (*fp_gdk_pixbuf_get_has_alpha)
+#define gdk_pixbuf_get_height (*fp_gdk_pixbuf_get_height)
+#define gdk_pixbuf_get_n_channels (*fp_gdk_pixbuf_get_n_channels)
+#define gdk_pixbuf_get_rowstride (*fp_gdk_pixbuf_get_rowstride)
+#define gdk_pixbuf_get_width (*fp_gdk_pixbuf_get_width)
+#define gdk_pixbuf_new_from_file (*fp_gdk_pixbuf_new_from_file)
+#define gdk_pixbuf_new (*fp_gdk_pixbuf_new)
+
+/* GtkFileChooser */
+#define gtk_file_chooser_get_filename (*fp_gtk_file_chooser_get_filename)
+#define gtk_file_chooser_dialog_new (*fp_gtk_file_chooser_dialog_new)
+#define gtk_file_chooser_set_current_folder (*fp_gtk_file_chooser_set_current_folder)
+#define gtk_file_chooser_set_filename (*fp_gtk_file_chooser_set_filename)
+#define gtk_file_chooser_set_current_name (*fp_gtk_file_chooser_set_current_name)
+#define gtk_file_chooser_set_filter (*fp_gtk_file_chooser_set_filter)
+#define gtk_file_chooser_get_type (*fp_gtk_file_chooser_get_type)
+#define gtk_file_chooser_set_do_overwrite_confirmation (*fp_gtk_file_chooser_set_do_overwrite_confirmation)
+#define gtk_file_chooser_set_select_multiple (*fp_gtk_file_chooser_set_select_multiple)
+#define gtk_file_chooser_get_current_folder (*fp_gtk_file_chooser_get_current_folder)
+#define gtk_file_chooser_get_filenames (*fp_gtk_file_chooser_get_filenames)
+#define gtk_file_filter_add_custom (*fp_gtk_file_filter_add_custom)
+#define gtk_file_filter_new (*fp_gtk_file_filter_new)
+
+#endif /* __GTK_FP_H__ */

--- a/src/solaris/native/sun/awt/gtk2_interface.c	Thu Aug 11 17:22:31 2011 +0200
+++ b/src/solaris/native/sun/awt/gtk2_interface.c	Fri Aug 12 09:18:57 2011 +0100
@@ -22,8 +22,6 @@
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
-#include <dlfcn.h>
-#include <setjmp.h>
 #include <X11/Xlib.h>
 #include <limits.h>
 #include <stdio.h>
@@ -31,41 +29,10 @@
 #include "gtk2_interface.h"
 #include "java_awt_Transparency.h"
 
-#define GTK2_LIB "libgtk-x11-2.0.so.0"
-#define GTHREAD_LIB "libgthread-2.0.so.0"
-
-#define G_TYPE_INVALID                  G_TYPE_MAKE_FUNDAMENTAL (0)
-#define G_TYPE_NONE                     G_TYPE_MAKE_FUNDAMENTAL (1)
-#define G_TYPE_INTERFACE                G_TYPE_MAKE_FUNDAMENTAL (2)
-#define G_TYPE_CHAR                     G_TYPE_MAKE_FUNDAMENTAL (3)
-#define G_TYPE_UCHAR                    G_TYPE_MAKE_FUNDAMENTAL (4)
-#define G_TYPE_BOOLEAN                  G_TYPE_MAKE_FUNDAMENTAL (5)
-#define G_TYPE_INT                      G_TYPE_MAKE_FUNDAMENTAL (6)
-#define G_TYPE_UINT                     G_TYPE_MAKE_FUNDAMENTAL (7)
-#define G_TYPE_LONG                     G_TYPE_MAKE_FUNDAMENTAL (8)
-#define G_TYPE_ULONG                    G_TYPE_MAKE_FUNDAMENTAL (9)
-#define G_TYPE_INT64                    G_TYPE_MAKE_FUNDAMENTAL (10)
-#define G_TYPE_UINT64                   G_TYPE_MAKE_FUNDAMENTAL (11)
-#define G_TYPE_ENUM                     G_TYPE_MAKE_FUNDAMENTAL (12)
-#define G_TYPE_FLAGS                    G_TYPE_MAKE_FUNDAMENTAL (13)
-#define G_TYPE_FLOAT                    G_TYPE_MAKE_FUNDAMENTAL (14)
-#define G_TYPE_DOUBLE                   G_TYPE_MAKE_FUNDAMENTAL (15)
-#define G_TYPE_STRING                   G_TYPE_MAKE_FUNDAMENTAL (16)
-#define G_TYPE_POINTER                  G_TYPE_MAKE_FUNDAMENTAL (17)
-#define G_TYPE_BOXED                    G_TYPE_MAKE_FUNDAMENTAL (18)
-#define G_TYPE_PARAM                    G_TYPE_MAKE_FUNDAMENTAL (19)
-#define G_TYPE_OBJECT                   G_TYPE_MAKE_FUNDAMENTAL (20)
-
-#define GTK_TYPE_BORDER                 ((*fp_gtk_border_get_type)())
-
-#define G_TYPE_FUNDAMENTAL_SHIFT        (2)
-#define G_TYPE_MAKE_FUNDAMENTAL(x)      ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT))
 #define MIN(a, b)  (((a) < (b)) ? (a) : (b))
 
 #define CONV_BUFFER_SIZE 128
 
-#define NO_SYMBOL_EXCEPTION 1
-
 /* SynthConstants */
 const gint ENABLED    = 1 << 0;
 const gint MOUSE_OVER = 1 << 1;
@@ -75,10 +42,7 @@
 const gint SELECTED   = 1 << 9;
 const gint DEFAULT    = 1 << 10;
 
-static void *gtk2_libhandle = NULL;
-static void *gthread_libhandle = NULL;
 static gboolean flag_g_thread_get_initialized = FALSE;
-static jmp_buf j;
 
 /* Widgets */
 static GtkWidget *gtk2_widget = NULL;
@@ -96,8 +60,8 @@
 /* Static buffer for conversion from java.lang.String to UTF-8 */
 static char convertionBuffer[CONV_BUFFER_SIZE];
 
-static gboolean new_combo = TRUE;
 const char ENV_PREFIX[] = "GTK_MODULES=";
+static gboolean initialised = FALSE;
 
 /*******************/
 enum GtkWidgetType
@@ -147,214 +111,8 @@
     _GTK_WIDGET_TYPE_SIZE
 };
 
-
 static GtkWidget *gtk2_widgets[_GTK_WIDGET_TYPE_SIZE];
 
-/*************************
- * Glib function pointers
- *************************/
-
-static gboolean (*fp_g_main_context_iteration)(GMainContext *context,
-                                             gboolean may_block);
-
-static GValue*      (*fp_g_value_init)(GValue *value, GType g_type);
-static gboolean     (*fp_g_type_is_a)(GType type, GType is_a_type);
-static gboolean     (*fp_g_value_get_boolean)(const GValue *value);
-static gchar        (*fp_g_value_get_char)(const GValue *value);
-static guchar       (*fp_g_value_get_uchar)(const GValue *value);
-static gint         (*fp_g_value_get_int)(const GValue *value);
-static guint        (*fp_g_value_get_uint)(const GValue *value);
-static glong        (*fp_g_value_get_long)(const GValue *value);
-static gulong       (*fp_g_value_get_ulong)(const GValue *value);
-static gint64       (*fp_g_value_get_int64)(const GValue *value);
-static guint64      (*fp_g_value_get_uint64)(const GValue *value);
-static gfloat       (*fp_g_value_get_float)(const GValue *value);
-static gdouble      (*fp_g_value_get_double)(const GValue *value);
-static const gchar* (*fp_g_value_get_string)(const GValue *value);
-static gint         (*fp_g_value_get_enum)(const GValue *value);
-static guint        (*fp_g_value_get_flags)(const GValue *value);
-static GParamSpec*  (*fp_g_value_get_param)(const GValue *value);
-static gpointer*    (*fp_g_value_get_boxed)(const GValue *value);
-static gpointer*    (*fp_g_value_get_pointer)(const GValue *value);
-static GObject*     (*fp_g_value_get_object)(const GValue *value);
-static GParamSpec*  (*fp_g_param_spec_int)(const gchar *name,
-        const gchar *nick, const gchar *blurb,
-        gint minimum, gint maximum, gint default_value,
-        GParamFlags flags);
-static void         (*fp_g_object_get)(gpointer object,
-                                       const gchar* fpn, ...);
-static void         (*fp_g_object_set)(gpointer object,
-                                       const gchar *first_property_name,
-                                       ...);
-/************************
- * GDK function pointers
- ************************/
-static GdkPixmap *(*fp_gdk_pixmap_new)(GdkDrawable *drawable,
-        gint width, gint height, gint depth);
-static GdkGC *(*fp_gdk_gc_new)(GdkDrawable*);
-static void (*fp_gdk_rgb_gc_set_foreground)(GdkGC*, guint32);
-static void (*fp_gdk_draw_rectangle)(GdkDrawable*, GdkGC*, gboolean,
-        gint, gint, gint, gint);
-static GdkPixbuf *(*fp_gdk_pixbuf_new)(GdkColorspace colorspace,
-        gboolean has_alpha, int bits_per_sample, int width, int height);
-static GdkPixbuf *(*fp_gdk_pixbuf_get_from_drawable)(GdkPixbuf *dest,
-        GdkDrawable *src, GdkColormap *cmap, int src_x, int src_y,
-        int dest_x, int dest_y, int width, int height);
-static void (*fp_gdk_drawable_get_size)(GdkDrawable *drawable,
-        gint* width, gint* height);
-
-/************************
- * Gtk function pointers
- ************************/
-static gboolean (*fp_gtk_init_check)(int* argc, char** argv);
-
-/* Painting */
-static void (*fp_gtk_paint_hline)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GdkRectangle* area, GtkWidget* widget,
-        const gchar* detail, gint x1, gint x2, gint y);
-static void (*fp_gtk_paint_vline)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GdkRectangle* area, GtkWidget* widget,
-        const gchar* detail, gint y1, gint y2, gint x);
-static void (*fp_gtk_paint_shadow)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        gint x, gint y, gint width, gint height);
-static void (*fp_gtk_paint_arrow)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        GtkArrowType arrow_type, gboolean fill, gint x, gint y,
-        gint width, gint height);
-static void (*fp_gtk_paint_diamond)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        gint x, gint y, gint width, gint height);
-static void (*fp_gtk_paint_box)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        gint x, gint y, gint width, gint height);
-static void (*fp_gtk_paint_flat_box)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        gint x, gint y, gint width, gint height);
-static void (*fp_gtk_paint_check)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        gint x, gint y, gint width, gint height);
-static void (*fp_gtk_paint_option)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        gint x, gint y, gint width, gint height);
-static void (*fp_gtk_paint_box_gap)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        gint x, gint y, gint width, gint height,
-        GtkPositionType gap_side, gint gap_x, gint gap_width);
-static void (*fp_gtk_paint_extension)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        gint x, gint y, gint width, gint height, GtkPositionType gap_side);
-static void (*fp_gtk_paint_focus)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GdkRectangle* area, GtkWidget* widget,
-        const gchar* detail, gint x, gint y, gint width, gint height);
-static void (*fp_gtk_paint_slider)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        gint x, gint y, gint width, gint height, GtkOrientation orientation);
-static void (*fp_gtk_paint_handle)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GtkShadowType shadow_type,
-        GdkRectangle* area, GtkWidget* widget, const gchar* detail,
-        gint x, gint y, gint width, gint height, GtkOrientation orientation);
-static void (*fp_gtk_paint_expander)(GtkStyle* style, GdkWindow* window,
-        GtkStateType state_type, GdkRectangle* area, GtkWidget* widget,
-        const gchar* detail, gint x, gint y, GtkExpanderStyle expander_style);
-static void (*fp_gtk_style_apply_default_background)(GtkStyle* style,
-        GdkWindow* window, gboolean set_bg, GtkStateType state_type,
-        GdkRectangle* area, gint x, gint y, gint width, gint height);
-
-/* Widget creation */
-static GtkWidget* (*fp_gtk_arrow_new)(GtkArrowType arrow_type,
-                                      GtkShadowType shadow_type);
-static GtkWidget* (*fp_gtk_button_new)();
-static GtkWidget* (*fp_gtk_check_button_new)();
-static GtkWidget* (*fp_gtk_check_menu_item_new)();
-static GtkWidget* (*fp_gtk_color_selection_dialog_new)(const gchar* title);
-static GtkWidget* (*fp_gtk_combo_box_new)();
-static GtkWidget* (*fp_gtk_combo_box_entry_new)();
-static GtkWidget* (*fp_gtk_entry_new)();
-static GtkWidget* (*fp_gtk_fixed_new)();
-static GtkWidget* (*fp_gtk_handle_box_new)();
-static GtkWidget* (*fp_gtk_hpaned_new)();
-static GtkWidget* (*fp_gtk_vpaned_new)();
-static GtkWidget* (*fp_gtk_hscale_new)(GtkAdjustment* adjustment);
-static GtkWidget* (*fp_gtk_vscale_new)(GtkAdjustment* adjustment);
-static GtkWidget* (*fp_gtk_hscrollbar_new)(GtkAdjustment* adjustment);
-static GtkWidget* (*fp_gtk_vscrollbar_new)(GtkAdjustment* adjustment);
-static GtkWidget* (*fp_gtk_hseparator_new)();
-static GtkWidget* (*fp_gtk_vseparator_new)();
-static GtkWidget* (*fp_gtk_image_new)();
-static GtkWidget* (*fp_gtk_label_new)(const gchar* str);
-static GtkWidget* (*fp_gtk_menu_new)();
-static GtkWidget* (*fp_gtk_menu_bar_new)();
-static GtkWidget* (*fp_gtk_menu_item_new)();
-static GtkWidget* (*fp_gtk_notebook_new)();
-static GtkWidget* (*fp_gtk_progress_bar_new)();
-static GtkWidget* (*fp_gtk_progress_bar_set_orientation)(
-        GtkProgressBar *pbar,
-        GtkProgressBarOrientation orientation);
-static GtkWidget* (*fp_gtk_radio_button_new)(GSList *group);
-static GtkWidget* (*fp_gtk_radio_menu_item_new)(GSList *group);
-static GtkWidget* (*fp_gtk_scrolled_window_new)(GtkAdjustment *hadjustment,
-        GtkAdjustment *vadjustment);
-static GtkWidget* (*fp_gtk_separator_menu_item_new)();
-static GtkWidget* (*fp_gtk_separator_tool_item_new)();
-static GtkWidget* (*fp_gtk_text_view_new)();
-static GtkWidget* (*fp_gtk_toggle_button_new)();
-static GtkWidget* (*fp_gtk_toolbar_new)();
-static GtkWidget* (*fp_gtk_tree_view_new)();
-static GtkWidget* (*fp_gtk_viewport_new)(GtkAdjustment *hadjustment,
-        GtkAdjustment *vadjustment);
-static GtkWidget* (*fp_gtk_window_new)(GtkWindowType type);
-static GtkWidget* (*fp_gtk_dialog_new)();
-static GtkWidget* (*fp_gtk_spin_button_new)(GtkAdjustment *adjustment,
-        gdouble climb_rate, guint digits);
-static GtkWidget* (*fp_gtk_frame_new)(const gchar *label);
-
-/* Other widget operations */
-static GtkObject* (*fp_gtk_adjustment_new)(gdouble value,
-        gdouble lower, gdouble upper, gdouble step_increment,
-        gdouble page_increment, gdouble page_size);
-static void (*fp_gtk_container_add)(GtkContainer *window, GtkWidget *widget);
-static void (*fp_gtk_menu_shell_append)(GtkMenuShell *menu_shell,
-        GtkWidget *child);
-static void (*fp_gtk_menu_item_set_submenu)(GtkMenuItem *menu_item,
-        GtkWidget *submenu);
-static void (*fp_gtk_widget_realize)(GtkWidget *widget);
-static GdkPixbuf* (*fp_gtk_widget_render_icon)(GtkWidget *widget,
-        const gchar *stock_id, GtkIconSize size, const gchar *detail);
-static void (*fp_gtk_widget_set_name)(GtkWidget *widget, const gchar *name);
-static void (*fp_gtk_widget_set_parent)(GtkWidget *widget, GtkWidget *parent);
-static void (*fp_gtk_widget_set_direction)(GtkWidget *widget,
-        GtkTextDirection direction);
-static void (*fp_gtk_widget_style_get)(GtkWidget *widget,
-        const gchar *first_property_name, ...);
-static void (*fp_gtk_widget_class_install_style_property)(
-        GtkWidgetClass* class, GParamSpec *pspec);
-static GParamSpec* (*fp_gtk_widget_class_find_style_property)(
-        GtkWidgetClass* class, const gchar* property_name);
-static void (*fp_gtk_widget_style_get_property)(GtkWidget* widget,
-        const gchar* property_name, GValue* value);
-static char* (*fp_pango_font_description_to_string)(
-        const PangoFontDescription* fd);
-static GtkSettings* (*fp_gtk_settings_get_default)();
-static GtkSettings* (*fp_gtk_widget_get_settings)(GtkWidget *widget);
-static GType        (*fp_gtk_border_get_type)();
-static void (*fp_gtk_arrow_set)(GtkWidget* arrow,
-                                GtkArrowType arrow_type,
-                                GtkShadowType shadow_type);
-static void (*fp_gtk_widget_size_request)(GtkWidget *widget,
-                                          GtkRequisition *requisition);
-static GtkAdjustment* (*fp_gtk_range_get_adjustment)(GtkRange* range);
-
 /* Method bodies */
 const char *getStrFor(JNIEnv *env, jstring val)
 {
@@ -381,85 +139,13 @@
     (*env)->DeleteLocalRef(env, class);
 }
 
-/* This is a workaround for the bug:
- * http://sourceware.org/bugzilla/show_bug.cgi?id=1814
- * (dlsym/dlopen clears dlerror state)
- * This bug is specific to Linux, but there is no harm in
- * applying this workaround on Solaris as well.
- */
-static void* dl_symbol(const char* name)
-{
-    void* result = dlsym(gtk2_libhandle, name);
-    if (!result)
-        longjmp(j, NO_SYMBOL_EXCEPTION);
-
-    return result;
-}
-
-static void* dl_symbol_gthread(const char* name)
-{
-    void* result = dlsym(gthread_libhandle, name);
-    if (!result)
-        longjmp(j, NO_SYMBOL_EXCEPTION);
-
-    return result;
-}
-
 gboolean gtk2_check_version()
 {
-    if (gtk2_libhandle != NULL) {
-        /* We've already successfully opened the GTK libs, so return true. */
-        return TRUE;
-    } else {
-        void *lib = NULL;
-        gboolean result = FALSE;
-
-        lib = dlopen(GTK2_LIB, RTLD_LAZY | RTLD_LOCAL);
-        if (lib == NULL) {
-            return FALSE;
-        }
-
-        fp_gtk_check_version = dlsym(lib, "gtk_check_version");
-        /* Check for GTK 2.2+ */
-        if (!fp_gtk_check_version(2, 2, 0)) {
-            result = TRUE;
-        }
-
-        dlclose(lib);
-
-        return result;
-    }
-}
-
-/**
- * Functions for sun_awt_X11_GtkFileDialogPeer.c
- */
-void gtk2_file_chooser_load()
-{
-    fp_gtk_file_chooser_get_filename = dl_symbol(
-            "gtk_file_chooser_get_filename");
-    fp_gtk_file_chooser_dialog_new = dl_symbol("gtk_file_chooser_dialog_new");
-    fp_gtk_file_chooser_set_current_folder = dl_symbol(
-            "gtk_file_chooser_set_current_folder");
-    fp_gtk_file_chooser_set_filename = dl_symbol(
-            "gtk_file_chooser_set_filename");
-    fp_gtk_file_chooser_set_current_name = dl_symbol(
-            "gtk_file_chooser_set_current_name");
-    fp_gtk_file_filter_add_custom = dl_symbol("gtk_file_filter_add_custom");
-    fp_gtk_file_chooser_set_filter = dl_symbol("gtk_file_chooser_set_filter");
-    fp_gtk_file_chooser_get_type = dl_symbol("gtk_file_chooser_get_type");
-    fp_gtk_file_filter_new = dl_symbol("gtk_file_filter_new");
-    if (fp_gtk_check_version(2, 8, 0) == NULL) {
-        fp_gtk_file_chooser_set_do_overwrite_confirmation = dl_symbol(
-                "gtk_file_chooser_set_do_overwrite_confirmation");
-    }
-    fp_gtk_file_chooser_set_select_multiple = dl_symbol(
-            "gtk_file_chooser_set_select_multiple");
-    fp_gtk_file_chooser_get_current_folder = dl_symbol(
-            "gtk_file_chooser_get_current_folder");
-    fp_gtk_file_chooser_get_filenames = dl_symbol(
-            "gtk_file_chooser_get_filenames");
-    fp_gtk_g_slist_length = dl_symbol("g_slist_length");
+#ifdef USE_SYSTEM_GTK
+    return TRUE;
+#else
+    return gtk2_check_dlversion();
+#endif
 }
 
 gboolean gtk2_load()
@@ -470,244 +156,9 @@
     int (*io_handler)();
     char *gtk_modules_env;
 
-    gtk2_libhandle = dlopen(GTK2_LIB, RTLD_LAZY | RTLD_LOCAL);
-    gthread_libhandle = dlopen(GTHREAD_LIB, RTLD_LAZY | RTLD_LOCAL);
-
-    if (gtk2_libhandle == NULL || gthread_libhandle == NULL)
-        return FALSE;
-
-    if (setjmp(j) == 0)
-    {
-        fp_gtk_check_version = dl_symbol("gtk_check_version");
-        /* Check for GTK 2.2+ */
-        if (fp_gtk_check_version(2, 2, 0)) {
-            longjmp(j, NO_SYMBOL_EXCEPTION);
-        }
-
-        /* GLib */
-        fp_g_free = dl_symbol("g_free");
-        fp_g_object_unref = dl_symbol("g_object_unref");
-
-        fp_g_main_context_iteration =
-            dl_symbol("g_main_context_iteration");
-
-        fp_g_value_init = dl_symbol("g_value_init");
-        fp_g_type_is_a = dl_symbol("g_type_is_a");
-
-        fp_g_value_get_boolean = dl_symbol("g_value_get_boolean");
-        fp_g_value_get_char = dl_symbol("g_value_get_char");
-        fp_g_value_get_uchar = dl_symbol("g_value_get_uchar");
-        fp_g_value_get_int = dl_symbol("g_value_get_int");
-        fp_g_value_get_uint = dl_symbol("g_value_get_uint");
-        fp_g_value_get_long = dl_symbol("g_value_get_long");
-        fp_g_value_get_ulong = dl_symbol("g_value_get_ulong");
-        fp_g_value_get_int64 = dl_symbol("g_value_get_int64");
-        fp_g_value_get_uint64 = dl_symbol("g_value_get_uint64");
-        fp_g_value_get_float = dl_symbol("g_value_get_float");
-        fp_g_value_get_double = dl_symbol("g_value_get_double");
-        fp_g_value_get_string = dl_symbol("g_value_get_string");
-        fp_g_value_get_enum = dl_symbol("g_value_get_enum");
-        fp_g_value_get_flags = dl_symbol("g_value_get_flags");
-        fp_g_value_get_param = dl_symbol("g_value_get_param");
-        fp_g_value_get_boxed = dl_symbol("g_value_get_boxed");
-        fp_g_value_get_pointer = dl_symbol("g_value_get_pointer");
-        fp_g_value_get_object = dl_symbol("g_value_get_object");
-        fp_g_param_spec_int = dl_symbol("g_param_spec_int");
-        fp_g_object_get = dl_symbol("g_object_get");
-        fp_g_object_set = dl_symbol("g_object_set");
-
-        /* GDK */
-        fp_gdk_pixmap_new = dl_symbol("gdk_pixmap_new");
-        fp_gdk_pixbuf_get_from_drawable =
-            dl_symbol("gdk_pixbuf_get_from_drawable");
-        fp_gdk_gc_new = dl_symbol("gdk_gc_new");
-        fp_gdk_rgb_gc_set_foreground =
-            dl_symbol("gdk_rgb_gc_set_foreground");
-        fp_gdk_draw_rectangle = dl_symbol("gdk_draw_rectangle");
-        fp_gdk_drawable_get_size = dl_symbol("gdk_drawable_get_size");
-
-        /* Pixbuf */
-        fp_gdk_pixbuf_new = dl_symbol("gdk_pixbuf_new");
-        fp_gdk_pixbuf_new_from_file =
-                dl_symbol("gdk_pixbuf_new_from_file");
-        fp_gdk_pixbuf_get_width = dl_symbol("gdk_pixbuf_get_width");
-        fp_gdk_pixbuf_get_height = dl_symbol("gdk_pixbuf_get_height");
-        fp_gdk_pixbuf_get_pixels = dl_symbol("gdk_pixbuf_get_pixels");
-        fp_gdk_pixbuf_get_rowstride =
-                dl_symbol("gdk_pixbuf_get_rowstride");
-        fp_gdk_pixbuf_get_has_alpha =
-                dl_symbol("gdk_pixbuf_get_has_alpha");
-        fp_gdk_pixbuf_get_bits_per_sample =
-                dl_symbol("gdk_pixbuf_get_bits_per_sample");
-        fp_gdk_pixbuf_get_n_channels =
-                dl_symbol("gdk_pixbuf_get_n_channels");
-
-        /* GTK painting */
-        fp_gtk_init_check = dl_symbol("gtk_init_check");
-        fp_gtk_paint_hline = dl_symbol("gtk_paint_hline");
-        fp_gtk_paint_vline = dl_symbol("gtk_paint_vline");
-        fp_gtk_paint_shadow = dl_symbol("gtk_paint_shadow");
-        fp_gtk_paint_arrow = dl_symbol("gtk_paint_arrow");
-        fp_gtk_paint_diamond = dl_symbol("gtk_paint_diamond");
-        fp_gtk_paint_box = dl_symbol("gtk_paint_box");
-        fp_gtk_paint_flat_box = dl_symbol("gtk_paint_flat_box");
-        fp_gtk_paint_check = dl_symbol("gtk_paint_check");
-        fp_gtk_paint_option = dl_symbol("gtk_paint_option");
-        fp_gtk_paint_box_gap = dl_symbol("gtk_paint_box_gap");
-        fp_gtk_paint_extension = dl_symbol("gtk_paint_extension");
-        fp_gtk_paint_focus = dl_symbol("gtk_paint_focus");
-        fp_gtk_paint_slider = dl_symbol("gtk_paint_slider");
-        fp_gtk_paint_handle = dl_symbol("gtk_paint_handle");
-        fp_gtk_paint_expander = dl_symbol("gtk_paint_expander");
-        fp_gtk_style_apply_default_background =
-                dl_symbol("gtk_style_apply_default_background");
-
-        /* GTK widgets */
-        fp_gtk_arrow_new = dl_symbol("gtk_arrow_new");
-        fp_gtk_button_new = dl_symbol("gtk_button_new");
-        fp_gtk_spin_button_new = dl_symbol("gtk_spin_button_new");
-        fp_gtk_check_button_new = dl_symbol("gtk_check_button_new");
-        fp_gtk_check_menu_item_new =
-                dl_symbol("gtk_check_menu_item_new");
-        fp_gtk_color_selection_dialog_new =
-                dl_symbol("gtk_color_selection_dialog_new");
-        fp_gtk_entry_new = dl_symbol("gtk_entry_new");
-        fp_gtk_fixed_new = dl_symbol("gtk_fixed_new");
-        fp_gtk_handle_box_new = dl_symbol("gtk_handle_box_new");
-        fp_gtk_image_new = dl_symbol("gtk_image_new");
-        fp_gtk_hpaned_new = dl_symbol("gtk_hpaned_new");
-        fp_gtk_vpaned_new = dl_symbol("gtk_vpaned_new");
-        fp_gtk_hscale_new = dl_symbol("gtk_hscale_new");
-        fp_gtk_vscale_new = dl_symbol("gtk_vscale_new");
-        fp_gtk_hscrollbar_new = dl_symbol("gtk_hscrollbar_new");
-        fp_gtk_vscrollbar_new = dl_symbol("gtk_vscrollbar_new");
-        fp_gtk_hseparator_new = dl_symbol("gtk_hseparator_new");
-        fp_gtk_vseparator_new = dl_symbol("gtk_vseparator_new");
-        fp_gtk_label_new = dl_symbol("gtk_label_new");
-        fp_gtk_menu_new = dl_symbol("gtk_menu_new");
-        fp_gtk_menu_bar_new = dl_symbol("gtk_menu_bar_new");
-        fp_gtk_menu_item_new = dl_symbol("gtk_menu_item_new");
-        fp_gtk_menu_item_set_submenu =
-                dl_symbol("gtk_menu_item_set_submenu");
-        fp_gtk_notebook_new = dl_symbol("gtk_notebook_new");
-        fp_gtk_progress_bar_new =
-            dl_symbol("gtk_progress_bar_new");
-        fp_gtk_progress_bar_set_orientation =
-            dl_symbol("gtk_progress_bar_set_orientation");
-        fp_gtk_radio_button_new =
-            dl_symbol("gtk_radio_button_new");
-        fp_gtk_radio_menu_item_new =
-            dl_symbol("gtk_radio_menu_item_new");
-        fp_gtk_scrolled_window_new =
-            dl_symbol("gtk_scrolled_window_new");
-        fp_gtk_separator_menu_item_new =
-            dl_symbol("gtk_separator_menu_item_new");
-        fp_gtk_text_view_new = dl_symbol("gtk_text_view_new");
-        fp_gtk_toggle_button_new =
-            dl_symbol("gtk_toggle_button_new");
-        fp_gtk_toolbar_new = dl_symbol("gtk_toolbar_new");
-        fp_gtk_tree_view_new = dl_symbol("gtk_tree_view_new");
-        fp_gtk_viewport_new = dl_symbol("gtk_viewport_new");
-        fp_gtk_window_new = dl_symbol("gtk_window_new");
-        fp_gtk_window_present = dl_symbol("gtk_window_present");
-        fp_gtk_window_move = dl_symbol("gtk_window_move");
-        fp_gtk_window_resize = dl_symbol("gtk_window_resize");
-
-          fp_gtk_dialog_new = dl_symbol("gtk_dialog_new");
-        fp_gtk_frame_new = dl_symbol("gtk_frame_new");
-
-        fp_gtk_adjustment_new = dl_symbol("gtk_adjustment_new");
-        fp_gtk_container_add = dl_symbol("gtk_container_add");
-        fp_gtk_menu_shell_append =
-            dl_symbol("gtk_menu_shell_append");
-        fp_gtk_widget_realize = dl_symbol("gtk_widget_realize");
-        fp_gtk_widget_destroy = dl_symbol("gtk_widget_destroy");
-        fp_gtk_widget_render_icon =
-            dl_symbol("gtk_widget_render_icon");
-        fp_gtk_widget_set_name =
-            dl_symbol("gtk_widget_set_name");
-        fp_gtk_widget_set_parent =
-            dl_symbol("gtk_widget_set_parent");
-        fp_gtk_widget_set_direction =
-            dl_symbol("gtk_widget_set_direction");
-        fp_gtk_widget_style_get =
-            dl_symbol("gtk_widget_style_get");
-        fp_gtk_widget_class_install_style_property =
-            dl_symbol("gtk_widget_class_install_style_property");
-        fp_gtk_widget_class_find_style_property =
-            dl_symbol("gtk_widget_class_find_style_property");
-        fp_gtk_widget_style_get_property =
-            dl_symbol("gtk_widget_style_get_property");
-        fp_pango_font_description_to_string =
-            dl_symbol("pango_font_description_to_string");
-        fp_gtk_settings_get_default =
-            dl_symbol("gtk_settings_get_default");
-        fp_gtk_widget_get_settings =
-            dl_symbol("gtk_widget_get_settings");
-        fp_gtk_border_get_type =  dl_symbol("gtk_border_get_type");
-        fp_gtk_arrow_set = dl_symbol("gtk_arrow_set");
-        fp_gtk_widget_size_request =
-            dl_symbol("gtk_widget_size_request");
-        fp_gtk_range_get_adjustment =
-            dl_symbol("gtk_range_get_adjustment");
-
-        fp_gtk_widget_hide = dl_symbol("gtk_widget_hide");
-        fp_gtk_main_quit = dl_symbol("gtk_main_quit");
-        fp_g_signal_connect_data = dl_symbol("g_signal_connect_data");
-        fp_gtk_widget_show = dl_symbol("gtk_widget_show");
-        fp_gtk_main = dl_symbol("gtk_main");
-
-        /**
-         * GLib thread system
-         */
-        fp_g_thread_init = dl_symbol_gthread("g_thread_init");
-        fp_gdk_threads_init = dl_symbol("gdk_threads_init");
-        fp_gdk_threads_enter = dl_symbol("gdk_threads_enter");
-        fp_gdk_threads_leave = dl_symbol("gdk_threads_leave");
-
-        /**
-         * Functions for sun_awt_X11_GtkFileDialogPeer.c
-         */
-        if (fp_gtk_check_version(2, 4, 0) == NULL) {
-            // The current GtkFileChooser is available from GTK+ 2.4
-            gtk2_file_chooser_load();
-        }
-
-        /* Some functions may be missing in pre-2.4 GTK.
-           We handle them specially here.
-         */
-        fp_gtk_combo_box_new = dlsym(gtk2_libhandle, "gtk_combo_box_new");
-        if (fp_gtk_combo_box_new == NULL) {
-            fp_gtk_combo_box_new = dl_symbol("gtk_combo_new");
-        }
-
-        fp_gtk_combo_box_entry_new =
-            dlsym(gtk2_libhandle, "gtk_combo_box_entry_new");
-        if (fp_gtk_combo_box_entry_new == NULL) {
-            fp_gtk_combo_box_entry_new = dl_symbol("gtk_combo_new");
-            new_combo = FALSE;
-        }
-
-        fp_gtk_separator_tool_item_new =
-            dlsym(gtk2_libhandle, "gtk_separator_tool_item_new");
-        if (fp_gtk_separator_tool_item_new == NULL) {
-            fp_gtk_separator_tool_item_new =
-                dl_symbol("gtk_vseparator_new");
-        }
-    }
-    /* Now we have only one kind of exceptions: NO_SYMBOL_EXCEPTION
-     * Otherwise we can check the return value of setjmp method.
-     */
-    else
-    {
-        dlclose(gtk2_libhandle);
-        gtk2_libhandle = NULL;
-
-        dlclose(gthread_libhandle);
-        gthread_libhandle = NULL;
-
-        return FALSE;
-    }
+#ifndef USE_SYSTEM_GTK
+    gtk2_dlload ();
+#endif
 
     /*
      * Strip the AT-SPI GTK_MODULEs if present
@@ -759,19 +210,19 @@
     handler = XSetErrorHandler(NULL);
     io_handler = XSetIOErrorHandler(NULL);
 
-    if (fp_gtk_check_version(2, 2, 0) == NULL) {
+    if (gtk_check_version(2, 2, 0) == NULL) {
         // Init the thread system to use GLib in a thread-safe mode
         if (!flag_g_thread_get_initialized) {
             flag_g_thread_get_initialized = TRUE;
 
-            fp_g_thread_init(NULL);
+            g_thread_init(NULL);
 
             //According the GTK documentation, gdk_threads_init() should be
             //called before gtk_init() or gtk_init_check()
-            fp_gdk_threads_init();
+            gdk_threads_init();
         }
     }
-    result = (*fp_gtk_init_check)(NULL, NULL);
+    result = gtk_init_check (NULL, NULL);
 
     XSetErrorHandler(handler);
     XSetIOErrorHandler(io_handler);
@@ -782,23 +233,23 @@
         gtk2_widgets[i] = NULL;
     }
 
+    initialised = result;
     return result;
 }
 
 int gtk2_unload()
 {
     int i;
-    char *gtk2_error;
 
-    if (!gtk2_libhandle)
+    if (!initialised)
         return TRUE;
 
     /* Release painting objects */
     if (gtk2_white_pixmap != NULL) {
-        (*fp_g_object_unref)(gtk2_white_pixmap);
-        (*fp_g_object_unref)(gtk2_black_pixmap);
-        (*fp_g_object_unref)(gtk2_white_pixbuf);
-        (*fp_g_object_unref)(gtk2_black_pixbuf);
+        g_object_unref (gtk2_white_pixmap);
+        g_object_unref (gtk2_black_pixmap);
+        g_object_unref (gtk2_white_pixbuf);
+        g_object_unref (gtk2_black_pixbuf);
         gtk2_white_pixmap = gtk2_black_pixmap =
             gtk2_white_pixbuf = gtk2_black_pixbuf = NULL;
     }
@@ -807,20 +258,17 @@
 
     if (gtk2_window != NULL) {
         /* Destroying toplevel widget will destroy all contained widgets */
-        (*fp_gtk_widget_destroy)(gtk2_window);
+        gtk_widget_destroy (gtk2_window);
 
         /* Unset some static data so they get reinitialized on next load */
         gtk2_window = NULL;
     }
 
-    dlerror();
-    dlclose(gtk2_libhandle);
-    dlclose(gthread_libhandle);
-    if ((gtk2_error = dlerror()) != NULL)
-    {
-        return FALSE;
-    }
+#ifdef USE_SYSTEM_GTK
     return TRUE;
+#else
+    return gtk2_dlunload ();
+#endif
 }
 
 /* Dispatch all pending events from the GTK event loop.
@@ -828,7 +276,7 @@
  */
 void flush_gtk_event_loop()
 {
-    while( (*fp_g_main_context_iteration)(NULL, FALSE));
+    while( g_main_context_iteration (NULL, FALSE));
 }
 
 /*
@@ -839,12 +287,12 @@
 {
     if (gtk2_window == NULL)
     {
-        gtk2_window = (*fp_gtk_window_new)(GTK_WINDOW_TOPLEVEL);
-        gtk2_fixed = (GtkFixed *)(*fp_gtk_fixed_new)();
-        (*fp_gtk_container_add)((GtkContainer*)gtk2_window,
-                                (GtkWidget *)gtk2_fixed);
-        (*fp_gtk_widget_realize)(gtk2_window);
-        (*fp_gtk_widget_realize)((GtkWidget *)gtk2_fixed);
+        gtk2_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+        gtk2_fixed = (GtkFixed *) gtk_fixed_new ();
+        gtk_container_add ((GtkContainer*)gtk2_window,
+			   (GtkWidget *)gtk2_fixed);
+        gtk_widget_realize (gtk2_window);
+        gtk_widget_realize ((GtkWidget *)gtk2_fixed);
     }
 }
 
@@ -884,27 +332,27 @@
 
     if (gtk2_pixbuf_width < width || gtk2_pixbuf_height < height)
     {
-        white = (*fp_gdk_pixbuf_new)(GDK_COLORSPACE_RGB, TRUE, 8, width, height);
-        black = (*fp_gdk_pixbuf_new)(GDK_COLORSPACE_RGB, TRUE, 8, width, height);
+        white = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, width, height);
+        black = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, width, height);
 
         if (white == NULL || black == NULL)
         {
             snprintf(convertionBuffer, CONV_BUFFER_SIZE, "Couldn't create pixbuf of size %dx%d", width, height);
             throw_exception(env, "java/lang/RuntimeException", convertionBuffer);
-            fp_gdk_threads_leave();
+            gdk_threads_leave();
             return;
         }
 
         if (gtk2_white_pixmap != NULL) {
             /* free old stuff */
-            (*fp_g_object_unref)(gtk2_white_pixmap);
-            (*fp_g_object_unref)(gtk2_black_pixmap);
-            (*fp_g_object_unref)(gtk2_white_pixbuf);
-            (*fp_g_object_unref)(gtk2_black_pixbuf);
+            g_object_unref (gtk2_white_pixmap);
+            g_object_unref (gtk2_black_pixmap);
+            g_object_unref (gtk2_white_pixbuf);
+            g_object_unref (gtk2_black_pixbuf);
         }
 
-        gtk2_white_pixmap = (*fp_gdk_pixmap_new)(gtk2_window->window, width, height, -1);
-        gtk2_black_pixmap = (*fp_gdk_pixmap_new)(gtk2_window->window, width, height, -1);
+        gtk2_white_pixmap = gdk_pixmap_new (gtk2_window->window, width, height, -1);
+        gtk2_black_pixmap = gdk_pixmap_new (gtk2_window->window, width, height, -1);
 
         gtk2_white_pixbuf = white;
         gtk2_black_pixbuf = black;
@@ -914,15 +362,15 @@
     }
 
     /* clear the pixmaps */
-    gc = (*fp_gdk_gc_new)(gtk2_white_pixmap);
-    (*fp_gdk_rgb_gc_set_foreground)(gc, 0xffffff);
-    (*fp_gdk_draw_rectangle)(gtk2_white_pixmap, gc, TRUE, 0, 0, width, height);
-    (*fp_g_object_unref)(gc);
+    gc = gdk_gc_new (gtk2_white_pixmap);
+    gdk_rgb_gc_set_foreground (gc, 0xffffff);
+    gdk_draw_rectangle (gtk2_white_pixmap, gc, TRUE, 0, 0, width, height);
+    g_object_unref (gc);
 
-    gc = (*fp_gdk_gc_new)(gtk2_black_pixmap);
-    (*fp_gdk_rgb_gc_set_foreground)(gc, 0x000000);
-    (*fp_gdk_draw_rectangle)(gtk2_black_pixmap, gc, TRUE, 0, 0, width, height);
-    (*fp_g_object_unref)(gc);
+    gc = gdk_gc_new (gtk2_black_pixmap);
+    gdk_rgb_gc_set_foreground (gc, 0x000000);
+    gdk_draw_rectangle (gtk2_black_pixmap, gc, TRUE, 0, 0, width, height);
+    g_object_unref (gc);
 }
 
 /*
@@ -943,14 +391,14 @@
     gboolean is_opaque = TRUE;
     gboolean is_bitmask = TRUE;
 
-    (*fp_gdk_pixbuf_get_from_drawable)(gtk2_white_pixbuf, gtk2_white_pixmap,
+    gdk_pixbuf_get_from_drawable (gtk2_white_pixbuf, gtk2_white_pixmap,
             NULL, 0, 0, 0, 0, width, height);
-    (*fp_gdk_pixbuf_get_from_drawable)(gtk2_black_pixbuf, gtk2_black_pixmap,
+    gdk_pixbuf_get_from_drawable (gtk2_black_pixbuf, gtk2_black_pixmap,
             NULL, 0, 0, 0, 0, width, height);
 
-    white = (*fp_gdk_pixbuf_get_pixels)(gtk2_white_pixbuf);
-    black = (*fp_gdk_pixbuf_get_pixels)(gtk2_black_pixbuf);
-    stride = (*fp_gdk_pixbuf_get_rowstride)(gtk2_black_pixbuf);
+    white = gdk_pixbuf_get_pixels (gtk2_white_pixbuf);
+    black = gdk_pixbuf_get_pixels (gtk2_black_pixbuf);
+    stride = gdk_pixbuf_get_rowstride (gtk2_black_pixbuf);
     padding = stride - width * 4;
 
     for (i = 0; i < height; i++) {
@@ -1005,9 +453,9 @@
      * parent, so we need to set the direction of both the widget and its
      * parent.
      */
-    (*fp_gtk_widget_set_direction)(widget, dir);
+    gtk_widget_set_direction (widget, dir);
     if (widget->parent != NULL) {
-        (*fp_gtk_widget_set_direction)(widget->parent, dir);
+        gtk_widget_set_direction (widget->parent, dir);
     }
 }
 
@@ -1073,20 +521,20 @@
     GtkWidget *arrow = NULL;
     if (NULL == gtk2_widgets[_GTK_ARROW_TYPE])
     {
-        gtk2_widgets[_GTK_ARROW_TYPE] = (*fp_gtk_arrow_new)(arrow_type, shadow_type);
-        (*fp_gtk_container_add)((GtkContainer *)gtk2_fixed, gtk2_widgets[_GTK_ARROW_TYPE]);
-        (*fp_gtk_widget_realize)(gtk2_widgets[_GTK_ARROW_TYPE]);
+        gtk2_widgets[_GTK_ARROW_TYPE] = gtk_arrow_new (arrow_type, shadow_type);
+        gtk_container_add ((GtkContainer *)gtk2_fixed, gtk2_widgets[_GTK_ARROW_TYPE]);
+        gtk_widget_realize (gtk2_widgets[_GTK_ARROW_TYPE]);
     }
     arrow = gtk2_widgets[_GTK_ARROW_TYPE];
 
-    (*fp_gtk_arrow_set)(arrow, arrow_type, shadow_type);
+    gtk_arrow_set (arrow, arrow_type, shadow_type);
     return arrow;
 }
 
 static GtkAdjustment* create_adjustment()
 {
     return (GtkAdjustment *)
-            (*fp_gtk_adjustment_new)(50.0, 0.0, 100.0, 10.0, 20.0, 20.0);
+            gtk_adjustment_new (50.0, 0.0, 100.0, 10.0, 20.0, 20.0);
 }
 
 /**
@@ -1103,7 +551,7 @@
         case TABLE_HEADER:
             if (init_result = (NULL == gtk2_widgets[_GTK_BUTTON_TYPE]))
             {
-                gtk2_widgets[_GTK_BUTTON_TYPE] = (*fp_gtk_button_new)();
+                gtk2_widgets[_GTK_BUTTON_TYPE] = gtk_button_new ();
             }
             result = gtk2_widgets[_GTK_BUTTON_TYPE];
             break;
@@ -1111,7 +559,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_CHECK_BUTTON_TYPE]))
             {
                 gtk2_widgets[_GTK_CHECK_BUTTON_TYPE] =
-                    (*fp_gtk_check_button_new)();
+                    gtk_check_button_new ();
             }
             result = gtk2_widgets[_GTK_CHECK_BUTTON_TYPE];
             break;
@@ -1119,7 +567,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_CHECK_MENU_ITEM_TYPE]))
             {
                 gtk2_widgets[_GTK_CHECK_MENU_ITEM_TYPE] =
-                    (*fp_gtk_check_menu_item_new)();
+                    gtk_check_menu_item_new ();
             }
             result = gtk2_widgets[_GTK_CHECK_MENU_ITEM_TYPE];
             break;
@@ -1132,7 +580,7 @@
                     (NULL == gtk2_widgets[_GTK_COLOR_SELECTION_DIALOG_TYPE]))
             {
                 gtk2_widgets[_GTK_COLOR_SELECTION_DIALOG_TYPE] =
-                    (*fp_gtk_color_selection_dialog_new)(NULL);
+                    gtk_color_selection_dialog_new (NULL);
             }
             result = gtk2_widgets[_GTK_COLOR_SELECTION_DIALOG_TYPE];
             break;*/
@@ -1140,7 +588,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_COMBO_BOX_TYPE]))
             {
                 gtk2_widgets[_GTK_COMBO_BOX_TYPE] =
-                    (*fp_gtk_combo_box_new)();
+                    gtk_combo_box_new ();
             }
             result = gtk2_widgets[_GTK_COMBO_BOX_TYPE];
             break;
@@ -1149,7 +597,7 @@
                     (NULL == gtk2_widgets[_GTK_COMBO_BOX_ARROW_BUTTON_TYPE]))
             {
                 gtk2_widgets[_GTK_COMBO_BOX_ARROW_BUTTON_TYPE] =
-                     (*fp_gtk_toggle_button_new)();
+                     gtk_toggle_button_new ();
             }
             result = gtk2_widgets[_GTK_COMBO_BOX_ARROW_BUTTON_TYPE];
             break;
@@ -1158,10 +606,10 @@
                     (NULL == gtk2_widgets[_GTK_COMBO_BOX_TEXT_FIELD_TYPE]))
             {
                 result = gtk2_widgets[_GTK_COMBO_BOX_TEXT_FIELD_TYPE] =
-                     (*fp_gtk_entry_new)();
+                     gtk_entry_new ();
 
-                GtkSettings* settings = fp_gtk_widget_get_settings(result);
-                fp_g_object_set(settings, "gtk-cursor-blink", FALSE, NULL);
+                GtkSettings* settings = gtk_widget_get_settings(result);
+                g_object_set(settings, "gtk-cursor-blink", FALSE, NULL);
             }
             result = gtk2_widgets[_GTK_COMBO_BOX_TEXT_FIELD_TYPE];
             break;
@@ -1171,7 +619,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_LABEL_TYPE]))
             {
                 gtk2_widgets[_GTK_LABEL_TYPE] =
-                    (*fp_gtk_label_new)(NULL);
+                    gtk_label_new (NULL);
             }
             result = gtk2_widgets[_GTK_LABEL_TYPE];
             break;
@@ -1185,7 +633,7 @@
                  * constructor.
                  */
                 gtk2_widgets[_GTK_CONTAINER_TYPE] =
-                    (*fp_gtk_fixed_new)();
+                    gtk_fixed_new();
             }
             result = gtk2_widgets[_GTK_CONTAINER_TYPE];
             break;
@@ -1195,7 +643,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_TEXT_VIEW_TYPE]))
             {
                 gtk2_widgets[_GTK_TEXT_VIEW_TYPE] =
-                    (*fp_gtk_text_view_new)();
+                    gtk_text_view_new();
             }
             result = gtk2_widgets[_GTK_TEXT_VIEW_TYPE];
             break;
@@ -1205,11 +653,11 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_ENTRY_TYPE]))
             {
                 gtk2_widgets[_GTK_ENTRY_TYPE] =
-                    (*fp_gtk_entry_new)();
+                    gtk_entry_new ();
 
                 GtkSettings* settings =
-                    fp_gtk_widget_get_settings(gtk2_widgets[_GTK_ENTRY_TYPE]);
-                fp_g_object_set(settings, "gtk-cursor-blink", FALSE, NULL);
+                    gtk_widget_get_settings(gtk2_widgets[_GTK_ENTRY_TYPE]);
+                g_object_set(settings, "gtk-cursor-blink", FALSE, NULL);
             }
             result = gtk2_widgets[_GTK_ENTRY_TYPE];
             break;
@@ -1217,7 +665,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_HANDLE_BOX_TYPE]))
             {
                 gtk2_widgets[_GTK_HANDLE_BOX_TYPE] =
-                    (*fp_gtk_handle_box_new)();
+                    gtk_handle_box_new ();
             }
             result = gtk2_widgets[_GTK_HANDLE_BOX_TYPE];
             break;
@@ -1229,7 +677,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_HSCROLLBAR_TYPE]))
             {
                 gtk2_widgets[_GTK_HSCROLLBAR_TYPE] =
-                    (*fp_gtk_hscrollbar_new)(create_adjustment());
+                    gtk_hscrollbar_new (create_adjustment());
             }
             result = gtk2_widgets[_GTK_HSCROLLBAR_TYPE];
             break;
@@ -1237,7 +685,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_HSEPARATOR_TYPE]))
             {
                 gtk2_widgets[_GTK_HSEPARATOR_TYPE] =
-                    (*fp_gtk_hseparator_new)();
+                    gtk_hseparator_new ();
             }
             result = gtk2_widgets[_GTK_HSEPARATOR_TYPE];
             break;
@@ -1247,7 +695,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_HSCALE_TYPE]))
             {
                 gtk2_widgets[_GTK_HSCALE_TYPE] =
-                    (*fp_gtk_hscale_new)(NULL);
+		    gtk_hscale_new (NULL);
             }
             result = gtk2_widgets[_GTK_HSCALE_TYPE];
             break;
@@ -1255,14 +703,14 @@
         case SPLIT_PANE:
             if (init_result = (NULL == gtk2_widgets[_GTK_HPANED_TYPE]))
             {
-                gtk2_widgets[_GTK_HPANED_TYPE] = (*fp_gtk_hpaned_new)();
+                gtk2_widgets[_GTK_HPANED_TYPE] = gtk_hpaned_new ();
             }
             result = gtk2_widgets[_GTK_HPANED_TYPE];
             break;
         case IMAGE:
             if (init_result = (NULL == gtk2_widgets[_GTK_IMAGE_TYPE]))
             {
-                gtk2_widgets[_GTK_IMAGE_TYPE] = (*fp_gtk_image_new)();
+                gtk2_widgets[_GTK_IMAGE_TYPE] = gtk_image_new ();
             }
             result = gtk2_widgets[_GTK_IMAGE_TYPE];
             break;
@@ -1270,15 +718,15 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_WINDOW_TYPE]))
             {
                 gtk2_widgets[_GTK_WINDOW_TYPE] =
-                    (*fp_gtk_window_new)(GTK_WINDOW_TOPLEVEL);
+                    gtk_window_new (GTK_WINDOW_TOPLEVEL);
             }
             result = gtk2_widgets[_GTK_WINDOW_TYPE];
             break;
         case TOOL_TIP:
             if (init_result = (NULL == gtk2_widgets[_GTK_TOOLTIP_TYPE]))
             {
-                result = (*fp_gtk_window_new)(GTK_WINDOW_TOPLEVEL);
-                (*fp_gtk_widget_set_name)(result, "gtk-tooltips");
+                result = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+                gtk_widget_set_name (result, "gtk-tooltips");
                 gtk2_widgets[_GTK_TOOLTIP_TYPE] = result;
             }
             result = gtk2_widgets[_GTK_TOOLTIP_TYPE];
@@ -1290,14 +738,14 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_TREE_VIEW_TYPE]))
             {
                 gtk2_widgets[_GTK_TREE_VIEW_TYPE] =
-                    (*fp_gtk_tree_view_new)();
+                    gtk_tree_view_new ();
             }
             result = gtk2_widgets[_GTK_TREE_VIEW_TYPE];
             break;
         case TITLED_BORDER:
             if (init_result = (NULL == gtk2_widgets[_GTK_FRAME_TYPE]))
             {
-                gtk2_widgets[_GTK_FRAME_TYPE] = fp_gtk_frame_new(NULL);
+                gtk2_widgets[_GTK_FRAME_TYPE] = gtk_frame_new(NULL);
             }
             result = gtk2_widgets[_GTK_FRAME_TYPE];
             break;
@@ -1305,7 +753,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_MENU_TYPE]))
             {
                 gtk2_widgets[_GTK_MENU_TYPE] =
-                    (*fp_gtk_menu_new)();
+                    gtk_menu_new ();
             }
             result = gtk2_widgets[_GTK_MENU_TYPE];
             break;
@@ -1315,7 +763,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_MENU_ITEM_TYPE]))
             {
                 gtk2_widgets[_GTK_MENU_ITEM_TYPE] =
-                    (*fp_gtk_menu_item_new)();
+                    gtk_menu_item_new ();
             }
             result = gtk2_widgets[_GTK_MENU_ITEM_TYPE];
             break;
@@ -1323,7 +771,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_MENU_BAR_TYPE]))
             {
                 gtk2_widgets[_GTK_MENU_BAR_TYPE] =
-                    (*fp_gtk_menu_bar_new)();
+                    gtk_menu_bar_new ();
             }
             result = gtk2_widgets[_GTK_MENU_BAR_TYPE];
             break;
@@ -1332,7 +780,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_DIALOG_TYPE]))
             {
                 gtk2_widgets[_GTK_DIALOG_TYPE] =
-                    (*fp_gtk_dialog_new)();
+                    gtk_dialog_new ();
             }
             result = gtk2_widgets[_GTK_DIALOG_TYPE];
             break;
@@ -1341,7 +789,7 @@
                     (NULL == gtk2_widgets[_GTK_SEPARATOR_MENU_ITEM_TYPE]))
             {
                 gtk2_widgets[_GTK_SEPARATOR_MENU_ITEM_TYPE] =
-                    (*fp_gtk_separator_menu_item_new)();
+                    gtk_separator_menu_item_new ();
             }
             result = gtk2_widgets[_GTK_SEPARATOR_MENU_ITEM_TYPE];
             break;
@@ -1349,7 +797,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_HPROGRESS_BAR_TYPE]))
             {
                 gtk2_widgets[_GTK_HPROGRESS_BAR_TYPE] =
-                    (*fp_gtk_progress_bar_new)();
+                    gtk_progress_bar_new ();
             }
             result = gtk2_widgets[_GTK_HPROGRESS_BAR_TYPE];
             break;
@@ -1357,12 +805,12 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_VPROGRESS_BAR_TYPE]))
             {
                 gtk2_widgets[_GTK_VPROGRESS_BAR_TYPE] =
-                    (*fp_gtk_progress_bar_new)();
+                    gtk_progress_bar_new ();
                 /*
                  * Vertical JProgressBars always go bottom-to-top,
                  * regardless of the ComponentOrientation.
                  */
-                (*fp_gtk_progress_bar_set_orientation)(
+                gtk_progress_bar_set_orientation (
                     (GtkProgressBar *)gtk2_widgets[_GTK_VPROGRESS_BAR_TYPE],
                     GTK_PROGRESS_BOTTOM_TO_TOP);
             }
@@ -1372,7 +820,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_RADIO_BUTTON_TYPE]))
             {
                 gtk2_widgets[_GTK_RADIO_BUTTON_TYPE] =
-                    (*fp_gtk_radio_button_new)(NULL);
+                    gtk_radio_button_new (NULL);
             }
             result = gtk2_widgets[_GTK_RADIO_BUTTON_TYPE];
             break;
@@ -1381,7 +829,7 @@
                     (NULL == gtk2_widgets[_GTK_RADIO_MENU_ITEM_TYPE]))
             {
                 gtk2_widgets[_GTK_RADIO_MENU_ITEM_TYPE] =
-                    (*fp_gtk_radio_menu_item_new)(NULL);
+                    gtk_radio_menu_item_new (NULL);
             }
             result = gtk2_widgets[_GTK_RADIO_MENU_ITEM_TYPE];
             break;
@@ -1390,7 +838,7 @@
                     (NULL == gtk2_widgets[_GTK_SCROLLED_WINDOW_TYPE]))
             {
                 gtk2_widgets[_GTK_SCROLLED_WINDOW_TYPE] =
-                    (*fp_gtk_scrolled_window_new)(NULL, NULL);
+                    gtk_scrolled_window_new (NULL, NULL);
             }
             result = gtk2_widgets[_GTK_SCROLLED_WINDOW_TYPE];
             break;
@@ -1400,10 +848,10 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_SPIN_BUTTON_TYPE]))
             {
                 result = gtk2_widgets[_GTK_SPIN_BUTTON_TYPE] =
-                    (*fp_gtk_spin_button_new)(NULL, 0, 0);
+                    gtk_spin_button_new (NULL, 0, 0);
 
-                GtkSettings* settings = fp_gtk_widget_get_settings(result);
-                fp_g_object_set(settings, "gtk-cursor-blink", FALSE, NULL);
+                GtkSettings* settings = gtk_widget_get_settings(result);
+                g_object_set(settings, "gtk-cursor-blink", FALSE, NULL);
             }
             result = gtk2_widgets[_GTK_SPIN_BUTTON_TYPE];
             break;
@@ -1414,7 +862,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_NOTEBOOK_TYPE]))
             {
                 gtk2_widgets[_GTK_NOTEBOOK_TYPE] =
-                    (*fp_gtk_notebook_new)(NULL);
+                    gtk_notebook_new ();
             }
             result = gtk2_widgets[_GTK_NOTEBOOK_TYPE];
             break;
@@ -1422,7 +870,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_TOGGLE_BUTTON_TYPE]))
             {
                 gtk2_widgets[_GTK_TOGGLE_BUTTON_TYPE] =
-                    (*fp_gtk_toggle_button_new)(NULL);
+                    gtk_toggle_button_new ();
             }
             result = gtk2_widgets[_GTK_TOGGLE_BUTTON_TYPE];
             break;
@@ -1431,7 +879,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_TOOLBAR_TYPE]))
             {
                 gtk2_widgets[_GTK_TOOLBAR_TYPE] =
-                    (*fp_gtk_toolbar_new)(NULL);
+                    gtk_toolbar_new ();
             }
             result = gtk2_widgets[_GTK_TOOLBAR_TYPE];
             break;
@@ -1440,7 +888,7 @@
                     (NULL == gtk2_widgets[_GTK_SEPARATOR_TOOL_ITEM_TYPE]))
             {
                 gtk2_widgets[_GTK_SEPARATOR_TOOL_ITEM_TYPE] =
-                    (*fp_gtk_separator_tool_item_new)();
+                    gtk_separator_tool_item_new();
             }
             result = gtk2_widgets[_GTK_SEPARATOR_TOOL_ITEM_TYPE];
             break;
@@ -1449,7 +897,7 @@
             {
                 GtkAdjustment *adjustment = create_adjustment();
                 gtk2_widgets[_GTK_VIEWPORT_TYPE] =
-                    (*fp_gtk_viewport_new)(adjustment, adjustment);
+                    gtk_viewport_new (adjustment, adjustment);
             }
             result = gtk2_widgets[_GTK_VIEWPORT_TYPE];
             break;
@@ -1461,7 +909,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_VSCROLLBAR_TYPE]))
             {
                 gtk2_widgets[_GTK_VSCROLLBAR_TYPE] =
-                    (*fp_gtk_vscrollbar_new)(create_adjustment());
+                    gtk_vscrollbar_new (create_adjustment());
             }
             result = gtk2_widgets[_GTK_VSCROLLBAR_TYPE];
             break;
@@ -1469,7 +917,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_VSEPARATOR_TYPE]))
             {
                 gtk2_widgets[_GTK_VSEPARATOR_TYPE] =
-                    (*fp_gtk_vseparator_new)();
+                    gtk_vseparator_new ();
             }
             result = gtk2_widgets[_GTK_VSEPARATOR_TYPE];
             break;
@@ -1479,7 +927,7 @@
             if (init_result = (NULL == gtk2_widgets[_GTK_VSCALE_TYPE]))
             {
                 gtk2_widgets[_GTK_VSCALE_TYPE] =
-                    (*fp_gtk_vscale_new)(NULL);
+                    gtk_vscale_new (NULL);
             }
             result = gtk2_widgets[_GTK_VSCALE_TYPE];
             /*
@@ -1492,7 +940,7 @@
         case VSPLIT_PANE_DIVIDER:
             if (init_result = (NULL == gtk2_widgets[_GTK_VPANED_TYPE]))
             {
-                gtk2_widgets[_GTK_VPANED_TYPE] = (*fp_gtk_vpaned_new)();
+                gtk2_widgets[_GTK_VPANED_TYPE] = gtk_vpaned_new ();
             }
             result = gtk2_widgets[_GTK_VPANED_TYPE];
             break;
@@ -1510,14 +958,14 @@
                 widget_type == POPUP_MENU_SEPARATOR)
         {
             GtkWidget *menu = gtk2_get_widget(POPUP_MENU);
-            (*fp_gtk_menu_shell_append)((GtkMenuShell *)menu, result);
+            gtk_menu_shell_append ((GtkMenuShell *)menu, result);
         }
         else if (widget_type == POPUP_MENU)
         {
             GtkWidget *menu_bar = gtk2_get_widget(MENU_BAR);
-            GtkWidget *root_menu = (*fp_gtk_menu_item_new)();
-            (*fp_gtk_menu_item_set_submenu)((GtkMenuItem*)root_menu, result);
-            (*fp_gtk_menu_shell_append)((GtkMenuShell *)menu_bar, root_menu);
+            GtkWidget *root_menu = gtk_menu_item_new ();
+            gtk_menu_item_set_submenu ((GtkMenuItem*)root_menu, result);
+            gtk_menu_shell_append ((GtkMenuShell *)menu_bar, root_menu);
         }
         else if (widget_type == COMBO_BOX_ARROW_BUTTON ||
                  widget_type == COMBO_BOX_TEXT_FIELD)
@@ -1527,23 +975,30 @@
             * in order to trick engines into thinking it's a real combobox
             * arrow button/text field.
             */
-            GtkWidget *combo = (*fp_gtk_combo_box_entry_new)();
+            GtkWidget *combo = gtk_combo_box_entry_new ();
+	    gboolean use_new_combo;
+	    
+#ifdef USE_SYSTEM_GTK
+	    use_new_combo = TRUE;
+#else
+	    use_new_combo = new_combo();
+#endif
 
-            if (new_combo && widget_type == COMBO_BOX_ARROW_BUTTON) {
-                (*fp_gtk_widget_set_parent)(result, combo);
+            if (use_new_combo && widget_type == COMBO_BOX_ARROW_BUTTON) {
+                gtk_widget_set_parent (result, combo);
                 ((GtkBin*)combo)->child = result;
             } else {
-                (*fp_gtk_container_add)((GtkContainer *)combo, result);
+                gtk_container_add ((GtkContainer *)combo, result);
             }
-            (*fp_gtk_container_add)((GtkContainer *)gtk2_fixed, combo);
+            gtk_container_add ((GtkContainer *)gtk2_fixed, combo);
         }
         else if (widget_type != TOOL_TIP &&
                  widget_type != INTERNAL_FRAME &&
                  widget_type != OPTION_PANE)
         {
-            (*fp_gtk_container_add)((GtkContainer *)gtk2_fixed, result);
+            gtk_container_add ((GtkContainer *)gtk2_fixed, result);
         }
-        (*fp_gtk_widget_realize)(result);
+        gtk_widget_realize (result);
     }
     return result;
 }
@@ -1585,7 +1040,7 @@
         case COMBO_BOX_ARROW_BUTTON:
         case TABLE:
             x = 1;
-            (*fp_gtk_widget_size_request)(gtk2_widget, &size);
+            gtk_widget_size_request (gtk2_widget, &size);
             w = size.width - ((GtkMisc*)gtk2_widget)->xpad * 2;
             h = size.height - ((GtkMisc*)gtk2_widget)->ypad * 2;
             w = h = MIN(MIN(w, h), MIN(width,height)) * 0.7;
@@ -1599,10 +1054,10 @@
     x += (width - w) / 2;
     y += (height - h) / 2;
 
-    (*fp_gtk_paint_arrow)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_arrow (gtk2_widget->style, gtk2_white_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail, arrow_type, fill,
             x, y, w, h);
-    (*fp_gtk_paint_arrow)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_arrow (gtk2_widget->style, gtk2_black_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail, arrow_type, fill,
             x, y, w, h);
 }
@@ -1748,9 +1203,9 @@
         break;
     }
 
-    (*fp_gtk_paint_box)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_box (gtk2_widget->style, gtk2_white_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail, x, y, width, height);
-    (*fp_gtk_paint_box)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_box (gtk2_widget->style, gtk2_black_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail, x, y, width, height);
 
     /*
@@ -1769,10 +1224,10 @@
     GdkRectangle area = { x, y, width, height };
 
     gtk2_widget = gtk2_get_widget(widget_type);
-    (*fp_gtk_paint_box_gap)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_box_gap(gtk2_widget->style, gtk2_white_pixmap, state_type,
             shadow_type, &area, gtk2_widget, detail,
             x, y, width, height, gap_side, gap_x, gap_width);
-    (*fp_gtk_paint_box_gap)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_box_gap(gtk2_widget->style, gtk2_black_pixmap, state_type,
             shadow_type, &area, gtk2_widget, detail,
             x, y, width, height, gap_side, gap_x, gap_width);
 }
@@ -1786,10 +1241,10 @@
     gtk2_widget = gtk2_get_widget(widget_type);
     init_toggle_widget(widget_type, synth_state);
 
-    (*fp_gtk_paint_check)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_check (gtk2_widget->style, gtk2_white_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height);
-    (*fp_gtk_paint_check)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_check (gtk2_widget->style, gtk2_black_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height);
 }
@@ -1799,10 +1254,10 @@
         gint x, gint y, gint width, gint height)
 {
     gtk2_widget = gtk2_get_widget(widget_type);
-    (*fp_gtk_paint_diamond)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_diamond (gtk2_widget->style, gtk2_white_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height);
-    (*fp_gtk_paint_diamond)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_diamond (gtk2_widget->style, gtk2_black_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height);
 }
@@ -1812,10 +1267,10 @@
         GtkExpanderStyle expander_style)
 {
     gtk2_widget = gtk2_get_widget(widget_type);
-    (*fp_gtk_paint_expander)(gtk2_widget->style, gtk2_white_pixmap,
+    gtk_paint_expander (gtk2_widget->style, gtk2_white_pixmap,
             state_type, NULL, gtk2_widget, detail,
             x + width / 2, y + height / 2, expander_style);
-    (*fp_gtk_paint_expander)(gtk2_widget->style, gtk2_black_pixmap,
+    gtk_paint_expander (gtk2_widget->style, gtk2_black_pixmap,
             state_type, NULL, gtk2_widget, detail,
             x + width / 2, y + height / 2, expander_style);
 }
@@ -1825,10 +1280,10 @@
         gint x, gint y, gint width, gint height, GtkPositionType gap_side)
 {
     gtk2_widget = gtk2_get_widget(widget_type);
-    (*fp_gtk_paint_extension)(gtk2_widget->style, gtk2_white_pixmap,
+    gtk_paint_extension (gtk2_widget->style, gtk2_white_pixmap,
             state_type, shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height, gap_side);
-    (*fp_gtk_paint_extension)(gtk2_widget->style, gtk2_black_pixmap,
+    gtk_paint_extension (gtk2_widget->style, gtk2_black_pixmap,
             state_type, shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height, gap_side);
 }
@@ -1844,10 +1299,10 @@
     else
         ((GtkObject*)gtk2_widget)->flags &= ~GTK_HAS_FOCUS;
 
-    (*fp_gtk_paint_flat_box)(gtk2_widget->style, gtk2_white_pixmap,
+    gtk_paint_flat_box (gtk2_widget->style, gtk2_white_pixmap,
             state_type, shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height);
-    (*fp_gtk_paint_flat_box)(gtk2_widget->style, gtk2_black_pixmap,
+    gtk_paint_flat_box (gtk2_widget->style, gtk2_black_pixmap,
             state_type, shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height);
 }
@@ -1856,9 +1311,9 @@
         const char *detail, gint x, gint y, gint width, gint height)
 {
     gtk2_widget = gtk2_get_widget(widget_type);
-    (*fp_gtk_paint_focus)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_focus (gtk2_widget->style, gtk2_white_pixmap, state_type,
             NULL, gtk2_widget, detail, x, y, width, height);
-    (*fp_gtk_paint_focus)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_focus (gtk2_widget->style, gtk2_black_pixmap, state_type,
             NULL, gtk2_widget, detail, x, y, width, height);
 }
 
@@ -1867,10 +1322,10 @@
         gint x, gint y, gint width, gint height, GtkOrientation orientation)
 {
     gtk2_widget = gtk2_get_widget(widget_type);
-    (*fp_gtk_paint_handle)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_handle (gtk2_widget->style, gtk2_white_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height, orientation);
-    (*fp_gtk_paint_handle)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_handle (gtk2_widget->style, gtk2_black_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height, orientation);
 }
@@ -1879,9 +1334,9 @@
         const gchar *detail, gint x, gint y, gint width, gint height)
 {
     gtk2_widget = gtk2_get_widget(widget_type);
-    (*fp_gtk_paint_hline)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_hline (gtk2_widget->style, gtk2_white_pixmap, state_type,
             NULL, gtk2_widget, detail, x, x + width, y);
-    (*fp_gtk_paint_hline)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_hline (gtk2_widget->style, gtk2_black_pixmap, state_type,
             NULL, gtk2_widget, detail, x, x + width, y);
 }
 
@@ -1894,10 +1349,10 @@
     gtk2_widget = gtk2_get_widget(widget_type);
     init_toggle_widget(widget_type, synth_state);
 
-    (*fp_gtk_paint_option)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_option (gtk2_widget->style, gtk2_white_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height);
-    (*fp_gtk_paint_option)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_option (gtk2_widget->style, gtk2_black_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height);
 }
@@ -1940,9 +1395,9 @@
         break;
     }
 
-    (*fp_gtk_paint_shadow)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_shadow (gtk2_widget->style, gtk2_white_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail, x, y, width, height);
-    (*fp_gtk_paint_shadow)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_shadow (gtk2_widget->style, gtk2_black_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail, x, y, width, height);
 
     /*
@@ -1957,10 +1412,10 @@
         gint x, gint y, gint width, gint height, GtkOrientation orientation)
 {
     gtk2_widget = gtk2_get_widget(widget_type);
-    (*fp_gtk_paint_slider)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_slider (gtk2_widget->style, gtk2_white_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height, orientation);
-    (*fp_gtk_paint_slider)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_slider (gtk2_widget->style, gtk2_black_pixmap, state_type,
             shadow_type, NULL, gtk2_widget, detail,
             x, y, width, height, orientation);
 }
@@ -1969,9 +1424,9 @@
         const gchar *detail, gint x, gint y, gint width, gint height)
 {
     gtk2_widget = gtk2_get_widget(widget_type);
-    (*fp_gtk_paint_vline)(gtk2_widget->style, gtk2_white_pixmap, state_type,
+    gtk_paint_vline (gtk2_widget->style, gtk2_white_pixmap, state_type,
             NULL, gtk2_widget, detail, y, y + height, x);
-    (*fp_gtk_paint_vline)(gtk2_widget->style, gtk2_black_pixmap, state_type,
+    gtk_paint_vline (gtk2_widget->style, gtk2_black_pixmap, state_type,
             NULL, gtk2_widget, detail, y, y + height, x);
 }
 
@@ -1979,9 +1434,9 @@
         gint x, gint y, gint width, gint height)
 {
     gtk2_widget = gtk2_get_widget(widget_type);
-    (*fp_gtk_style_apply_default_background)(gtk2_widget->style,
+    gtk_style_apply_default_background (gtk2_widget->style,
             gtk2_white_pixmap, TRUE, state_type, NULL, x, y, width, height);
-    (*fp_gtk_style_apply_default_background)(gtk2_widget->style,
+    gtk_style_apply_default_background (gtk2_widget->style,
             gtk2_black_pixmap, TRUE, state_type, NULL, x, y, width, height);
 }
 
@@ -1991,8 +1446,8 @@
     init_containers();
     gtk2_widget = gtk2_get_widget((widget_type < 0) ? IMAGE : widget_type);
     gtk2_widget->state = GTK_STATE_NORMAL;
-    (*fp_gtk_widget_set_direction)(gtk2_widget, direction);
-    return (*fp_gtk_widget_render_icon)(gtk2_widget, stock_id, size, detail);
+    gtk_widget_set_direction (gtk2_widget, direction);
+    return gtk_widget_render_icon (gtk2_widget, stock_id, size, detail);
 }
 
 /*************************************************/
@@ -2090,81 +1545,81 @@
     GValue value;
     value.g_type = 0;
 
-    GParamSpec* param = (*fp_gtk_widget_class_find_style_property)(
+    GParamSpec* param = gtk_widget_class_find_style_property (
                                     ((GTypeInstance*)gtk2_widget)->g_class, key);
     if( param )
     {
-        (*fp_g_value_init)( &value, param->value_type );
-        (*fp_gtk_widget_style_get_property)(gtk2_widget, key, &value);
+        g_value_init ( &value, param->value_type );
+        gtk_widget_style_get_property (gtk2_widget, key, &value);
 
-        if( (*fp_g_type_is_a)( param->value_type, G_TYPE_BOOLEAN ))
+        if( g_type_is_a ( param->value_type, G_TYPE_BOOLEAN ))
         {
-            gboolean val = (*fp_g_value_get_boolean)(&value);
+            gboolean val = g_value_get_boolean (&value);
             return create_Boolean(env, (jboolean)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_CHAR ))
+        else if( g_type_is_a ( param->value_type, G_TYPE_CHAR ))
         {
-            gchar val = (*fp_g_value_get_char)(&value);
+            gchar val = g_value_get_char (&value);
             return create_Character(env, (jchar)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_UCHAR ))
+        else if( g_type_is_a( param->value_type, G_TYPE_UCHAR ))
         {
-            guchar val = (*fp_g_value_get_uchar)(&value);
+            guchar val = g_value_get_uchar (&value);
             return create_Character(env, (jchar)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_INT ))
+        else if( g_type_is_a ( param->value_type, G_TYPE_INT ))
         {
-            gint val = (*fp_g_value_get_int)(&value);
+            gint val = g_value_get_int (&value);
             return create_Integer(env, (jint)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_UINT ))
+        else if( g_type_is_a( param->value_type, G_TYPE_UINT ))
         {
-            guint val = (*fp_g_value_get_uint)(&value);
+            guint val = g_value_get_uint (&value);
             return create_Integer(env, (jint)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_LONG ))
+        else if( g_type_is_a( param->value_type, G_TYPE_LONG ))
         {
-            glong val = (*fp_g_value_get_long)(&value);
+            glong val = g_value_get_long (&value);
             return create_Long(env, (jlong)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_ULONG ))
+        else if( g_type_is_a( param->value_type, G_TYPE_ULONG ))
         {
-            gulong val = (*fp_g_value_get_ulong)(&value);
+            gulong val = g_value_get_ulong (&value);
             return create_Long(env, (jlong)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_INT64 ))
+        else if( g_type_is_a( param->value_type, G_TYPE_INT64 ))
         {
-            gint64 val = (*fp_g_value_get_int64)(&value);
+            gint64 val = g_value_get_int64(&value);
             return create_Long(env, (jlong)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_UINT64 ))
+        else if( g_type_is_a( param->value_type, G_TYPE_UINT64 ))
         {
-            guint64 val = (*fp_g_value_get_uint64)(&value);
+            guint64 val = g_value_get_uint64 (&value);
             return create_Long(env, (jlong)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_FLOAT ))
+        else if( g_type_is_a( param->value_type, G_TYPE_FLOAT ))
         {
-            gfloat val = (*fp_g_value_get_float)(&value);
+            gfloat val = g_value_get_float (&value);
             return create_Float(env, (jfloat)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_DOUBLE ))
+        else if( g_type_is_a( param->value_type, G_TYPE_DOUBLE ))
         {
-            gdouble val = (*fp_g_value_get_double)(&value);
+            gdouble val = g_value_get_double (&value);
             return create_Double(env, (jdouble)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_ENUM ))
+        else if( g_type_is_a( param->value_type, G_TYPE_ENUM ))
         {
-            gint val = (*fp_g_value_get_enum)(&value);
+            gint val = g_value_get_enum (&value);
             return create_Integer(env, (jint)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_FLAGS ))
+        else if( g_type_is_a( param->value_type, G_TYPE_FLAGS ))
         {
-            guint val = (*fp_g_value_get_flags)(&value);
+            guint val = g_value_get_flags (&value);
             return create_Integer(env, (jint)val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_STRING ))
+        else if( g_type_is_a( param->value_type, G_TYPE_STRING ))
         {
-            const gchar* val = (*fp_g_value_get_string)(&value);
+            const gchar* val = g_value_get_string (&value);
 
             /* We suppose that all values come in C locale and
              * utf-8 representation of a string is the same as
@@ -2173,31 +1628,31 @@
              */
             return (*env)->NewStringUTF(env, val);
         }
-        else if( (*fp_g_type_is_a)( param->value_type, GTK_TYPE_BORDER ))
+        else if( g_type_is_a( param->value_type, GTK_TYPE_BORDER ))
         {
-            GtkBorder *border = (GtkBorder*)(*fp_g_value_get_boxed)(&value);
+            GtkBorder *border = (GtkBorder*)g_value_get_boxed(&value);
             return border ? create_Insets(env, border) : NULL;
         }
 
         /*      TODO: Other types are not supported yet.*/
-/*        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_PARAM ))
+/*        else if( g_type_is_a( param->value_type, G_TYPE_PARAM ))
         {
-            GParamSpec* val = (*fp_g_value_get_param)(&value);
+            GParamSpec* val = g_value_get_param (&value);
             printf( "Param: %p\n", val );
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_BOXED ))
+        else if( g_type_is_a( param->value_type, G_TYPE_BOXED ))
         {
-            gpointer* val = (*fp_g_value_get_boxed)(&value);
+            gpointer* val = g_value_get_boxed (&value);
             printf( "Boxed: %p\n", val );
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_POINTER ))
+        else if( g_type_is_a( param->value_type, G_TYPE_POINTER ))
         {
-            gpointer* val = (*fp_g_value_get_pointer)(&value);
+            gpointer* val = g_value_get_pointer (&value);
             printf( "Pointer: %p\n", val );
         }
-        else if( (*fp_g_type_is_a)( param->value_type, G_TYPE_OBJECT ))
+        else if( g_type_is_a( param->value_type, G_TYPE_OBJECT ))
         {
-            GObject* val = (GObject*)(*fp_g_value_get_object)(&value);
+            GObject* val = (GObject*)g_value_get_object (&value);
             printf( "Object: %p\n", val );
         }*/
     }
@@ -2212,7 +1667,7 @@
 
     gtk2_widget = gtk2_get_widget(widget_type);
 
-    adj = (*fp_gtk_range_get_adjustment)((GtkRange *)gtk2_widget);
+    adj = gtk_range_get_adjustment ((GtkRange *)gtk2_widget);
     adj->value = (gdouble)value;
     adj->lower = (gdouble)min;
     adj->upper = (gdouble)max;
@@ -2333,9 +1788,9 @@
 
     if (style && style->font_desc)
     {
-        gchar* val = (*fp_pango_font_description_to_string)(style->font_desc);
+        gchar* val = pango_font_description_to_string (style->font_desc);
         result = (*env)->NewStringUTF(env, val);
-        (*fp_g_free)( val );
+        g_free( val );
     }
 
     return result;
@@ -2347,9 +1802,9 @@
     jobject result = NULL;
     gchar*  strval = NULL;
 
-    (*fp_g_object_get)(settings, key, &strval, NULL);
+    g_object_get (settings, key, &strval, NULL);
     result = (*env)->NewStringUTF(env, strval);
-    (*fp_g_free)(strval);
+    g_free (strval);
 
     return result;
 }
@@ -2358,13 +1813,13 @@
 {
     gint    intval = NULL;
 
-    (*fp_g_object_get)(settings, key, &intval, NULL);
+    g_object_get (settings, key, &intval, NULL);
     return create_Integer(env, intval);
 }*/
 
 jobject gtk2_get_setting(JNIEnv *env, Setting property)
 {
-    GtkSettings* settings = (*fp_gtk_settings_get_default)();
+    GtkSettings* settings = gtk_settings_get_default ();
 
     switch (property)
     {

--- a/src/solaris/native/sun/awt/gtk2_interface.h	Thu Aug 11 17:22:31 2011 +0200
+++ b/src/solaris/native/sun/awt/gtk2_interface.h	Fri Aug 12 09:18:57 2011 +0100
@@ -28,20 +28,11 @@
 #include <stdlib.h>
 #include <jni.h>
 
-#define _G_TYPE_CIC(ip, gt, ct)       ((ct*) ip)
-#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type)    (_G_TYPE_CIC ((instance), (g_type), c_type))
-#define GTK_TYPE_FILE_CHOOSER             (fp_gtk_file_chooser_get_type ())
-#define GTK_FILE_CHOOSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER, GtkFileChooser))
-#define fp_g_signal_connect(instance, detailed_signal, c_handler, data) \
-    fp_g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, (GConnectFlags) 0)
-#define G_CALLBACK(f) ((GCallback) (f))
-#define G_TYPE_FUNDAMENTAL_SHIFT (2)
-#define G_TYPE_MAKE_FUNDAMENTAL(x) ((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT))
-#define G_TYPE_OBJECT G_TYPE_MAKE_FUNDAMENTAL (20)
-#define G_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_OBJECT, GObject))
-#define GTK_STOCK_CANCEL           "gtk-cancel"
-#define GTK_STOCK_SAVE             "gtk-save"
-#define GTK_STOCK_OPEN             "gtk-open"
+#include <gtk/gtk.h>
+
+#ifndef USE_SYSTEM_GTK
+#include <gtk_fp.h>
+#endif
 
 typedef enum _WidgetType
 {
@@ -142,500 +133,6 @@
     GTK_ICON_SIZES
 } Setting;
 
-/* GTK types, here to eliminate need for GTK headers at compile time */
-
-#ifndef FALSE
-#define FALSE           (0)
-#define TRUE            (!FALSE)
-#endif
-
-#define GTK_HAS_FOCUS   (1 << 12)
-#define GTK_HAS_DEFAULT (1 << 14)
-
-
-/* basic types */
-typedef char    gchar;
-typedef short   gshort;
-typedef int     gint;
-typedef long    glong;
-typedef float   gfloat;
-typedef double  gdouble;
-typedef void*   gpointer;
-typedef gint    gboolean;
-
-typedef signed char  gint8;
-typedef signed short gint16;
-typedef signed int   gint32;
-
-typedef unsigned char  guchar;
-typedef unsigned char  guint8;
-typedef unsigned short gushort;
-typedef unsigned short guint16;
-typedef unsigned int   guint;
-typedef unsigned int   guint32;
-typedef unsigned int   gsize;
-typedef unsigned long  gulong;
-
-typedef signed long long   gint64;
-typedef unsigned long long guint64;
-
-/* enumerated constants */
-typedef enum
-{
-  GTK_ARROW_UP,
-  GTK_ARROW_DOWN,
-  GTK_ARROW_LEFT,
-  GTK_ARROW_RIGHT
-} GtkArrowType;
-
-typedef enum {
-  GDK_COLORSPACE_RGB
-} GdkColorspace;
-
-typedef enum
-{
-  GTK_EXPANDER_COLLAPSED,
-  GTK_EXPANDER_SEMI_COLLAPSED,
-  GTK_EXPANDER_SEMI_EXPANDED,
-  GTK_EXPANDER_EXPANDED
-} GtkExpanderStyle;
-
-typedef enum
-{
-  GTK_ICON_SIZE_INVALID,
-  GTK_ICON_SIZE_MENU,
-  GTK_ICON_SIZE_SMALL_TOOLBAR,
-  GTK_ICON_SIZE_LARGE_TOOLBAR,
-  GTK_ICON_SIZE_BUTTON,
-  GTK_ICON_SIZE_DND,
-  GTK_ICON_SIZE_DIALOG
-} GtkIconSize;
-
-typedef enum
-{
-  GTK_ORIENTATION_HORIZONTAL,
-  GTK_ORIENTATION_VERTICAL
-} GtkOrientation;
-
-typedef enum
-{
-  GTK_POS_LEFT,
-  GTK_POS_RIGHT,
-  GTK_POS_TOP,
-  GTK_POS_BOTTOM
-} GtkPositionType;
-
-typedef enum
-{
-  GTK_SHADOW_NONE,
-  GTK_SHADOW_IN,
-  GTK_SHADOW_OUT,
-  GTK_SHADOW_ETCHED_IN,
-  GTK_SHADOW_ETCHED_OUT
-} GtkShadowType;
-
-typedef enum
-{
-  GTK_STATE_NORMAL,
-  GTK_STATE_ACTIVE,
-  GTK_STATE_PRELIGHT,
-  GTK_STATE_SELECTED,
-  GTK_STATE_INSENSITIVE
-} GtkStateType;
-
-typedef enum
-{
-  GTK_TEXT_DIR_NONE,
-  GTK_TEXT_DIR_LTR,
-  GTK_TEXT_DIR_RTL
-} GtkTextDirection;
-
-typedef enum
-{
-  GTK_WINDOW_TOPLEVEL,
-  GTK_WINDOW_POPUP
-} GtkWindowType;
-
-typedef enum
-{
-  G_PARAM_READABLE            = 1 << 0,
-  G_PARAM_WRITABLE            = 1 << 1,
-  G_PARAM_CONSTRUCT           = 1 << 2,
-  G_PARAM_CONSTRUCT_ONLY      = 1 << 3,
-  G_PARAM_LAX_VALIDATION      = 1 << 4,
-  G_PARAM_PRIVATE             = 1 << 5
-} GParamFlags;
-
-/* We define all structure pointers to be void* */
-typedef void GError;
-typedef void GMainContext;
-
-typedef struct _GSList GSList;
-struct _GSList
-{
-  gpointer data;
-  GSList *next;
-};
-
-typedef void GdkColormap;
-typedef void GdkDrawable;
-typedef void GdkGC;
-typedef void GdkPixbuf;
-typedef void GdkPixmap;
-typedef void GdkWindow;
-
-typedef void GtkFixed;
-typedef void GtkMenuItem;
-typedef void GtkMenuShell;
-typedef void GtkWidgetClass;
-typedef void PangoFontDescription;
-typedef void GtkSettings;
-
-/* Some real structures */
-typedef struct
-{
-  guint32 pixel;
-  guint16 red;
-  guint16 green;
-  guint16 blue;
-} GdkColor;
-
-typedef struct {
-  gint      fd;
-  gushort   events;
-  gushort   revents;
-} GPollFD;
-
-typedef struct {
-  gint x;
-  gint y;
-  gint width;
-  gint height;
-} GdkRectangle;
-
-typedef struct {
-  gint x;
-  gint y;
-  gint width;
-  gint height;
-} GtkAllocation;
-
-typedef struct {
-  gint width;
-  gint height;
-} GtkRequisition;
-
-typedef struct {
-  GtkWidgetClass *g_class;
-} GTypeInstance;
-
-typedef struct {
-  gint left;
-  gint right;
-  gint top;
-  gint bottom;
-} GtkBorder;
-
-/******************************************************
- * FIXME: it is more safe to include gtk headers for
- * the precise type definition of GType and other
- * structures. This is a place where getting rid of gtk
- * headers may be dangerous.
- ******************************************************/
-typedef gulong         GType;
-
-typedef struct
-{
-  GType         g_type;
-
-  union {
-    gint        v_int;
-    guint       v_uint;
-    glong       v_long;
-    gulong      v_ulong;
-    gint64      v_int64;
-    guint64     v_uint64;
-    gfloat      v_float;
-    gdouble     v_double;
-    gpointer    v_pointer;
-  } data[2];
-} GValue;
-
-typedef struct
-{
-  GTypeInstance  g_type_instance;
-
-  gchar         *name;
-  GParamFlags    flags;
-  GType          value_type;
-  GType          owner_type;
-} GParamSpec;
-
-typedef struct {
-  GTypeInstance g_type_instance;
-  guint         ref_count;
-  void         *qdata;
-} GObject;
-
-typedef struct {
-  GObject parent_instance;
-  guint32 flags;
-} GtkObject;
-
-typedef struct
-{
-  GObject parent_instance;
-
-  GdkColor fg[5];
-  GdkColor bg[5];
-  GdkColor light[5];
-  GdkColor dark[5];
-  GdkColor mid[5];
-  GdkColor text[5];
-  GdkColor base[5];
-  GdkColor text_aa[5];          /* Halfway between text/base */
-
-  GdkColor black;
-  GdkColor white;
-  PangoFontDescription *font_desc;
-
-  gint xthickness;
-  gint ythickness;
-
-  GdkGC *fg_gc[5];
-  GdkGC *bg_gc[5];
-  GdkGC *light_gc[5];
-  GdkGC *dark_gc[5];
-  GdkGC *mid_gc[5];
-  GdkGC *text_gc[5];
-  GdkGC *base_gc[5];
-  GdkGC *text_aa_gc[5];
-  GdkGC *black_gc;
-  GdkGC *white_gc;
-
-  GdkPixmap *bg_pixmap[5];
-} GtkStyle;
-
-typedef struct _GtkWidget GtkWidget;
-struct _GtkWidget
-{
-  GtkObject object;
-  guint16 private_flags;
-  guint8 state;
-  guint8 saved_state;
-  gchar *name;
-  GtkStyle *style;
-  GtkRequisition requisition;
-  GtkAllocation allocation;
-  GdkWindow *window;
-  GtkWidget *parent;
-};
-
-typedef struct
-{
-  GtkWidget widget;
-
-  gfloat xalign;
-  gfloat yalign;
-
-  guint16 xpad;
-  guint16 ypad;
-} GtkMisc;
-
-typedef struct {
-  GtkWidget widget;
-  GtkWidget *focus_child;
-  guint border_width : 16;
-  guint need_resize : 1;
-  guint resize_mode : 2;
-  guint reallocate_redraws : 1;
-  guint has_focus_chain : 1;
-} GtkContainer;
-
-typedef struct {
-  GtkContainer container;
-  GtkWidget *child;
-} GtkBin;
-
-typedef struct {
-  GtkBin bin;
-  GdkWindow *event_window;
-  gchar *label_text;
-  guint activate_timeout;
-  guint constructed : 1;
-  guint in_button : 1;
-  guint button_down : 1;
-  guint relief : 2;
-  guint use_underline : 1;
-  guint use_stock : 1;
-  guint depressed : 1;
-  guint depress_on_activate : 1;
-  guint focus_on_click : 1;
-} GtkButton;
-
-typedef struct {
-  GtkButton button;
-  guint active : 1;
-  guint draw_indicator : 1;
-  guint inconsistent : 1;
-} GtkToggleButton;
-
-typedef struct _GtkAdjustment GtkAdjustment;
-struct _GtkAdjustment
-{
-  GtkObject parent_instance;
-
-  gdouble lower;
-  gdouble upper;
-  gdouble value;
-  gdouble step_increment;
-  gdouble page_increment;
-  gdouble page_size;
-};
-
-typedef enum
-{
-  GTK_UPDATE_CONTINUOUS,
-  GTK_UPDATE_DISCONTINUOUS,
-  GTK_UPDATE_DELAYED
-} GtkUpdateType;
-
-typedef struct _GtkRange GtkRange;
-struct _GtkRange
-{
-  GtkWidget widget;
-  GtkAdjustment *adjustment;
-  GtkUpdateType update_policy;
-  guint inverted : 1;
-  /*< protected >*/
-  guint flippable : 1;
-  guint has_stepper_a : 1;
-  guint has_stepper_b : 1;
-  guint has_stepper_c : 1;
-  guint has_stepper_d : 1;
-  guint need_recalc : 1;
-  guint slider_size_fixed : 1;
-  gint min_slider_size;
-  GtkOrientation orientation;
-  GdkRectangle range_rect;
-  gint slider_start, slider_end;
-  gint round_digits;
-  /*< private >*/
-  guint trough_click_forward : 1;
-  guint update_pending : 1;
-  /*GtkRangeLayout * */ void *layout;
-  /*GtkRangeStepTimer * */ void* timer;
-  gint slide_initial_slider_position;
-  gint slide_initial_coordinate;
-  guint update_timeout_id;
-  GdkWindow *event_window;
-};
-
-typedef struct _GtkProgressBar       GtkProgressBar;
-
-typedef enum
-{
-  GTK_PROGRESS_CONTINUOUS,
-  GTK_PROGRESS_DISCRETE
-} GtkProgressBarStyle;
-
-typedef enum
-{
-  GTK_PROGRESS_LEFT_TO_RIGHT,
-  GTK_PROGRESS_RIGHT_TO_LEFT,
-  GTK_PROGRESS_BOTTOM_TO_TOP,
-  GTK_PROGRESS_TOP_TO_BOTTOM
-} GtkProgressBarOrientation;
-
-typedef struct _GtkProgress       GtkProgress;
-
-struct _GtkProgress
-{
-  GtkWidget widget;
-  GtkAdjustment *adjustment;
-  GdkPixmap     *offscreen_pixmap;
-  gchar         *format;
-  gfloat         x_align;
-  gfloat         y_align;
-  guint          show_text : 1;
-  guint          activity_mode : 1;
-  guint          use_text_format : 1;
-};
-
-struct _GtkProgressBar
-{
-  GtkProgress progress;
-  GtkProgressBarStyle bar_style;
-  GtkProgressBarOrientation orientation;
-  guint blocks;
-  gint  in_block;
-  gint  activity_pos;
-  guint activity_step;
-  guint activity_blocks;
-  gdouble pulse_fraction;
-  guint activity_dir : 1;
-  guint ellipsize : 3;
-};
-
-typedef enum {
-  GTK_RESPONSE_NONE = -1,
-  GTK_RESPONSE_REJECT = -2,
-  GTK_RESPONSE_ACCEPT = -3,
-  GTK_RESPONSE_DELETE_EVENT = -4,
-  GTK_RESPONSE_OK = -5,
-  GTK_RESPONSE_CANCEL = -6,
-  GTK_RESPONSE_CLOSE = -7,
-  GTK_RESPONSE_YES = -8,
-  GTK_RESPONSE_NO = -9,
-  GTK_RESPONSE_APPLY = -10,
-  GTK_RESPONSE_HELP = -11
-} GtkResponseType;
-
-typedef struct _GtkWindow GtkWindow;
-
-typedef struct _GtkFileChooser GtkFileChooser;
-
-typedef enum {
-  GTK_FILE_CHOOSER_ACTION_OPEN,
-  GTK_FILE_CHOOSER_ACTION_SAVE,
-  GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
-  GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
-} GtkFileChooserAction;
-
-typedef struct _GtkFileFilter GtkFileFilter;
-
-typedef enum {
-  GTK_FILE_FILTER_FILENAME = 1 << 0,
-  GTK_FILE_FILTER_URI = 1 << 1,
-  GTK_FILE_FILTER_DISPLAY_NAME = 1 << 2,
-  GTK_FILE_FILTER_MIME_TYPE = 1 << 3
-} GtkFileFilterFlags;
-
-typedef struct {
-  GtkFileFilterFlags contains;
-  const gchar *filename;
-  const gchar *uri;
-  const gchar *display_name;
-  const gchar *mime_type;
-} GtkFileFilterInfo;
-
-typedef gboolean (*GtkFileFilterFunc)(const GtkFileFilterInfo *filter_info,
-    gpointer data);
-
-typedef void (*GDestroyNotify)(gpointer data);
-
-typedef void (*GCallback)(void);
-
-typedef struct _GClosure GClosure;
-
-typedef void (*GClosureNotify)(gpointer data, GClosure *closure);
-
-typedef enum {
-  G_CONNECT_AFTER = 1 << 0, G_CONNECT_SWAPPED = 1 << 1
-} GConnectFlags;
-
-typedef struct _GThreadFunctions GThreadFunctions;
-
 /*
  * Converts java.lang.String object to UTF-8 character string.
  */
@@ -649,13 +146,6 @@
  */
 gboolean gtk2_check_version();
 
-/**
- * Returns :
- * NULL if the GTK+ library is compatible with the given version, or a string
- * describing the version mismatch.
- */
-gchar* (*fp_gtk_check_version)(guint required_major, guint required_minor,
-                       guint required_micro);
 /*
  * Load the gtk2 library.  If the library is already loaded this method has no
  * effect and returns success.
@@ -738,61 +228,4 @@
 void gtk2_set_range_value(WidgetType widget_type, jdouble value,
                           jdouble min, jdouble max, jdouble visible);
 
-void (*fp_g_free)(gpointer mem);
-void (*fp_g_object_unref)(gpointer object);
-int (*fp_gdk_pixbuf_get_bits_per_sample)(const GdkPixbuf *pixbuf);
-guchar *(*fp_gdk_pixbuf_get_pixels)(const GdkPixbuf *pixbuf);
-gboolean (*fp_gdk_pixbuf_get_has_alpha)(const GdkPixbuf *pixbuf);
-int (*fp_gdk_pixbuf_get_height)(const GdkPixbuf *pixbuf);
-int (*fp_gdk_pixbuf_get_n_channels)(const GdkPixbuf *pixbuf);
-int (*fp_gdk_pixbuf_get_rowstride)(const GdkPixbuf *pixbuf);
-int (*fp_gdk_pixbuf_get_width)(const GdkPixbuf *pixbuf);
-GdkPixbuf *(*fp_gdk_pixbuf_new_from_file)(const char *filename, GError **error);
-void (*fp_gtk_widget_destroy)(GtkWidget *widget);
-void (*fp_gtk_window_present)(GtkWindow *window);
-void (*fp_gtk_window_move)(GtkWindow *window, gint x, gint y);
-void (*fp_gtk_window_resize)(GtkWindow *window, gint width, gint height);
-
-/**
- * Function Pointers for GtkFileChooser
- */
-gchar* (*fp_gtk_file_chooser_get_filename)(GtkFileChooser *chooser);
-void (*fp_gtk_widget_hide)(GtkWidget *widget);
-void (*fp_gtk_main_quit)(void);
-GtkWidget* (*fp_gtk_file_chooser_dialog_new)(const gchar *title,
-    GtkWindow *parent, GtkFileChooserAction action,
-    const gchar *first_button_text, ...);
-gboolean (*fp_gtk_file_chooser_set_current_folder)(GtkFileChooser *chooser,
-    const gchar *filename);
-gboolean (*fp_gtk_file_chooser_set_filename)(GtkFileChooser *chooser,
-    const char *filename);
-void (*fp_gtk_file_chooser_set_current_name)(GtkFileChooser *chooser,
-    const gchar *name);
-void (*fp_gtk_file_filter_add_custom)(GtkFileFilter *filter,
-    GtkFileFilterFlags needed, GtkFileFilterFunc func, gpointer data,
-    GDestroyNotify notify);
-void (*fp_gtk_file_chooser_set_filter)(GtkFileChooser *chooser,
-    GtkFileFilter *filter);
-GType (*fp_gtk_file_chooser_get_type)(void);
-GtkFileFilter* (*fp_gtk_file_filter_new)(void);
-void (*fp_gtk_file_chooser_set_do_overwrite_confirmation)(
-    GtkFileChooser *chooser, gboolean do_overwrite_confirmation);
-void (*fp_gtk_file_chooser_set_select_multiple)(
-    GtkFileChooser *chooser, gboolean select_multiple);
-gchar* (*fp_gtk_file_chooser_get_current_folder)(GtkFileChooser *chooser);
-GSList* (*fp_gtk_file_chooser_get_filenames)(GtkFileChooser *chooser);
-guint (*fp_gtk_g_slist_length)(GSList *list);
-gulong (*fp_g_signal_connect_data)(gpointer instance,
-    const gchar *detailed_signal, GCallback c_handler, gpointer data,
-    GClosureNotify destroy_data, GConnectFlags connect_flags);
-void (*fp_gtk_widget_show)(GtkWidget *widget);
-void (*fp_gtk_main)(void);
-guint (*fp_gtk_main_level)(void);
-
-
-void (*fp_g_thread_init)(GThreadFunctions *vtable);
-void (*fp_gdk_threads_init)(void);
-void (*fp_gdk_threads_enter)(void);
-void (*fp_gdk_threads_leave)(void);
-
 #endif /* !_GTK2_INTERFACE_H */

--- a/src/solaris/native/sun/awt/sun_awt_X11_GtkFileDialogPeer.c	Thu Aug 11 17:22:31 2011 +0200
+++ b/src/solaris/native/sun/awt/sun_awt_X11_GtkFileDialogPeer.c	Fri Aug 12 09:18:57 2011 +0100
@@ -52,20 +52,20 @@
     {
         // Callbacks from GTK signals are made within the GTK lock
         // So, within a signal handler there is no need to call
-        // gdk_threads_enter() / fp_gdk_threads_leave()
+        // gdk_threads_enter() / gdk_threads_leave()
         if (!isSignalHandler) {
-            fp_gdk_threads_enter();
+            gdk_threads_enter();
         }
 
-        fp_gtk_widget_hide (dialog);
-        fp_gtk_widget_destroy (dialog);
+        gtk_widget_hide (dialog);
+        gtk_widget_destroy (dialog);
 
-        fp_gtk_main_quit ();
+        gtk_main_quit ();
 
         (*env)->SetLongField(env, jpeer, widgetFieldID, 0);
 
         if (!isSignalHandler) {
-            fp_gdk_threads_leave();
+            gdk_threads_leave();
         }
     }
 }
@@ -91,16 +91,16 @@
 {
     GtkWidget * dialog;
 
-    fp_gdk_threads_enter();
+    gdk_threads_enter();
 
     dialog = (GtkWidget*)jlong_to_ptr(
             (*env)->GetLongField(env, jpeer, widgetFieldID));
 
     if (dialog != NULL) {
-        fp_gtk_window_present((GtkWindow*)dialog);
+        gtk_window_present((GtkWindow*)dialog);
     }
 
-    fp_gdk_threads_leave();
+    gdk_threads_leave();
 }
 
 /*
@@ -113,21 +113,21 @@
 {
     GtkWindow* dialog;
 
-    fp_gdk_threads_enter();
+    gdk_threads_enter();
 
     dialog = (GtkWindow*)jlong_to_ptr(
         (*env)->GetLongField(env, jpeer, widgetFieldID));
 
     if (dialog != NULL) {
         if (x >= 0 && y >= 0) {
-            fp_gtk_window_move(dialog, (gint)x, (gint)y);
+            gtk_window_move(dialog, (gint)x, (gint)y);
         }
         if (width > 0 && height > 0) {
-            fp_gtk_window_resize(dialog, (gint)width, (gint)height);
+            gtk_window_resize(dialog, (gint)width, (gint)height);
         }
     }
 
-    fp_gdk_threads_leave();
+    gdk_threads_leave();
 }
 
 /**
@@ -152,7 +152,7 @@
         return NULL;
     }
 
-    array = (*env)->NewObjectArray(env, fp_gtk_g_slist_length(list), stringCls,
+    array = (*env)->NewObjectArray(env, g_slist_length(list), stringCls,
             NULL);
     if (array == NULL) {
         JNU_ThrowInternalError(env, "Could not instantiate array files array");
@@ -185,9 +185,9 @@
     filenames = NULL;
 
     if (responseId == GTK_RESPONSE_ACCEPT) {
-        current_folder = fp_gtk_file_chooser_get_current_folder(
+        current_folder = gtk_file_chooser_get_current_folder(
                 GTK_FILE_CHOOSER(aDialog));
-        filenames = fp_gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(aDialog));
+        filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(aDialog));
     }
 
     jcurrent_folder = (*env)->NewStringUTF(env, current_folder);
@@ -195,7 +195,7 @@
 
     (*env)->CallVoidMethod(env, obj, setFileInternalMethodID, jcurrent_folder,
             jfilenames);
-    fp_g_free(current_folder);
+    g_free(current_folder);
 
     quit(env, (jobject)obj, TRUE);
 }
@@ -217,25 +217,25 @@
         (*env)->GetJavaVM(env, &jvm);
     }
 
-    fp_gdk_threads_enter();
+    gdk_threads_enter();
 
     const char *title = jtitle == NULL? "": (*env)->GetStringUTFChars(env, jtitle, 0);
 
     if (mode == java_awt_FileDialog_SAVE) {
         /* Save action */
-        dialog = fp_gtk_file_chooser_dialog_new(title, NULL,
+        dialog = gtk_file_chooser_dialog_new(title, NULL,
                 GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL,
                 GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
     }
     else {
         /* Default action OPEN */
-        dialog = fp_gtk_file_chooser_dialog_new(title, NULL,
+        dialog = gtk_file_chooser_dialog_new(title, NULL,
                 GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL,
                 GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL);
 
         /* Set multiple selection mode, that is allowed only in OPEN action */
         if (multiple) {
-            fp_gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog),
+            gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog),
                     multiple);
         }
     }
@@ -247,7 +247,7 @@
     /* Set the directory */
     if (jdir != NULL) {
         const char *dir = (*env)->GetStringUTFChars(env, jdir, 0);
-        fp_gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), dir);
+        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), dir);
         (*env)->ReleaseStringUTFChars(env, jdir, dir);
     }
 
@@ -255,43 +255,43 @@
     if (jfile != NULL) {
         const char *filename = (*env)->GetStringUTFChars(env, jfile, 0);
         if (mode == java_awt_FileDialog_SAVE) {
-            fp_gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), filename);
+            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), filename);
         } else {
-            fp_gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), filename);
+            gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), filename);
         }
         (*env)->ReleaseStringUTFChars(env, jfile, filename);
     }
 
     /* Set the file filter */
     if (jfilter != NULL) {
-        filter = fp_gtk_file_filter_new();
-        fp_gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME,
+        filter = gtk_file_filter_new();
+        gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME,
                 filenameFilterCallback, jpeer, NULL);
-        fp_gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
+        gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
     }
 
     /* Other Properties */
-    if (fp_gtk_check_version(2, 8, 0) == NULL) {
-        fp_gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(
+    if (gtk_check_version(2, 8, 0) == NULL) {
+        gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(
                 dialog), TRUE);
     }
 
     /* Set the initial location */
     if (x >= 0 && y >= 0) {
-        fp_gtk_window_move((GtkWindow*)dialog, (gint)x, (gint)y);
+        gtk_window_move((GtkWindow*)dialog, (gint)x, (gint)y);
 
         // NOTE: it doesn't set the initial size for the file chooser
         // as it seems like the file chooser overrides the size internally
     }
 
-    fp_g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(
+    g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(
             handle_response), jpeer);
 
     (*env)->SetLongField(env, jpeer, widgetFieldID, ptr_to_jlong(dialog));
 
-    fp_gtk_widget_show(dialog);
+    gtk_widget_show(dialog);
 
-    fp_gtk_main();
-    fp_gdk_threads_leave();
+    gtk_main();
+    gdk_threads_leave();
 }