# HG changeset patch # User andrew # Date 1313137137 -3600 # Node ID ac0f32da8dca4475d20ee41eb5682c746517f8c8 # Parent 18e4e42d9d6d6929d64e90d45e9b60edcc4f4ccc Support building using system Gtk+ (USE_SYSTEM_GTK, GTK_CFLAGS, GTK_LIBS) diff -r 18e4e42d9d6d -r ac0f32da8dca make/sun/xawt/FILES_c_unix.gmk --- 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 diff -r 18e4e42d9d6d -r ac0f32da8dca make/sun/xawt/Makefile --- 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 diff -r 18e4e42d9d6d -r ac0f32da8dca src/solaris/native/sun/awt/awt_UNIXToolkit.c --- 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; } diff -r 18e4e42d9d6d -r ac0f32da8dca src/solaris/native/sun/awt/gtk2/gtk/gtk.h --- /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__ */ diff -r 18e4e42d9d6d -r ac0f32da8dca src/solaris/native/sun/awt/gtk2/gtk_fp.c --- /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 +#include +#include + +#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; +} + diff -r 18e4e42d9d6d -r ac0f32da8dca src/solaris/native/sun/awt/gtk2/gtk_fp.h --- /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 + +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__ */ diff -r 18e4e42d9d6d -r ac0f32da8dca src/solaris/native/sun/awt/gtk2_interface.c --- 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 -#include #include #include #include @@ -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) { diff -r 18e4e42d9d6d -r ac0f32da8dca src/solaris/native/sun/awt/gtk2_interface.h --- 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 #include -#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 + +#ifndef USE_SYSTEM_GTK +#include +#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 */ diff -r 18e4e42d9d6d -r ac0f32da8dca src/solaris/native/sun/awt/sun_awt_X11_GtkFileDialogPeer.c --- 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(); } diff -r 18e4e42d9d6d -r ac0f32da8dca src/solaris/native/sun/awt/swing_GTKEngine.c --- a/src/solaris/native/sun/awt/swing_GTKEngine.c Thu Aug 11 17:22:31 2011 +0200 +++ b/src/solaris/native/sun/awt/swing_GTKEngine.c Fri Aug 12 09:18:57 2011 +0100 @@ -38,10 +38,10 @@ jint widget_type, jint state, jint shadow_type, jstring detail, jint x, jint y, jint w, jint h, jint arrow_type) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_arrow(widget_type, state, shadow_type, getStrFor(env, detail), x, y, w, h, arrow_type, TRUE); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -56,10 +56,10 @@ jint x, jint y, jint w, jint h, jint synth_state, jint dir) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_box(widget_type, state, shadow_type, getStrFor(env, detail), x, y, w, h, synth_state, dir); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -74,10 +74,10 @@ jint x, jint y, jint w, jint h, jint gap_side, jint gap_x, jint gap_w) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_box_gap(widget_type, state, shadow_type, getStrFor(env, detail), x, y, w, h, gap_side, gap_x, gap_w); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -91,10 +91,10 @@ jint widget_type, jint synth_state, jstring detail, jint x, jint y, jint w, jint h) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_check(widget_type, synth_state, getStrFor(env, detail), x, y, w, h); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -108,10 +108,10 @@ jint widget_type, jint state, jstring detail, jint x, jint y, jint w, jint h, jint expander_style) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_expander(widget_type, state, getStrFor(env, detail), x, y, w, h, expander_style); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -125,10 +125,10 @@ jint widget_type, jint state, jint shadow_type, jstring detail, jint x, jint y, jint w, jint h, jint placement) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_extension(widget_type, state, shadow_type, getStrFor(env, detail), x, y, w, h, placement); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -142,10 +142,10 @@ jint widget_type, jint state, jint shadow_type, jstring detail, jint x, jint y, jint w, jint h, jboolean has_focus) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_flat_box(widget_type, state, shadow_type, getStrFor(env, detail), x, y, w, h, has_focus); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -159,10 +159,10 @@ jint widget_type, jint state, jstring detail, jint x, jint y, jint w, jint h) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_focus(widget_type, state, getStrFor(env, detail), x, y, w, h); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -176,10 +176,10 @@ jint widget_type, jint state, jint shadow_type, jstring detail, jint x, jint y, jint w, jint h, jint orientation) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_handle(widget_type, state, shadow_type, getStrFor(env, detail), x, y, w, h, orientation); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -193,10 +193,10 @@ jint widget_type, jint state, jstring detail, jint x, jint y, jint w, jint h) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_hline(widget_type, state, getStrFor(env, detail), x, y, w, h); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -210,10 +210,10 @@ jint widget_type, jint synth_state, jstring detail, jint x, jint y, jint w, jint h) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_option(widget_type, synth_state, getStrFor(env, detail), x, y, w, h); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -228,10 +228,10 @@ jint x, jint y, jint w, jint h, jint synth_state, jint dir) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_shadow(widget_type, state, shadow_type, getStrFor(env, detail), x, y, w, h, synth_state, dir); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -245,10 +245,10 @@ jint widget_type, jint state, jint shadow_type, jstring detail, jint x, jint y, jint w, jint h, jint orientation) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_slider(widget_type, state, shadow_type, getStrFor(env, detail), x, y, w, h, orientation); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -262,10 +262,10 @@ jint widget_type, jint state, jstring detail, jint x, jint y, jint w, jint h) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_paint_vline(widget_type, state, getStrFor(env, detail), x, y, w, h); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -278,9 +278,9 @@ JNIEnv *env, jobject this, jint widget_type, jint state, jint x, jint y, jint w, jint h) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk_paint_background(widget_type, state, x, y, w, h); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -292,9 +292,9 @@ Java_com_sun_java_swing_plaf_gtk_GTKEngine_nativeStartPainting( JNIEnv *env, jobject this, jint w, jint h) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_init_painting(env, w, h); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -308,9 +308,9 @@ { jint transparency; gint *buffer = (gint*) (*env)->GetPrimitiveArrayCritical(env, dest, 0); - fp_gdk_threads_enter(); + gdk_threads_enter(); transparency = gtk2_copy_image(buffer, width, height); - fp_gdk_threads_leave(); + gdk_threads_leave(); (*env)->ReleasePrimitiveArrayCritical(env, dest, buffer, 0); return transparency; } @@ -323,9 +323,9 @@ JNIEXPORT void JNICALL Java_com_sun_java_swing_plaf_gtk_GTKEngine_native_1switch_1theme( JNIEnv *env, jobject this) { - fp_gdk_threads_enter(); + gdk_threads_enter(); flush_gtk_event_loop(); - fp_gdk_threads_leave(); + gdk_threads_leave(); } /* @@ -337,9 +337,9 @@ JNIEnv *env, jobject this, jint property) { jobject obj; - fp_gdk_threads_enter(); + gdk_threads_enter(); obj = gtk2_get_setting(env, property); - fp_gdk_threads_leave(); + gdk_threads_leave(); return obj; } @@ -353,7 +353,7 @@ JNIEnv *env, jobject this, jint widget_type, jdouble value, jdouble min, jdouble max, jdouble visible) { - fp_gdk_threads_enter(); + gdk_threads_enter(); gtk2_set_range_value(widget_type, value, min, max, visible); - fp_gdk_threads_leave(); + gdk_threads_leave(); } diff -r 18e4e42d9d6d -r ac0f32da8dca src/solaris/native/sun/awt/swing_GTKStyle.c --- a/src/solaris/native/sun/awt/swing_GTKStyle.c Thu Aug 11 17:22:31 2011 +0200 +++ b/src/solaris/native/sun/awt/swing_GTKStyle.c Fri Aug 12 09:18:57 2011 +0100 @@ -37,9 +37,9 @@ JNIEnv *env, jclass klass, jint widget_type) { jint ret; - fp_gdk_threads_enter(); + gdk_threads_enter(); ret = gtk2_get_xthickness(env, widget_type); - fp_gdk_threads_leave(); + gdk_threads_leave(); return ret; } @@ -53,9 +53,9 @@ JNIEnv *env, jclass klass, jint widget_type) { jint ret; - fp_gdk_threads_enter(); + gdk_threads_enter(); ret = gtk2_get_ythickness(env, widget_type); - fp_gdk_threads_leave(); + gdk_threads_leave(); return ret; } @@ -70,9 +70,9 @@ jint state_type, jint type_id) { jint ret; - fp_gdk_threads_enter(); + gdk_threads_enter(); ret = gtk2_get_color_for_state(env, widget_type, state_type, type_id); - fp_gdk_threads_leave(); + gdk_threads_leave(); return ret; } @@ -86,9 +86,9 @@ JNIEnv *env, jclass klass, jint widget_type, jstring key) { jobject ret; - fp_gdk_threads_enter(); + gdk_threads_enter(); ret = gtk2_get_class_value(env, widget_type, key); - fp_gdk_threads_leave(); + gdk_threads_leave(); return ret; } @@ -102,8 +102,8 @@ JNIEnv *env, jclass klass, jint widget_type) { jstring ret; - fp_gdk_threads_enter(); + gdk_threads_enter(); ret = gtk2_get_pango_font_name(env, widget_type); - fp_gdk_threads_leave(); + gdk_threads_leave(); return ret; }