X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3fa056ab78be920eacac56e51864fe7a45d1a31a..9348da2fc0395dfe8704cb7e618f7b129f054865:/src/gtk/wx_gtk_vmsjackets.c?ds=sidebyside diff --git a/src/gtk/wx_gtk_vmsjackets.c b/src/gtk/wx_gtk_vmsjackets.c index e19cafb723..20b1ec70cd 100644 --- a/src/gtk/wx_gtk_vmsjackets.c +++ b/src/gtk/wx_gtk_vmsjackets.c @@ -1,4 +1,12 @@ +/* Jackets for VMS only */ + +#include + +#include #include +#include +#include +#include void GDK_BEEP (void) { @@ -38,3 +46,2533 @@ GdkVisual* GDK_COLORMAP_GET_VISUAL (GdkColormap *colormap) return gdk_colormap_get_visual (colormap); } +GdkColormap* GDK_COLORMAP_NEW (GdkVisual *visual, + gboolean allocate) +{ + return gdk_colormap_new (visual, + allocate); +} + +void GDK_COLORMAP_UNREF (GdkColormap *cmap) +{ + gdk_colormap_unref (cmap); +} + +gboolean GDK_COLOR_ALLOC (GdkColormap *colormap, + GdkColor *color) +{ + return gdk_color_alloc (colormap, + color); +} + +gboolean GDK_COLOR_PARSE (const gchar *spec, + GdkColor *color) +{ + return gdk_color_parse (spec, + color); +} + +void GDK_CURSOR_DESTROY (GdkCursor *cursor) +{ + gdk_cursor_destroy (cursor); +} + +GdkCursor* GDK_CURSOR_NEW (GdkCursorType cursor_type) +{ + return gdk_cursor_new (cursor_type); +} + +void GDK_DRAW_ARC (GdkDrawable *drawable, + GdkGC *gc, + gint filled, + gint x, + gint y, + gint width, + gint height, + gint angle1, + gint angle2) +{ + gdk_draw_arc (drawable, + gc, + filled, + x, + y, + width, + height, + angle1, + angle2); +} + +void GDK_DRAW_IMAGE (GdkDrawable *drawable, + GdkGC *gc, + GdkImage *image, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height) +{ + gdk_draw_image (drawable, + gc, + image, + xsrc, + ysrc, + xdest, + ydest, + width, + height); +} + +void GDK_DRAW_LINE (GdkDrawable *drawable, + GdkGC *gc, + gint x1, + gint y1, + gint x2, + gint y2) +{ + gdk_draw_line (drawable, + gc, + x1, + y1, + x2, + y2); +} + +void GDK_DRAW_PIXMAP (GdkDrawable *drawable, + GdkGC *gc, + GdkDrawable *src, + gint xsrc, + gint ysrc, + gint xdest, + gint ydest, + gint width, + gint height) +{ + gdk_draw_pixmap (drawable, + gc, + src, + xsrc, + ysrc, + xdest, + ydest, + width, + height); +} + +void GDK_DRAW_POINT (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y) +{ + gdk_draw_point (drawable, + gc, + x, + y); +} + +void GDK_DRAW_POLYGON (GdkDrawable *drawable, + GdkGC *gc, + gint filled, + GdkPoint *points, + gint npoints) +{ + gdk_draw_polygon (drawable, + gc, + filled, + points, + npoints); +} + +void GDK_DRAW_RECTANGLE (GdkDrawable *drawable, + GdkGC *gc, + gint filled, + gint x, + gint y, + gint width, + gint height) +{ + gdk_draw_rectangle (drawable, + gc, + filled, + x, + y, + width, + height); +} + +void GDK_DRAW_STRING (GdkDrawable *drawable, + GdkFont *font, + GdkGC *gc, + gint x, + gint y, + const gchar *string) +{ + gdk_draw_string (drawable, + font, + gc, + x, + y, + string); +} + +void GDK_FLUSH (void) +{ + gdk_flush (); +} + +GdkFont* GDK_FONT_LOAD (const gchar *font_name) +{ + return gdk_font_load (font_name); +} + +GdkFont* GDK_FONT_REF (GdkFont *font) +{ + return gdk_font_ref (font); +} + +void GDK_FONT_UNREF (GdkFont *font) +{ + gdk_font_unref (font); +} + +void GDK_GC_DESTROY (GdkGC *gc) +{ + gdk_gc_destroy (gc); +} + +GdkGC* GDK_GC_NEW (GdkWindow *window) +{ + return gdk_gc_new (window); +} + +void GDK_GC_SET_BACKGROUND (GdkGC *gc, + GdkColor *color) +{ + gdk_gc_set_background (gc, + color); +} + +void GDK_GC_SET_CLIP_MASK (GdkGC *gc, + GdkBitmap *mask) +{ + gdk_gc_set_clip_mask (gc, + mask); +} + +void GDK_GC_SET_CLIP_ORIGIN (GdkGC *gc, + gint x, + gint y) +{ + gdk_gc_set_clip_origin (gc, + x, + y); +} + +void GDK_GC_SET_CLIP_RECTANGLE (GdkGC *gc, + GdkRectangle *rectangle) +{ + gdk_gc_set_clip_rectangle (gc, + rectangle); +} + +void GDK_GC_SET_CLIP_REGION (GdkGC *gc, + GdkRegion *region) +{ + gdk_gc_set_clip_region (gc, + region); +} + +void GDK_GC_SET_DASHES (GdkGC *gc, + gint dash_offset, + gint8 dash_list[], + gint n) +{ + gdk_gc_set_dashes (gc, + dash_offset, + dash_list, + n); +} + +void GDK_GC_SET_EXPOSURES (GdkGC *gc, + gboolean exposures) +{ + gdk_gc_set_exposures (gc, + exposures); +} + +void GDK_GC_SET_FILL (GdkGC *gc, + GdkFill fill) +{ + gdk_gc_set_fill (gc, + fill); +} + +void GDK_GC_SET_FOREGROUND (GdkGC *gc, + GdkColor *color) +{ + gdk_gc_set_foreground (gc, + color); +} + +void GDK_GC_SET_FUNCTION (GdkGC *gc, + GdkFunction function) +{ + gdk_gc_set_function (gc, + function); +} + +void GDK_GC_SET_LINE_ATTRIBUTES (GdkGC *gc, + gint line_width, + GdkLineStyle line_style, + GdkCapStyle cap_style, + GdkJoinStyle join_style) +{ + gdk_gc_set_line_attributes (gc, + line_width, + line_style, + cap_style, + join_style); +} + +void GDK_GC_SET_STIPPLE (GdkGC *gc, + GdkPixmap *stipple) +{ + gdk_gc_set_stipple (gc, + stipple); +} + +void GDK_GC_SET_SUBWINDOW (GdkGC *gc, + GdkSubwindowMode mode) +{ + gdk_gc_set_subwindow (gc, + mode); +} + +void GDK_GC_SET_TILE (GdkGC *gc, + GdkPixmap *tile) +{ + gdk_gc_set_tile (gc, + tile); +} + +void GDK_GC_SET_TS_ORIGIN (GdkGC *gc, + gint x, + gint y) +{ + gdk_gc_set_ts_origin (gc, + x, + y); +} + +void GDK_GC_UNREF (GdkGC *gc) +{ + gdk_gc_unref (gc); +} + +void GDK_IMAGE_DESTROY (GdkImage *image) +{ + gdk_image_destroy (image); +} + +GdkImage* GDK_IMAGE_GET (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + return gdk_image_get (window, + x, + y, + width, + height); +} + +guint32 GDK_IMAGE_GET_PIXEL (GdkImage *image, + gint x, + gint y) +{ + return gdk_image_get_pixel (image, + x, + y); +} + +GdkImage* GDK_IMAGE_NEW (GdkImageType type, + GdkVisual *visual, + gint width, + gint height) +{ + return gdk_image_new (type, + visual, + width, + height); +} + +GdkImage* GDK_IMAGE_NEW_BITMAP(GdkVisual *visual, + gpointer data, + gint width, + gint height) +{ + return gdk_image_new_bitmap(visual, + data, + width, + height); +} + +void GDK_IMAGE_PUT_PIXEL (GdkImage *image, + gint x, + gint y, + guint32 pixel) +{ + gdk_image_put_pixel (image, + x, + y, + pixel); + +} + +gint GDK_INPUT_ADD_FULL (gint source, + GdkInputCondition condition, + GdkInputFunction function, + gpointer data, + GdkDestroyNotify destroy) +{ + return gdk_input_add_full (source, + condition, + function, + data, + destroy); +} + +void GDK_INPUT_REMOVE (gint tag) +{ + gdk_input_remove (tag); +} + +guint GDK_KEYVAL_TO_UPPER (guint keyval) +{ + return gdk_keyval_to_upper (keyval); +} + +GdkPixmap* GDK_PIXMAP_CREATE_FROM_XPM (GdkWindow *window, + GdkBitmap **mask, + GdkColor *transparent_color, + const gchar *filename) +{ + return gdk_pixmap_create_from_xpm (window, + mask, + transparent_color, + filename); +} + +GdkPixmap* GDK_PIXMAP_CREATE_FROM_XPM_D (GdkWindow *window, + GdkBitmap **mask, + GdkColor *transparent_color, + gchar **data) +{ + return gdk_pixmap_create_from_xpm_d (window, + mask, + transparent_color, + data); +} + +GdkPixmap* GDK_PIXMAP_NEW (GdkWindow *window, + gint width, + gint height, + gint depth) +{ + return gdk_pixmap_new (window, + width, + height, + depth); +} + +void GDK_PIXMAP_UNREF (GdkPixmap *pixmap) +{ + gdk_pixmap_unref (pixmap); +} + +gint GDK_POINTER_GRAB (GdkWindow *window, + gint owner_events, + GdkEventMask event_mask, + GdkWindow *confine_to, + GdkCursor *cursor, + guint32 time) +{ + return gdk_pointer_grab (window, + owner_events, + event_mask, + confine_to, + cursor, + time); +} + +void GDK_POINTER_UNGRAB (guint32 time) +{ + gdk_pointer_ungrab (time); +} + +GdkRegion* GDK_REGIONS_INTERSECT (GdkRegion *source1, + GdkRegion *source2) +{ + return gdk_regions_intersect (source1, + source2); + +} + +GdkRegion* GDK_REGIONS_SUBTRACT (GdkRegion *source1, + GdkRegion *source2) +{ + return gdk_regions_subtract (source1, + source2); +} + +GdkRegion* GDK_REGIONS_UNION (GdkRegion *source1, + GdkRegion *source2) +{ + return gdk_regions_union (source1, + source2); +} + +GdkRegion* GDK_REGIONS_XOR (GdkRegion *source1, + GdkRegion *source2) +{ + return gdk_regions_xor (source1, + source2); +} + +void GDK_REGION_DESTROY (GdkRegion *region) +{ + gdk_region_destroy (region); +} + +gboolean GDK_REGION_EMPTY (GdkRegion *region) +{ + return gdk_region_empty (region); +} + +void GDK_REGION_GET_CLIPBOX(GdkRegion *region, + GdkRectangle *rectangle) +{ + gdk_region_get_clipbox(region, + rectangle); +} + +GdkRegion* GDK_REGION_NEW (void) +{ + return gdk_region_new (); +} + +gboolean GDK_REGION_POINT_IN (GdkRegion *region, + int x, + int y) +{ + return gdk_region_point_in (region, + x, + y); +} + +GdkOverlapType GDK_REGION_RECT_IN (GdkRegion *region, + GdkRectangle *rect) +{ + return gdk_region_rect_in (region, + rect); +} + +GdkRegion* GDK_REGION_UNION_WITH_RECT (GdkRegion *region, + GdkRectangle *rect) +{ + return gdk_region_union_with_rect (region, + rect); +} + +gint GDK_SCREEN_HEIGHT (void) +{ + return gdk_screen_height (); +} + +gint GDK_SCREEN_WIDTH (void) +{ + return gdk_screen_width (); +} + +gint GDK_STRING_WIDTH (GdkFont *font, + const gchar *string) +{ + return gdk_string_width (font, + string); +} + +void gdk_threads_enter1 (void) +{ + gdk_threads_enter (); +} + +void gdk_threads_leave1 (void) +{ + gdk_threads_leave (); +} + +GdkVisual* GDK_VISUAL_GET_BEST (void) +{ + return gdk_visual_get_best (); +} + +GdkVisual* GDK_VISUAL_GET_SYSTEM (void) +{ + return gdk_visual_get_system (); +} + +void GDK_WINDOW_ADD_FILTER (GdkWindow *window, + GdkFilterFunc function, + gpointer data) +{ + gdk_window_add_filter (window, + function, + data); +} + +void GDK_WINDOW_CLEAR (GdkWindow *window) +{ + gdk_window_clear (window); +} + +void GDK_WINDOW_CLEAR_AREA (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + gdk_window_clear_area (window, + x, + y, + width, + height); +} + +void GDK_WINDOW_COPY_AREA (GdkWindow *window, + GdkGC *gc, + gint x, + gint y, + GdkWindow *source_window, + gint source_x, + gint source_y, + gint width, + gint height) +{ + gdk_window_copy_area (window, + gc, + x, + y, + source_window, + source_x, + source_y, + width, + height); +} + +void GDK_WINDOW_DESTROY (GdkWindow *window) +{ + gdk_window_destroy (window); +} + +GdkColormap* GDK_WINDOW_GET_COLORMAP (GdkWindow *window) +{ + return gdk_window_get_colormap (window); +} + +gint GDK_WINDOW_GET_ORIGIN (GdkWindow *window, + gint *x, + gint *y) +{ + return gdk_window_get_origin (window, + x, + y); +} + +GdkWindow* GDK_WINDOW_GET_POINTER (GdkWindow *window, + gint *x, + gint *y, + GdkModifierType *mask) +{ + return gdk_window_get_pointer (window, + x, + y, + mask); +} + +void GDK_WINDOW_GET_ROOT_ORIGIN (GdkWindow *window, + gint *x, + gint *y) +{ + gdk_window_get_root_origin (window, + x, + y); +} + +void GDK_WINDOW_GET_SIZE (GdkWindow *window, + gint *width, + gint *height) +{ + gdk_window_get_size (window, + width, + height); +} + +void GDK_WINDOW_GET_USER_DATA (GdkWindow *window, + gpointer *data) +{ + gdk_window_get_user_data (window, + data); +} + +GdkVisual* GDK_WINDOW_GET_VISUAL (GdkWindow *window) +{ + return gdk_window_get_visual (window); +} + +void GDK_WINDOW_LOWER (GdkWindow *window) +{ + gdk_window_lower (window); +} + +void GDK_WINDOW_MOVE (GdkWindow *window, + gint x, + gint y) +{ + gdk_window_move (window, + x, + y); +} + +void GDK_WINDOW_MOVE_RESIZE (GdkWindow *window, + gint x, + gint y, + gint width, + gint height) +{ + gdk_window_move_resize (window, + x, + y, + width, + height); +} + +GdkWindow* GDK_WINDOW_NEW (GdkWindow *parent, + GdkWindowAttr *attributes, + gint attributes_mask) +{ + return gdk_window_new (parent, + attributes, + attributes_mask); +} + +void GDK_WINDOW_RAISE (GdkWindow *window) +{ + gdk_window_raise (window); +} + +GdkWindow* GDK_WINDOW_REF (GdkWindow *window) +{ + return gdk_window_ref (window); +} + +void GDK_WINDOW_RESIZE (GdkWindow *window, + gint width, + gint height) +{ + gdk_window_resize (window, + width, + height); +} + +void GDK_WINDOW_SET_BACKGROUND (GdkWindow *window, + GdkColor *color) +{ + gdk_window_set_background (window, + color); +} + +void GDK_WINDOW_SET_CURSOR (GdkWindow *window, + GdkCursor *cursor) +{ + gdk_window_set_cursor (window, + cursor); +} + +void GDK_WINDOW_SET_DECORATIONS (GdkWindow *window, + GdkWMDecoration decorations) +{ + gdk_window_set_decorations (window, + decorations); +} + +void GDK_WINDOW_SET_FUNCTIONS (GdkWindow *window, + GdkWMFunction functions) +{ + gdk_window_set_functions (window, + functions); +} + +void GDK_WINDOW_SET_HINTS (GdkWindow *window, + gint x, + gint y, + gint min_width, + gint min_height, + gint max_width, + gint max_height, + gint flags) +{ + gdk_window_set_hints (window, + x, + y, + min_width, + min_height, + max_width, + max_height, + flags); +} + +void GDK_WINDOW_SET_ICON (GdkWindow *window, + GdkWindow *icon_window, + GdkPixmap *pixmap, + GdkBitmap *mask) +{ + gdk_window_set_icon (window, + icon_window, + pixmap, + mask); +} + +gboolean GDK_WINDOW_SET_STATIC_GRAVITIES (GdkWindow *window, + gboolean use_static) +{ + return gdk_window_set_static_gravities (window, + use_static); +} + +void GDK_WINDOW_SET_USER_DATA (GdkWindow *window, + gpointer user_data) +{ + gdk_window_set_user_data (window, + user_data); +} + +void GDK_WINDOW_SHOW (GdkWindow *window) +{ + gdk_window_show (window); +} + +void GDK_WINDOW_UNREF (GdkWindow *window) +{ + gdk_window_unref (window); +} + +void +GDK_DRAW_RGB_IMAGE (GdkDrawable *drawable, + GdkGC *gc, + gint x, + gint y, + gint width, + gint height, + GdkRgbDither dith, + guchar *rgb_buf, + gint rowstride) +{ +gdk_draw_rgb_image (drawable, + gc, + x, + y, + width, + height, + dith, + rgb_buf, + rowstride); +} + +void +GDK_RGB_INIT (void) +{ +gdk_rgb_init (); +} + +gpointer GDK_XID_TABLE_LOOKUP (XID xid) +{ + return gdk_xid_table_lookup (xid); +} + + +Display* GDK_DISPLAY0( void ) +{ + return gdk_display; +} + +gint GDK_INPUT_ADD (gint source, + GdkInputCondition condition, + GdkInputFunction function, + gpointer data) +{ + return gdk_input_add (source, + condition, + function, + data); +} + +GdkWindow* GDK_ROOT_PARENT0( void ) +{ + return ((GdkWindow *)&gdk_root_parent); +} + +void GTK_ACCEL_GROUP_ATTACH (GtkAccelGroup *accel_group, + GtkObject *object) +{ + gtk_accel_group_attach (accel_group, + object); +} + +void GTK_ACCEL_GROUP_DETACH (GtkAccelGroup *accel_group, + GtkObject *object) +{ + gtk_accel_group_detach (accel_group, + object); +} + +GtkAccelGroup* GTK_ACCEL_GROUP_NEW (void) +{ + return gtk_accel_group_new (); +} + +GtkType GTK_ACCEL_LABEL_GET_TYPE (void) +{ + return gtk_accel_label_get_type (); +} + +gboolean GTK_ACCEL_LABEL_REFETCH (GtkAccelLabel *accel_label) +{ + return gtk_accel_label_refetch (accel_label); +} + +GtkType GTK_ADJUSTMENT_GET_TYPE (void) +{ + return gtk_adjustment_get_type (); +} + +GtkType GTK_BIN_GET_TYPE (void) +{ + return gtk_bin_get_type (); +} + +GtkType GTK_BOX_GET_TYPE (void) +{ + return gtk_box_get_type (); +} + +void GTK_BOX_PACK_START (GtkBox *box, + GtkWidget *child, + gboolean expand, + gboolean fill, + guint padding) +{ + gtk_box_pack_start (box, + child, + expand, + fill, + padding); +} + +GtkType GTK_BUTTON_GET_TYPE (void) +{ + return gtk_button_get_type (); +} + +GtkWidget* GTK_BUTTON_NEW (void) +{ + return gtk_button_new (); +} + +GtkWidget* GTK_BUTTON_NEW_WITH_LABEL (const gchar *label) +{ + return gtk_button_new_with_label (label); +} + +void GTK_BUTTON_SET_RELIEF (GtkButton *button, + GtkReliefStyle newstyle) +{ + gtk_button_set_relief (button, + newstyle); +} + +GtkWidget* GTK_CHECK_BUTTON_NEW (void) +{ + return gtk_check_button_new (); +} + +GtkWidget* GTK_CHECK_BUTTON_NEW_WITH_LABEL (const gchar *label) +{ + return gtk_check_button_new_with_label (label); +} + +void GTK_CHECK_MENU_ITEM_SET_ACTIVE (GtkCheckMenuItem *check_menu_item, + gboolean is_active) +{ + gtk_check_menu_item_set_active (check_menu_item, + is_active); +} + +guint GTK_COMBO_GET_TYPE (void) +{ + return gtk_combo_get_type (); +} + +GtkWidget *GTK_COMBO_NEW (void) +{ + return gtk_combo_new (); +} + +void GTK_COMBO_SET_USE_ARROWS_ALWAYS (GtkCombo* combo, + gint val) +{ + gtk_combo_set_use_arrows_always (combo, + val); +} + +void GTK_CONTAINER_ADD (GtkContainer *container, + GtkWidget *widget) +{ + gtk_container_add (container, + widget); +} + +gint GTK_CONTAINER_FOCUS (GtkContainer *container, + GtkDirectionType direction) +{ + return gtk_container_focus (container, + direction); +} + +void GTK_CONTAINER_FORALL (GtkContainer *container, + GtkCallback callback, + gpointer callback_data) +{ + gtk_container_forall (container, + callback, + callback_data); +} + +GtkType GTK_CONTAINER_GET_TYPE (void) +{ + return gtk_container_get_type (); +} + +void GTK_CONTAINER_REMOVE (GtkContainer *container, + GtkWidget *widget) +{ + gtk_container_remove (container, + widget); +} + +void GTK_CONTAINER_SET_FOCUS_VADJUST (GtkContainer *container, + GtkAdjustment *adjustment) +{ + gtk_container_set_focus_vadjustment (container, + adjustment); +} + +void GTK_DRAW_SHADOW (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type, + GtkShadowType shadow_type, + gint x, + gint y, + gint width, + gint height) +{ + gtk_draw_shadow (style, + window, + state_type, + shadow_type, + x, + y, + width, + height); +} + +void GTK_EDITABLE_COPY_CLIPBOARD (GtkEditable *editable) +{ + gtk_editable_copy_clipboard (editable); +} + +void GTK_EDITABLE_CUT_CLIPBOARD (GtkEditable *editable) +{ + gtk_editable_cut_clipboard (editable); +} + +void GTK_EDITABLE_DELETE_TEXT (GtkEditable *editable, + gint start_pos, + gint end_pos) +{ + gtk_editable_delete_text (editable, + start_pos, + end_pos); +} + +gchar* GTK_EDITABLE_GET_CHARS (GtkEditable *editable, + gint start_pos, + gint end_pos) +{ + return gtk_editable_get_chars (editable, + start_pos, + end_pos); +} + +GtkType GTK_EDITABLE_GET_TYPE (void) +{ + return gtk_editable_get_type (); +} + +void GTK_EDITABLE_INSERT_TEXT (GtkEditable *editable, + const gchar *new_text, + gint new_text_length, + gint *position) +{ + gtk_editable_insert_text (editable, + new_text, + new_text_length, + position); +} + +void GTK_EDITABLE_PASTE_CLIPBOARD (GtkEditable *editable) +{ + gtk_editable_paste_clipboard (editable); +} + +void GTK_EDITABLE_SELECT_REGION (GtkEditable *editable, + gint start, + gint end) +{ + gtk_editable_select_region (editable, + start, + end); +} + +void GTK_ENTRY_APPEND_TEXT (GtkEntry *entry, + const gchar *text) +{ + gtk_entry_append_text (entry, + text); +} + +gchar* GTK_ENTRY_GET_TEXT (GtkEntry *entry) +{ + return gtk_entry_get_text (entry); +} + +GtkType GTK_ENTRY_GET_TYPE (void) +{ + return gtk_entry_get_type (); +} + +GtkWidget* GTK_ENTRY_NEW (void) +{ + return gtk_entry_new (); +} + +void GTK_ENTRY_SET_EDITABLE (GtkEntry *entry, + gboolean editable) +{ + gtk_entry_set_editable (entry, + editable); +} + +void GTK_ENTRY_SET_POSITION (GtkEntry *entry, + gint position) +{ + gtk_entry_set_position (entry, + position); +} + +void GTK_ENTRY_SET_TEXT (GtkEntry *entry, + const gchar *text) +{ + gtk_entry_set_text (entry, + text); +} + +void GTK_ENTRY_SET_VISIBILITY (GtkEntry *entry, + gboolean visible) +{ + gtk_entry_set_visibility (entry, + visible); +} + +gint GTK_EVENTS_PENDING (void) +{ + return gtk_events_pending (); +} + +gchar* GTK_FILE_SELECTION_GET_FILENAME (GtkFileSelection *filesel) +{ + return gtk_file_selection_get_filename (filesel); +} + +GtkType GTK_FILE_SELECTION_GET_TYPE (void) +{ + return gtk_file_selection_get_type (); +} + +void GTK_FILE_SELECTION_HIDE_FILEOP_ (GtkFileSelection *filesel) +{ + gtk_file_selection_hide_fileop_buttons (filesel); +} + +GtkWidget* GTK_FILE_SELECTION_NEW (const gchar *title) +{ + return gtk_file_selection_new (title); +} + +void GTK_FILE_SELECTION_SET_FILENAME (GtkFileSelection *filesel, + const gchar *filename) +{ + gtk_file_selection_set_filename (filesel, + filename); +} + +gchar* GTK_FONT_SELECTION_DIALOG_GETNF (GtkFontSelectionDialog *fsd) +{ + return gtk_font_selection_dialog_get_font_name (fsd); +} + +GdkFont* GTK_FONT_SELECTION_DIALOG_GET_F (GtkFontSelectionDialog *fsd) +{ + return gtk_font_selection_dialog_get_font (fsd); +} + +GtkType GTK_FONT_SELECTION_DIALOG_GET_T (void) +{ + return gtk_font_selection_dialog_get_type (); +} + +GtkWidget* GTK_FONT_SELECTION_DIALOG_NEW (const gchar *title) +{ + return gtk_font_selection_dialog_new (title); +} + +GtkType GTK_FRAME_GET_TYPE (void) +{ + return gtk_frame_get_type (); +} + +GtkWidget* GTK_FRAME_NEW (const gchar *label) +{ + return gtk_frame_new (label); +} + +void GTK_FRAME_SET_LABEL (GtkFrame *frame, + const gchar *label) +{ + gtk_frame_set_label (frame, + label); +} + +void GTK_GRAB_ADD (GtkWidget *widget) +{ + gtk_grab_add (widget); +} + +void GTK_GRAB_REMOVE (GtkWidget *widget) +{ + gtk_grab_remove (widget); +} + +GtkType GTK_HANDLE_BOX_GET_TYPE (void) +{ + return gtk_handle_box_get_type (); +} + +GtkWidget* GTK_HANDLE_BOX_NEW (void) +{ + return gtk_handle_box_new (); +} + +void GTK_HANDLE_BOX_SET_SHADOW_TYPE (GtkHandleBox *handle_box, + GtkShadowType type) +{ + gtk_handle_box_set_shadow_type (handle_box, + type); +} + +GtkWidget* GTK_HBOX_NEW (gboolean homogeneous, + gint spacing) +{ + return gtk_hbox_new (homogeneous, + spacing); +} + +GtkWidget* GTK_HSCALE_NEW (GtkAdjustment *adjustment) +{ + return gtk_hscale_new (adjustment); +} + +GtkWidget* GTK_HSCROLLBAR_NEW (GtkAdjustment *adjustment) +{ + return gtk_hscrollbar_new (adjustment); +} + +GtkWidget* GTK_HSEPARATOR_NEW (void) +{ + return gtk_hseparator_new (); +} + +guint GTK_IDLE_ADD (GtkFunction function, + gpointer data) +{ + return gtk_idle_add (function, + data); +} + +void GTK_IDLE_REMOVE (guint idle_handler_id) +{ + gtk_idle_remove (idle_handler_id); +} + +void GTK_INIT (int *argc, + char ***argv) +{ + gtk_init (argc, + argv); +} + +void GTK_ITEM_FACTORY_CREATE_ITEM (GtkItemFactory *ifactory, + GtkItemFactoryEntry *entry, + gpointer callback_data, + guint callback_type) +{ + gtk_item_factory_create_item (ifactory, + entry, + callback_data, + callback_type); +} + +GtkWidget* GTK_ITEM_FACTORY_GET_ITEM (GtkItemFactory *ifactory, + const gchar *path) +{ + return gtk_item_factory_get_item (ifactory, + path); +} + +GtkWidget* GTK_ITEM_FACTORY_GET_WIDGET (GtkItemFactory *ifactory, + const gchar *path) +{ + return gtk_item_factory_get_widget (ifactory, + path); +} + +GtkItemFactory* GTK_ITEM_FACTORY_NEW (GtkType container_type, + const gchar *path, + GtkAccelGroup *accel_group) +{ + return gtk_item_factory_new (container_type, + path, + accel_group); +} + +void GTK_LABEL_GET (GtkLabel *label, + gchar **str) +{ + gtk_label_get (label, + str); +} + +GtkType GTK_LABEL_GET_TYPE (void) +{ + return gtk_label_get_type (); +} + +GtkWidget* GTK_LABEL_NEW (const gchar *str) +{ + return gtk_label_new (str); +} + +guint GTK_LABEL_PARSE_ULINE (GtkLabel *label, + const gchar *string) +{ + return gtk_label_parse_uline (label, + string); +} + +void GTK_LABEL_SET_JUSTIFY (GtkLabel *label, + GtkJustification jtype) +{ + gtk_label_set_justify (label, + jtype); +} + +void GTK_LABEL_SET_LINE_WRAP (GtkLabel *label, + gboolean wrap) +{ + gtk_label_set_line_wrap (label, + wrap); +} + +void GTK_LABEL_SET_TEXT (GtkLabel *label, + const gchar *str) +{ + gtk_label_set_text (label, + str); +} + +void GTK_LIST_APPEND_ITEMS (GtkList *list, + GList *items) +{ + gtk_list_append_items (list, + items); +} + +void GTK_LIST_CLEAR_ITEMS (GtkList *list, + gint start, + gint end) +{ + gtk_list_clear_items (list, + start, + end); +} + +GtkType GTK_LIST_GET_TYPE (void) +{ + return gtk_list_get_type (); +} + +void GTK_LIST_INSERT_ITEMS (GtkList *list, + GList *items, + gint position) +{ + gtk_list_insert_items (list, + items, + position); +} + +GtkWidget* GTK_LIST_ITEM_NEW_WITH_LABEL (const gchar *label) +{ + return gtk_list_item_new_with_label (label); +} + +GtkWidget* GTK_LIST_NEW (void) +{ + return gtk_list_new (); +} + +void GTK_LIST_REMOVE_ITEMS (GtkList *list, + GList *items) +{ + gtk_list_remove_items (list, + items); +} + +void GTK_LIST_SELECT_ITEM (GtkList *list, + gint item) +{ + gtk_list_select_item (list, + item); +} + +void GTK_LIST_SET_SELECTION_MODE (GtkList *list, + GtkSelectionMode mode) +{ + gtk_list_set_selection_mode (list, + mode); +} + +void GTK_LIST_UNSELECT_ITEM (GtkList *list, + gint item) +{ + gtk_list_unselect_item (list, + item); +} + +void GTK_MAIN (void) +{ + gtk_main (); +} + +gint GTK_MAIN_ITERATION (void) +{ + return gtk_main_iteration (); +} + +guint GTK_MAIN_LEVEL (void) +{ + return gtk_main_level (); +} + +void GTK_MAIN_QUIT (void) +{ + gtk_main_quit (); +} + +GdkEventMask GDK_WINDOW_GET_EVENTS (GdkWindow *window) +{ + return gdk_window_get_events (window); +} + +void GDK_WINDOW_SET_EVENTS (GdkWindow *window, + GdkEventMask event_mask) +{ + gdk_window_set_events (window, + event_mask); +} + +guint GTK_IDLE_ADD_PRIORITY (gint priority, + GtkFunction function, + gpointer data) +{ + return gtk_idle_add_priority (priority, + function, + data); +} + +guint VMS_GTK_MAJOR_VERSION( void ) +{ + return gtk_major_version; +} + +guint VMS_GTK_MINOR_VERSION( void ) +{ + return gtk_minor_version; +} + +guint VMS_GTK_MICRO_VERSION( void ) +{ + return gtk_micro_version; +} + +GtkWidget* +gtk_item_factory_get_item (GtkItemFactory *ifactory, + const gchar *path) +{ + GtkWidget *widget; + + g_return_val_if_fail (GTK_IS_ITEM_FACTORY (ifactory), NULL); + g_return_val_if_fail (path != NULL, NULL); + + widget = gtk_item_factory_get_widget (ifactory, path); + + if (GTK_IS_MENU (widget)) + widget = gtk_menu_get_attach_widget (GTK_MENU (widget)); + + return GTK_IS_ITEM (widget) ? widget : NULL; +} + +void GTK_MARSHAL_NONE__POINTER_POINT (GtkObject * object, + GtkSignalFunc func, + gpointer func_data, GtkArg * args) +{ + gtk_marshal_NONE__POINTER_POINTER (object, + func, + func_data, args); +} + +void GTK_MENU_APPEND (GtkMenu *menu, + GtkWidget *child) +{ + gtk_menu_append (menu, + child); +} + +GtkType GTK_MENU_BAR_GET_TYPE (void) +{ + return gtk_menu_bar_get_type (); +} + +GtkType GTK_MENU_GET_TYPE (void) +{ + return gtk_menu_get_type (); +} + +void GTK_MENU_INSERT (GtkMenu *menu, + GtkWidget *child, + gint position) +{ + gtk_menu_insert (menu, + child, + position); +} + +GtkType GTK_MENU_ITEM_GET_TYPE (void) +{ + return gtk_menu_item_get_type (); +} + +GtkWidget* GTK_MENU_ITEM_NEW_WITH_LABEL (const gchar *label) +{ + return gtk_menu_item_new_with_label (label); +} + +void GTK_MENU_ITEM_SET_SUBMENU (GtkMenuItem *menu_item, + GtkWidget *submenu) +{ + gtk_menu_item_set_submenu (menu_item, + submenu); +} + +GtkWidget* GTK_MENU_NEW (void) +{ + return gtk_menu_new (); +} + +void GTK_MENU_POPUP (GtkMenu *menu, + GtkWidget *parent_menu_shell, + GtkWidget *parent_menu_item, + GtkMenuPositionFunc func, + gpointer data, + guint button, + guint32 activate_time) +{ + gtk_menu_popup (menu, + parent_menu_shell, + parent_menu_item, + func, + data, + button, + activate_time); +} + +GtkType GTK_MENU_SHELL_GET_TYPE (void) +{ + return gtk_menu_shell_get_type (); +} + +GtkType GTK_MISC_GET_TYPE (void) +{ + return gtk_misc_get_type (); +} + +void GTK_MISC_SET_ALIGNMENT (GtkMisc *misc, + gfloat xalign, + gfloat yalign) +{ + gtk_misc_set_alignment (misc, + xalign, + yalign); +} + +void GTK_OBJECT_UNREF (GtkObject *object) +{ + gtk_object_unref (object); +} + +GtkWidget* GTK_OPTION_MENU_GET_MENU (GtkOptionMenu *option_menu) +{ + return gtk_option_menu_get_menu (option_menu); +} + +GtkType GTK_OPTION_MENU_GET_TYPE (void) +{ + return gtk_option_menu_get_type (); +} + +GtkWidget* GTK_OPTION_MENU_NEW (void) +{ + return gtk_option_menu_new (); +} + +void GTK_OPTION_MENU_REMOVE_MENU (GtkOptionMenu *option_menu) +{ + gtk_option_menu_remove_menu (option_menu); +} + +void GTK_OPTION_MENU_SET_HISTORY (GtkOptionMenu *option_menu, + guint index) +{ + gtk_option_menu_set_history (option_menu, + index); +} + +void GTK_OPTION_MENU_SET_MENU (GtkOptionMenu *option_menu, + GtkWidget *menu) +{ + gtk_option_menu_set_menu (option_menu, + menu); +} + +GtkType GTK_PIXMAP_GET_TYPE (void) +{ + return gtk_pixmap_get_type (); +} + +GtkWidget* GTK_PIXMAP_NEW (GdkPixmap *pixmap, + GdkBitmap *mask) +{ + return gtk_pixmap_new (pixmap, + mask); +} + +void GTK_PIXMAP_SET (GtkPixmap *pixmap, + GdkPixmap *val, + GdkBitmap *mask) +{ + gtk_pixmap_set (pixmap, + val, + mask); +} + +void GTK_PIXMAP_SET_BUILD_INSENSITIV (GtkPixmap *pixmap, + guint build) +{ + gtk_pixmap_set_build_insensitive (pixmap, + build); +} + +GtkType GTK_PROGRESS_BAR_GET_TYPE (void) +{ + return gtk_progress_bar_get_type (); +} + +GtkWidget* GTK_PROGRESS_BAR_NEW (void) +{ + return gtk_progress_bar_new (); +} + +void GTK_PROGRESS_BAR_UPDATE (GtkProgressBar *pbar, + gfloat percentage) +{ + gtk_progress_bar_update (pbar, + percentage); +} + +GtkType GTK_RADIO_BUTTON_GET_TYPE (void) +{ + return gtk_radio_button_get_type (); +} + +GSList* GTK_RADIO_BUTTON_GROUP (GtkRadioButton *radio_button) +{ + return gtk_radio_button_group (radio_button); +} + +GtkWidget* GTK_RADIO_BUTTON_NEW_WITH_LABEL (GSList *group, + const gchar *label) +{ + return gtk_radio_button_new_with_label (group, + label); +} + +GtkAdjustment* GTK_RANGE_GET_ADJUSTMENT (GtkRange *range) +{ + return gtk_range_get_adjustment (range); +} + +GtkType GTK_RANGE_GET_TYPE (void) +{ + return gtk_range_get_type (); +} + +GtkStyle* GTK_RC_GET_STYLE (GtkWidget *widget) +{ + return gtk_rc_get_style (widget); +} + +GtkType GTK_SCALE_GET_TYPE (void) +{ + return gtk_scale_get_type (); +} + +void GTK_SCALE_SET_DIGITS (GtkScale *scale, + gint digits) +{ + gtk_scale_set_digits (scale, + digits); +} + +void GTK_SCALE_SET_DRAW_VALUE (GtkScale *scale, + gboolean draw_value) +{ + gtk_scale_set_draw_value (scale, + draw_value); +} + +void GTK_SCROLLED_WINDOW_ADD_WITH_VI (GtkScrolledWindow *scrolled_window, + GtkWidget *child) +{ + gtk_scrolled_window_add_with_viewport (scrolled_window, + child); +} + +GtkType GTK_SCROLLED_WINDOW_GET_TYPE (void) +{ + return gtk_scrolled_window_get_type (); +} + +GtkAdjustment* GTK_SCROLLED_WINDOW_GET_VADJUST (GtkScrolledWindow *scrolled_window) +{ + return gtk_scrolled_window_get_vadjustment (scrolled_window); +} + +GtkWidget* GTK_SCROLLED_WINDOW_NEW (GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment) +{ + return gtk_scrolled_window_new (hadjustment, + vadjustment); +} + +void GTK_SCROLLED_WINDOW_SET_POLICY (GtkScrolledWindow *scrolled_window, + GtkPolicyType hscrollbar_policy, + GtkPolicyType vscrollbar_policy) +{ + gtk_scrolled_window_set_policy (scrolled_window, + hscrollbar_policy, + vscrollbar_policy); +} + +gchar* GTK_SET_LOCALE (void) +{ + return gtk_set_locale (); +} + +guint GTK_SIGNAL_CONNECT (GtkObject *object, + const gchar *name, + GtkSignalFunc func, + gpointer func_data) +{ + return gtk_signal_connect (object, + name, + func, + func_data); +} + +guint GTK_SIGNAL_CONNECT_AFTER (GtkObject *object, + const gchar *name, + GtkSignalFunc func, + gpointer func_data) +{ + return gtk_signal_connect_after (object, + name, + func, + func_data); +} + +void GTK_SIGNAL_DISCONNECT_BY_FUNC (GtkObject *object, + GtkSignalFunc func, + gpointer data) +{ + gtk_signal_disconnect_by_func (object, + func, + data); +} + +void GTK_SIGNAL_EMIT_BY_NAME (GtkObject *object, + const gchar *name + ) +{ + gtk_signal_emit_by_name (object, + name + ); + +} + +void GTK_SIGNAL_EMIT_STOP_BY_NAME (GtkObject *object, + const gchar *name) +{ + gtk_signal_emit_stop_by_name (object, + name); +} + +#define MAX_SIGNAL_PARAMS (31) + +guint GTK_SIGNAL_NEW (const gchar *name, + GtkSignalRunType signal_flags, + GtkType object_type, + guint function_offset, + GtkSignalMarshaller marshaller, + GtkType return_val, + guint nparams, + ...) +{ + GtkType *params; + guint i; + va_list args; + guint signal_id; + + g_return_val_if_fail (nparams < MAX_SIGNAL_PARAMS, 0); + + if (nparams > 0) + { + params = g_new (GtkType, nparams); + + va_start (args, nparams); + + for (i = 0; i < nparams; i++) + params[i] = va_arg (args, GtkType); + + va_end (args); + } + else + params = NULL; + + signal_id = gtk_signal_newv (name, + signal_flags, + object_type, + function_offset, + marshaller, + return_val, + nparams, + params); + + g_free (params); + + return signal_id; +} + +GtkStyle* GTK_STYLE_ATTACH (GtkStyle *style, + GdkWindow *window) +{ + return gtk_style_attach (style, + window); +} + +GtkStyle* GTK_STYLE_COPY (GtkStyle *style) +{ + return gtk_style_copy (style); +} + +void GTK_STYLE_SET_BACKGROUND (GtkStyle *style, + GdkWindow *window, + GtkStateType state_type) +{ + gtk_style_set_background (style, + window, + state_type); +} + +void GTK_STYLE_UNREF (GtkStyle *style) +{ + gtk_style_unref (style); +} + +void GTK_TABLE_ATTACH (GtkTable *table, + GtkWidget *child, + guint left_attach, + guint right_attach, + guint top_attach, + guint bottom_attach, + GtkAttachOptions xoptions, + GtkAttachOptions yoptions, + guint xpadding, + guint ypadding) +{ + gtk_table_attach (table, + child, + left_attach, + right_attach, + top_attach, + bottom_attach, + xoptions, + yoptions, + xpadding, + ypadding); +} + +GtkType GTK_TABLE_GET_TYPE (void) +{ + return gtk_table_get_type (); +} + +GtkWidget* GTK_TABLE_NEW (guint rows, + guint columns, + gboolean homogeneous) +{ + return gtk_table_new (rows, + columns, + homogeneous); +} + +guint GTK_TEXT_GET_LENGTH (GtkText *text) +{ + return gtk_text_get_length (text); +} + +guint GTK_TEXT_GET_POINT (GtkText *text) +{ + return gtk_text_get_point (text); +} + +GtkType GTK_TEXT_GET_TYPE (void) +{ + return gtk_text_get_type (); +} + +void GTK_TEXT_INSERT (GtkText *text, + GdkFont *font, + GdkColor *fore, + GdkColor *back, + const char *chars, + gint length) +{ + gtk_text_insert (text, + font, + fore, + back, + chars, + length); +} + +GtkWidget* GTK_TEXT_NEW (GtkAdjustment *hadj, + GtkAdjustment *vadj) +{ + return gtk_text_new (hadj, + vadj); +} + +void GTK_TEXT_SET_EDITABLE (GtkText *text, + gboolean editable) +{ + gtk_text_set_editable (text, + editable); +} + +void GTK_TEXT_SET_WORD_WRAP (GtkText *text, + gint word_wrap) +{ + gtk_text_set_word_wrap (text, + word_wrap); +} + +guint GTK_TIMEOUT_ADD (guint32 interval, + GtkFunction function, + gpointer data) +{ + return gtk_timeout_add (interval, + function, + data); +} + +void GTK_TIMEOUT_REMOVE (guint timeout_handler_id) +{ + gtk_timeout_remove (timeout_handler_id); +} + +GtkType GTK_TOGGLE_BUTTON_GET_TYPE (void) +{ + return gtk_toggle_button_get_type (); +} + +void GTK_TOGGLE_BUTTON_SET_ACTIVE (GtkToggleButton *toggle_button, + gboolean is_active) +{ + gtk_toggle_button_set_active (toggle_button, + is_active); +} + +void GTK_TOOLBAR_APPEND_SPACE (GtkToolbar *toolbar) +{ + gtk_toolbar_append_space (toolbar); +} + +GtkType GTK_TOOLBAR_GET_TYPE (void) +{ + return gtk_toolbar_get_type (); +} + +GtkWidget* GTK_TOOLBAR_INSERT_ELEMENT (GtkToolbar *toolbar, + GtkToolbarChildType type, + GtkWidget *widget, + const char *text, + const char *tooltip_text, + const char *tooltip_private_text, + GtkWidget *icon, + GtkSignalFunc callback, + gpointer user_data, + gint position) +{ + return gtk_toolbar_insert_element (toolbar, + type, + widget, + text, + tooltip_text, + tooltip_private_text, + icon, + callback, + user_data, + position); +} + +void GTK_TOOLBAR_INSERT_WIDGET (GtkToolbar *toolbar, + GtkWidget *widget, + const char *tooltip_text, + const char *tooltip_private_text, + gint position) +{ + gtk_toolbar_insert_widget (toolbar, + widget, + tooltip_text, + tooltip_private_text, + position); + + +} + +GtkWidget* GTK_TOOLBAR_NEW (GtkOrientation orientation, + GtkToolbarStyle style) +{ + return gtk_toolbar_new (orientation, + style); +} + +void GTK_TOOLBAR_SET_BUTTON_RELIEF (GtkToolbar *toolbar, + GtkReliefStyle relief) +{ + gtk_toolbar_set_button_relief (toolbar, + relief); +} + +void GTK_TOOLBAR_SET_SPACE_SIZE (GtkToolbar *toolbar, + gint space_size) +{ + gtk_toolbar_set_space_size (toolbar, + space_size); +} + +void GTK_TOOLBAR_SET_TOOLTIPS (GtkToolbar *toolbar, + gint enable) +{ + gtk_toolbar_set_tooltips (toolbar, + enable); +} + +void GTK_TOOLTIPS_FORCE_WINDOW (GtkTooltips *tooltips) +{ + gtk_tooltips_force_window (tooltips); +} + +GtkTypeClass* GTK_TYPE_CHECK_CLASS_CAST (GtkTypeClass *klass, + GtkType cast_type) +{ + return gtk_type_check_class_cast (klass, + cast_type); +} + +GtkTypeObject* GTK_TYPE_CHECK_OBJECT_CAST (GtkTypeObject *type_object, + GtkType cast_type) +{ + return gtk_type_check_object_cast (type_object, + cast_type); +} + +gpointer GTK_TYPE_CLASS (GtkType type) +{ + return gtk_type_class (type); +} + +gboolean GTK_TYPE_IS_A (GtkType type, + GtkType is_a_type) +{ + return gtk_type_is_a (type, + is_a_type); +} + +gpointer GTK_TYPE_NEW (GtkType type) +{ + return gtk_type_new (type); +} + +GtkType GTK_TYPE_UNIQUE (GtkType parent_type, + const GtkTypeInfo *type_info) +{ + return gtk_type_unique (parent_type, + type_info); +} + +GtkWidget* GTK_VSCALE_NEW (GtkAdjustment *adjustment) +{ + return gtk_vscale_new (adjustment); +} + +GtkWidget* GTK_VSCROLLBAR_NEW (GtkAdjustment *adjustment) +{ + return gtk_vscrollbar_new (adjustment); +} + +GtkWidget* GTK_VSEPARATOR_NEW (void) +{ + return gtk_vseparator_new (); +} + +gboolean GTK_WIDGET_ACTIVATE (GtkWidget *widget) +{ + return gtk_widget_activate (widget); +} + +void GTK_WIDGET_DESTROY (GtkWidget *widget) +{ + gtk_widget_destroy (widget); +} + +void GTK_WIDGET_DRAW (GtkWidget *widget, + GdkRectangle *area) +{ + gtk_widget_draw (widget, + area); +} + +gint GTK_WIDGET_EVENT (GtkWidget *widget, + GdkEvent *event) +{ + return gtk_widget_event (widget, + event); +} + +void GTK_WIDGET_GET_CHILD_REQUISITIO (GtkWidget *widget, + GtkRequisition *requisition) +{ + gtk_widget_get_child_requisition (widget, + requisition); +} + +GdkColormap* GTK_WIDGET_GET_COLORMAP (GtkWidget *widget) +{ + return gtk_widget_get_colormap (widget); +} + +GdkColormap* GTK_WIDGET_GET_DEFAULT_COLORMAP (void) +{ + return gtk_widget_get_default_colormap (); +} + +GtkStyle* GTK_WIDGET_GET_DEFAULT_STYLE (void) +{ + return gtk_widget_get_default_style (); +} + +gint GTK_WIDGET_GET_EVENTS (GtkWidget *widget) +{ + return gtk_widget_get_events (widget); +} + +GdkWindow *GTK_WIDGET_GET_PARENT_WINDOW (GtkWidget *widget) +{ + return gtk_widget_get_parent_window (widget); +} + +GtkStyle* GTK_WIDGET_GET_STYLE (GtkWidget *widget) +{ + return gtk_widget_get_style (widget); +} + +GtkType GTK_WIDGET_GET_TYPE (void) +{ + return gtk_widget_get_type (); +} + +GdkVisual* GTK_WIDGET_GET_VISUAL (GtkWidget *widget) +{ + return gtk_widget_get_visual (widget); +} + +void GTK_WIDGET_GRAB_DEFAULT (GtkWidget *widget) +{ + gtk_widget_grab_default (widget); +} + +void GTK_WIDGET_GRAB_FOCUS (GtkWidget *widget) +{ + gtk_widget_grab_focus (widget); +} + +void GTK_WIDGET_HIDE (GtkWidget *widget) +{ + gtk_widget_hide (widget); +} + +gint GTK_WIDGET_INTERSECT (GtkWidget *widget, + GdkRectangle *area, + GdkRectangle *intersection) +{ + return gtk_widget_intersect (widget, + area, + intersection); +} + +void GTK_WIDGET_MAP (GtkWidget *widget) +{ + gtk_widget_map (widget); +} + +void GTK_WIDGET_QUEUE_DRAW (GtkWidget *widget) +{ + gtk_widget_queue_draw (widget); +} + +void GTK_WIDGET_QUEUE_RESIZE (GtkWidget *widget) +{ + gtk_widget_queue_resize (widget); +} + +void GTK_WIDGET_REALIZE (GtkWidget *widget) +{ + gtk_widget_realize (widget); +} + +void GTK_WIDGET_REF (GtkWidget *widget) +{ + gtk_widget_ref (widget); +} + +void GTK_WIDGET_REPARENT (GtkWidget *widget, + GtkWidget *new_parent) +{ + gtk_widget_reparent (widget, + new_parent); +} + +void GTK_WIDGET_SET_DEFAULT_COLORMAP (GdkColormap *colormap) +{ + gtk_widget_set_default_colormap (colormap); +} + +void GTK_WIDGET_SET_DEFAULT_VISUAL (GdkVisual *visual) +{ + gtk_widget_set_default_visual (visual); +} + +void GTK_WIDGET_SET_PARENT (GtkWidget *widget, + GtkWidget *parent) +{ + gtk_widget_set_parent (widget, + parent); +} + +void GTK_WIDGET_SET_PARENT_WINDOW (GtkWidget *widget, + GdkWindow *parent_window) +{ + gtk_widget_set_parent_window (widget, + parent_window); +} + +void GTK_WIDGET_SET_SENSITIVE (GtkWidget *widget, + gboolean sensitive) +{ + gtk_widget_set_sensitive (widget, + sensitive); +} + +void GTK_WIDGET_SET_STYLE (GtkWidget *widget, + GtkStyle *style) +{ + gtk_widget_set_style (widget, + style); +} + +void GTK_WIDGET_SET_UPOSITION (GtkWidget *widget, + gint x, + gint y) +{ + gtk_widget_set_uposition (widget, + x, + y); +} + +void GTK_WIDGET_SET_USIZE (GtkWidget *widget, + gint width, + gint height) +{ + gtk_widget_set_usize (widget, + width, + height); +} + +void GTK_WIDGET_SHOW (GtkWidget *widget) +{ + gtk_widget_show (widget); +} + +void GTK_WIDGET_SIZE_ALLOCATE (GtkWidget *widget, + GtkAllocation *allocation) +{ + gtk_widget_size_allocate (widget, + allocation); +} + +void GTK_WIDGET_SIZE_REQUEST (GtkWidget *widget, + GtkRequisition *requisition) +{ + gtk_widget_size_request (widget, + requisition); +} + +void GTK_WIDGET_UNMAP (GtkWidget *widget) +{ + gtk_widget_unmap (widget); +} + +void GTK_WIDGET_UNPARENT (GtkWidget *widget) +{ + gtk_widget_unparent (widget); +} + +void GTK_WIDGET_UNREF (GtkWidget *widget) +{ + gtk_widget_unref (widget); +} + +GtkType GTK_WINDOW_GET_TYPE (void) +{ + return gtk_window_get_type (); +} + +GtkWidget* GTK_WINDOW_NEW (GtkWindowType type) +{ + return gtk_window_new (type); +} + +void GTK_WINDOW_SET_POLICY (GtkWindow *window, + gint allow_shrink, + gint allow_grow, + gint auto_shrink) +{ + gtk_window_set_policy (window, + allow_shrink, + allow_grow, + auto_shrink); +} + +void GTK_WINDOW_SET_TITLE (GtkWindow *window, + const gchar *title) +{ + gtk_window_set_title (window, + title); +} + +void GTK_WINDOW_SET_TRANSIENT_FOR (GtkWindow *window, + GtkWindow *parent) +{ + gtk_window_set_transient_for (window, + parent); +} + +void GTK_WINDOW_SET_WMCLASS (GtkWindow *window, + const gchar *wmclass_name, + const gchar *wmclass_class) +{ + gtk_window_set_wmclass (window, + wmclass_name, + wmclass_class); +} + +void G_FREE (gpointer mem) +{ + g_free (mem); +} + +GList* G_LIST_ALLOC (void) +{ + return g_list_alloc (); +} + +GList* G_LIST_APPEND (GList *list, + gpointer data) +{ + return g_list_append (list, + data); +} + +void G_LIST_FREE (GList *list) +{ + g_list_free (list); +} + +GList* G_LIST_INSERT (GList *list, + gpointer data, + gint position) +{ + return g_list_insert (list, + data, + position); +} + +GList* G_LIST_LAST (GList *list) +{ + return g_list_last (list); +} + +guint G_LIST_LENGTH (GList *list) +{ + return g_list_length (list); +} + +GList* G_LIST_NTH (GList *list, + guint n) +{ + return g_list_nth (list, + n); +} + +GList* G_LIST_REMOVE (GList *list, + gpointer data) +{ + return g_list_remove (list, + data); +} + +GList* G_LIST_REMOVE_LINK (GList *list, + GList *llink) +{ + return g_list_remove_link (list, + llink); +} + +void G_LOG (const gchar *log_domain, + GLogLevelFlags log_level, + const gchar *format, + ...) +{ + va_list args; + + va_start (args, format); + g_logv (log_domain, log_level, format, args); + va_end (args); +} + +void G_LOGV (const gchar *log_domain, + GLogLevelFlags log_level, + const gchar *format, + va_list args) +{ + g_logv (log_domain, + log_level, + format, + args); +} + +gpointer G_MALLOC (gulong size) +{ + return g_malloc (size); +} + +GSList* G_SLIST_FIND (GSList *list, + gpointer data) +{ + return g_slist_find (list, + data); +} + +void GTK_WINDOW_SET_GEOMETRY_HINTS (GtkWindow *window, + GtkWidget *geometry_widget, + GdkGeometry *geometry, + GdkWindowHints geom_mask) +{ + gtk_window_set_geometry_hints (window, + geometry_widget, + geometry, + geom_mask); +} + +#undef GDK_THREADS_ENTER +void GDK_THREADS_ENTER (void) +{ + gdk_threads_enter1 (); +} + +#undef GDK_THREADS_LEAVE +void GDK_THREADS_LEAVE (void) +{ + gdk_threads_leave1 (); +}