[19523] trunk/dports/x11
source_changes at macosforge.org
source_changes at macosforge.org
Wed Sep 13 22:22:42 PDT 2006
Revision: 19523
Author: markd at macports.org
Date: 2006-09-13 22:22:32 -0700 (Wed, 13 Sep 2006)
Log Message:
-----------
Closes 10293. New port.
Added Paths:
-----------
trunk/dports/x11/rep-gtk/
trunk/dports/x11/rep-gtk/Portfile
trunk/dports/x11/rep-gtk/files/
trunk/dports/x11/rep-gtk/files/patch-Makefile.in
trunk/dports/x11/rep-gtk/files/patch-config.guess
trunk/dports/x11/rep-gtk/files/patch-gtk-compat.c
trunk/dports/x11/rep-gtk/files/patch-gtk-glue.c
trunk/dports/x11/rep-gtk/files/patch-rep-gtk.h
Added: trunk/dports/x11/rep-gtk/Portfile
===================================================================
--- trunk/dports/x11/rep-gtk/Portfile (rev 0)
+++ trunk/dports/x11/rep-gtk/Portfile 2006-09-14 05:22:32 UTC (rev 19523)
@@ -0,0 +1,31 @@
+# $Id: $
+PortSystem 1.0
+name rep-gtk
+version 0.18
+categories x11
+maintainers lloyd at hilaiel.com
+description GTK bindings for the librep LISP implementation
+long_description rep-gtk is a binding of the GTK and GDK libraries \
+ for the librep Lisp environment. It's currently \
+ targeted at GTK 1.2 and is based on the guile-gtk \
+ binding by Marius Vollmer.
+homepage http://rep-gtk.sourceforge.net
+master_sites sourceforge
+
+checksums rep-gtk-0.18.tar.gz md5 220b0d728656472c068e40823f0a3b22 \
+ patch-config.guess md5 fa9e9ad8c181df7298fb3fa592fb84c1 \
+ patch-gtk-compat.c md5 e2303e80fb1ea919fc7db741981002c2 \
+ patch-gtk-glue.c md5 673e837d76db705d9dc23f34baa52256 \
+ patch-rep-gtk.h md5 b314e8518de931847ad60c9c346d06d4 \
+ patch-Makefile.in md5 a4e3ec91d136f91caa58d570d3ca808e
+
+patchfiles patch-config.guess \
+ patch-gtk-compat.c \
+ patch-gtk-glue.c \
+ patch-rep-gtk.h \
+ patch-Makefile.in
+
+depends_lib port:gtk2 port:librep
+
+configure.args --without-gnome --without-libglade --prefix=${prefix}
+
Added: trunk/dports/x11/rep-gtk/files/patch-Makefile.in
===================================================================
--- trunk/dports/x11/rep-gtk/files/patch-Makefile.in (rev 0)
+++ trunk/dports/x11/rep-gtk/files/patch-Makefile.in 2006-09-14 05:22:32 UTC (rev 19523)
@@ -0,0 +1,17 @@
+--- ../rep-gtk-0.18.orig/Makefile.in 2006-08-07 12:01:59.000000000 -0600
++++ Makefile.in 2006-08-07 12:13:58.000000000 -0600
+@@ -5,7 +5,7 @@
+ SGTK_SRCS = rep-types.c
+ SGTK_OBJS = $(SGTK_SRCS:.c=.lo)
+
+-SRCS = rep-gtk.c gtk-support.c gtk-compat.c glib-glue.c gdk-glue.c gtk-glue.c gdk-pixbuf-glue.c
++SRCS = rep-gtk.c gtk-support.c gtk-compat.c glib-glue.c gdk-glue.c gtk-gluehacked.c gdk-pixbuf-glue.c
+ OBJS = $(SRCS:.c=.lo)
+
+ LIBGLADE_SRCS = libglade-support.c libglade-glue.c
+@@ -128,5 +128,3 @@
+ gtk-2 :
+ mkdir gtk-2
+
+-# hand-needed dependences
+-gtk-glue.c : gtk.defs gtktext.defs build-gtk.jlc
Added: trunk/dports/x11/rep-gtk/files/patch-config.guess
===================================================================
--- trunk/dports/x11/rep-gtk/files/patch-config.guess (rev 0)
+++ trunk/dports/x11/rep-gtk/files/patch-config.guess 2006-09-14 05:22:32 UTC (rev 19523)
@@ -0,0 +1,16 @@
+--- ../rep-gtk-0.18.orig/config.guess 2006-08-07 08:35:10.000000000 -0600
++++ config.guess 2006-08-07 08:35:18.000000000 -0600
+@@ -974,6 +974,13 @@
+ *:Rhapsody:*:*)
+ echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+ exit 0 ;;
++ *:Darwin:*:*)
++ case `uname -p` in
++ *86) UNAME_PROCESSOR=i686 ;;
++ powerpc) UNAME_PROCESSOR=powerpc ;;
++ esac
++ echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
++ exit 0 ;;
+ *:QNX:*:4*)
+ echo i386-qnx-qnx${UNAME_VERSION}
+ exit 0 ;;
Added: trunk/dports/x11/rep-gtk/files/patch-gtk-compat.c
===================================================================
--- trunk/dports/x11/rep-gtk/files/patch-gtk-compat.c (rev 0)
+++ trunk/dports/x11/rep-gtk/files/patch-gtk-compat.c 2006-09-14 05:22:32 UTC (rev 19523)
@@ -0,0 +1,33 @@
+--- ../rep-gtk-0.18.orig/gtk-compat.c 2006-08-07 09:16:07.000000000 -0600
++++ gtk-compat.c 2006-08-07 09:16:29.000000000 -0600
+@@ -63,23 +63,25 @@
+ }
+
+ GtkWidget*
+-gtk_radio_menu_item_new_with_label_from_widget (GtkRadioMenuItem *group,
+- gchar *label)
++wrapper_gtk_radio_menu_item_new_with_label_from_widget (
++ GtkRadioMenuItem *group,
++ const gchar *label)
+ {
+ GSList *g = group? gtk_radio_menu_item_group (group) : NULL;
+ return gtk_radio_menu_item_new_with_label (g, label);
+ }
+
+ GtkWidget*
+-gtk_radio_menu_item_new_with_mnemonic_from_widget (GtkRadioMenuItem *group,
+- gchar *label)
++wrapper_gtk_radio_menu_item_new_with_mnemonic_from_widget (
++ GtkRadioMenuItem *group,
++ const gchar *label)
+ {
+ GSList *g = group? gtk_radio_menu_item_group (group) : NULL;
+ return gtk_radio_menu_item_new_with_mnemonic (g, label);
+ }
+
+ GtkWidget*
+-gtk_radio_menu_item_new_from_widget (GtkRadioMenuItem *group)
++wrapper_gtk_radio_menu_item_new_from_widget (GtkRadioMenuItem *group)
+ {
+ GSList *g = group? gtk_radio_menu_item_group (group) : NULL;
+ return gtk_radio_menu_item_new (g);
Added: trunk/dports/x11/rep-gtk/files/patch-gtk-glue.c
===================================================================
--- trunk/dports/x11/rep-gtk/files/patch-gtk-glue.c (rev 0)
+++ trunk/dports/x11/rep-gtk/files/patch-gtk-glue.c 2006-09-14 05:22:32 UTC (rev 19523)
@@ -0,0 +1,18966 @@
+--- gtk-gluehacked.c 1969-12-31 17:00:00.000000000 -0700
++++ gtk-gluehacked.c 2006-08-07 08:52:49.000000000 -0600
+@@ -0,0 +1,18963 @@
++/* Automatically generated by build-gtk, DO NOT EDIT! */
++
++#define GTK_ENABLE_BROKEN
++#include <gtk/gtk.h>
++#include <rep.h>
++#include "rep-gtk.h"
++
++
++/* Imported enums */
++
++extern sgtk_enum_info sgtk_gdk_interp_type_info;
++extern sgtk_enum_info sgtk_gdk_pixbuf_alpha_mode_info;
++extern sgtk_enum_info sgtk_gdk_colorspace_info;
++extern sgtk_enum_info sgtk_gdk_input_source_info;
++extern sgtk_enum_info sgtk_gdk_visibility_state_info;
++extern sgtk_enum_info sgtk_gdk_overlap_type_info;
++extern sgtk_enum_info sgtk_gdk_prop_mode_info;
++extern sgtk_enum_info sgtk_gdk_property_state_info;
++extern sgtk_enum_info sgtk_gdk_selection_info;
++extern sgtk_enum_info sgtk_gdk_byte_order_info;
++extern sgtk_enum_info sgtk_gdk_status_info;
++extern sgtk_enum_info sgtk_gdk_subwindow_mode_info;
++extern sgtk_enum_info sgtk_gdk_notify_type_info;
++extern sgtk_enum_info sgtk_gdk_event_type_info;
++extern sgtk_enum_info sgtk_gdk_cursor_type_info;
++extern sgtk_enum_info sgtk_gdk_join_style_info;
++extern sgtk_enum_info sgtk_gdk_cap_style_info;
++extern sgtk_enum_info sgtk_gdk_line_style_info;
++extern sgtk_enum_info sgtk_gdk_fill_info;
++extern sgtk_enum_info sgtk_gdk_function_info;
++extern sgtk_enum_info sgtk_gdk_visual_type_info;
++extern sgtk_enum_info sgtk_gdk_image_type_info;
++extern sgtk_enum_info sgtk_gdk_window_class_info;
++extern sgtk_enum_info sgtk_gdk_window_type_info;
++
++
++/* Imported flags */
++
++extern sgtk_enum_info sgtk_gdk_wmfunction_info;
++extern sgtk_enum_info sgtk_gdk_wmdecoration_info;
++extern sgtk_enum_info sgtk_gdk_gcvalues_mask_info;
++extern sgtk_enum_info sgtk_gdk_input_condition_info;
++extern sgtk_enum_info sgtk_gdk_modifier_type_info;
++extern sgtk_enum_info sgtk_gdk_event_mask_info;
++extern sgtk_enum_info sgtk_gdk_window_hints_info;
++extern sgtk_enum_info sgtk_gdk_window_attributes_type_info;
++
++
++/* Imported boxed structures */
++
++extern sgtk_boxed_info sgtk_gdk_pixbuf_info;
++extern sgtk_boxed_info sgtk_gdk_gc_info;
++extern sgtk_boxed_info sgtk_gdk_color_info;
++extern sgtk_boxed_info sgtk_gdk_event_info;
++extern sgtk_boxed_info sgtk_gdk_window_info;
++extern sgtk_boxed_info sgtk_gdk_font_info;
++extern sgtk_boxed_info sgtk_gdk_visual_info;
++extern sgtk_boxed_info sgtk_gdk_colormap_info;
++
++
++/* Imported GTK objects */
++
++extern sgtk_object_info sgtk_gobject_info;
++
++
++/* Enums definitions */
++
++static sgtk_enum_literal _gtk_anchor_type_literals[9] = {
++ { "center", GTK_ANCHOR_CENTER },
++ { "north", GTK_ANCHOR_NORTH },
++ { "south", GTK_ANCHOR_SOUTH },
++ { "east", GTK_ANCHOR_EAST },
++ { "west", GTK_ANCHOR_WEST },
++ { "north-west", GTK_ANCHOR_NORTH_WEST },
++ { "north-east", GTK_ANCHOR_NORTH_EAST },
++ { "south-west", GTK_ANCHOR_SOUTH_WEST },
++ { "south-east", GTK_ANCHOR_SOUTH_EAST },
++};
++sgtk_enum_info sgtk_gtk_anchor_type_info = {
++ { "GtkAnchorType", G_TYPE_ENUM }, 9, _gtk_anchor_type_literals,
++};
++
++static sgtk_enum_literal _gtk_arrow_type_literals[4] = {
++ { "up", GTK_ARROW_UP },
++ { "down", GTK_ARROW_DOWN },
++ { "left", GTK_ARROW_LEFT },
++ { "right", GTK_ARROW_RIGHT },
++};
++sgtk_enum_info sgtk_gtk_arrow_type_info = {
++ { "GtkArrowType", G_TYPE_ENUM }, 4, _gtk_arrow_type_literals,
++};
++
++static sgtk_enum_literal _gtk_button_box_style_literals[5] = {
++ { "default-style", GTK_BUTTONBOX_DEFAULT_STYLE },
++ { "spread", GTK_BUTTONBOX_SPREAD },
++ { "edge", GTK_BUTTONBOX_EDGE },
++ { "start", GTK_BUTTONBOX_START },
++ { "end", GTK_BUTTONBOX_END },
++};
++sgtk_enum_info sgtk_gtk_button_box_style_info = {
++ { "GtkButtonBoxStyle", G_TYPE_ENUM }, 5, _gtk_button_box_style_literals,
++};
++
++static sgtk_enum_literal _gtk_curve_type_literals[3] = {
++ { "linear", GTK_CURVE_TYPE_LINEAR },
++ { "spline", GTK_CURVE_TYPE_SPLINE },
++ { "free", GTK_CURVE_TYPE_FREE },
++};
++sgtk_enum_info sgtk_gtk_curve_type_info = {
++ { "GtkCurveType", G_TYPE_ENUM }, 3, _gtk_curve_type_literals,
++};
++
++static sgtk_enum_literal _gtk_delete_type_literals[8] = {
++ { "chars", GTK_DELETE_CHARS },
++ { "word-ends", GTK_DELETE_WORD_ENDS },
++ { "words", GTK_DELETE_WORDS },
++ { "display-lines", GTK_DELETE_DISPLAY_LINES },
++ { "display-line-ends", GTK_DELETE_DISPLAY_LINE_ENDS },
++ { "paragraph-ends", GTK_DELETE_PARAGRAPH_ENDS },
++ { "paragraphs", GTK_DELETE_PARAGRAPHS },
++ { "whitespace", GTK_DELETE_WHITESPACE },
++};
++sgtk_enum_info sgtk_gtk_delete_type_info = {
++ { "GtkDeleteType", G_TYPE_ENUM }, 8, _gtk_delete_type_literals,
++};
++
++static sgtk_enum_literal _gtk_direction_type_literals[6] = {
++ { "tab-forward", GTK_DIR_TAB_FORWARD },
++ { "tab-backward", GTK_DIR_TAB_BACKWARD },
++ { "up", GTK_DIR_UP },
++ { "down", GTK_DIR_DOWN },
++ { "left", GTK_DIR_LEFT },
++ { "right", GTK_DIR_RIGHT },
++};
++sgtk_enum_info sgtk_gtk_direction_type_info = {
++ { "GtkDirectionType", G_TYPE_ENUM }, 6, _gtk_direction_type_literals,
++};
++
++static sgtk_enum_literal _gtk_expander_style_literals[4] = {
++ { "collapsed", GTK_EXPANDER_COLLAPSED },
++ { "semi-collapsed", GTK_EXPANDER_SEMI_COLLAPSED },
++ { "semi-expanded", GTK_EXPANDER_SEMI_EXPANDED },
++ { "expanded", GTK_EXPANDER_EXPANDED },
++};
++sgtk_enum_info sgtk_gtk_expander_style_info = {
++ { "GtkExpanderStyle", G_TYPE_ENUM }, 4, _gtk_expander_style_literals,
++};
++
++static sgtk_enum_literal _gtk_icon_size_literals[7] = {
++ { "invalid", GTK_ICON_SIZE_INVALID },
++ { "menu", GTK_ICON_SIZE_MENU },
++ { "small-toolbar", GTK_ICON_SIZE_SMALL_TOOLBAR },
++ { "large-toolbar", GTK_ICON_SIZE_LARGE_TOOLBAR },
++ { "button", GTK_ICON_SIZE_BUTTON },
++ { "dnd", GTK_ICON_SIZE_DND },
++ { "dialog", GTK_ICON_SIZE_DIALOG },
++};
++sgtk_enum_info sgtk_gtk_icon_size_info = {
++ { "GtkIconSize", G_TYPE_ENUM }, 7, _gtk_icon_size_literals,
++};
++
++static sgtk_enum_literal _gtk_text_direction_literals[3] = {
++ { "none", GTK_TEXT_DIR_NONE },
++ { "ltr", GTK_TEXT_DIR_LTR },
++ { "rtl", GTK_TEXT_DIR_RTL },
++};
++sgtk_enum_info sgtk_gtk_text_direction_info = {
++ { "GtkTextDirection", G_TYPE_ENUM }, 3, _gtk_text_direction_literals,
++};
++
++static sgtk_enum_literal _gtk_justification_literals[4] = {
++ { "left", GTK_JUSTIFY_LEFT },
++ { "right", GTK_JUSTIFY_RIGHT },
++ { "center", GTK_JUSTIFY_CENTER },
++ { "fill", GTK_JUSTIFY_FILL },
++};
++sgtk_enum_info sgtk_gtk_justification_info = {
++ { "GtkJustification", G_TYPE_ENUM }, 4, _gtk_justification_literals,
++};
++
++static sgtk_enum_literal _gtk_menu_direction_type_literals[4] = {
++ { "parent", GTK_MENU_DIR_PARENT },
++ { "child", GTK_MENU_DIR_CHILD },
++ { "next", GTK_MENU_DIR_NEXT },
++ { "prev", GTK_MENU_DIR_PREV },
++};
++sgtk_enum_info sgtk_gtk_menu_direction_type_info = {
++ { "GtkMenuDirectionType", G_TYPE_ENUM }, 4, _gtk_menu_direction_type_literals,
++};
++
++static sgtk_enum_literal _gtk_metric_type_literals[3] = {
++ { "pixels", GTK_PIXELS },
++ { "inches", GTK_INCHES },
++ { "centimeters", GTK_CENTIMETERS },
++};
++sgtk_enum_info sgtk_gtk_metric_type_info = {
++ { "GtkMetricType", G_TYPE_ENUM }, 3, _gtk_metric_type_literals,
++};
++
++static sgtk_enum_literal _gtk_movement_step_literals[9] = {
++ { "logical-positions", GTK_MOVEMENT_LOGICAL_POSITIONS },
++ { "visual-positions", GTK_MOVEMENT_VISUAL_POSITIONS },
++ { "words", GTK_MOVEMENT_WORDS },
++ { "display-lines", GTK_MOVEMENT_DISPLAY_LINES },
++ { "display-line-ends", GTK_MOVEMENT_DISPLAY_LINE_ENDS },
++ { "paragraph-ends", GTK_MOVEMENT_PARAGRAPH_ENDS },
++ { "paragraphs", GTK_MOVEMENT_PARAGRAPHS },
++ { "pages", GTK_MOVEMENT_PAGES },
++ { "buffer-ends", GTK_MOVEMENT_BUFFER_ENDS },
++};
++sgtk_enum_info sgtk_gtk_movement_step_info = {
++ { "GtkMovementStep", G_TYPE_ENUM }, 9, _gtk_movement_step_literals,
++};
++
++static sgtk_enum_literal _gtk_orientation_literals[2] = {
++ { "horizontal", GTK_ORIENTATION_HORIZONTAL },
++ { "vertical", GTK_ORIENTATION_VERTICAL },
++};
++sgtk_enum_info sgtk_gtk_orientation_info = {
++ { "GtkOrientation", G_TYPE_ENUM }, 2, _gtk_orientation_literals,
++};
++
++static sgtk_enum_literal _gtk_corner_type_literals[4] = {
++ { "top-left", GTK_CORNER_TOP_LEFT },
++ { "bottom-left", GTK_CORNER_BOTTOM_LEFT },
++ { "top-right", GTK_CORNER_TOP_RIGHT },
++ { "bottom-right", GTK_CORNER_BOTTOM_RIGHT },
++};
++sgtk_enum_info sgtk_gtk_corner_type_info = {
++ { "GtkCornerType", G_TYPE_ENUM }, 4, _gtk_corner_type_literals,
++};
++
++static sgtk_enum_literal _gtk_pack_type_literals[2] = {
++ { "start", GTK_PACK_START },
++ { "end", GTK_PACK_END },
++};
++sgtk_enum_info sgtk_gtk_pack_type_info = {
++ { "GtkPackType", G_TYPE_ENUM }, 2, _gtk_pack_type_literals,
++};
++
++static sgtk_enum_literal _gtk_path_priority_type_literals[6] = {
++ { "lowest", GTK_PATH_PRIO_LOWEST },
++ { "gtk", GTK_PATH_PRIO_GTK },
++ { "application", GTK_PATH_PRIO_APPLICATION },
++ { "theme", GTK_PATH_PRIO_THEME },
++ { "rc", GTK_PATH_PRIO_RC },
++ { "highest", GTK_PATH_PRIO_HIGHEST },
++};
++sgtk_enum_info sgtk_gtk_path_priority_type_info = {
++ { "GtkPathPriorityType", G_TYPE_ENUM }, 6, _gtk_path_priority_type_literals,
++};
++
++static sgtk_enum_literal _gtk_path_type_literals[3] = {
++ { "widget", GTK_PATH_WIDGET },
++ { "widget-class", GTK_PATH_WIDGET_CLASS },
++ { "class", GTK_PATH_CLASS },
++};
++sgtk_enum_info sgtk_gtk_path_type_info = {
++ { "GtkPathType", G_TYPE_ENUM }, 3, _gtk_path_type_literals,
++};
++
++static sgtk_enum_literal _gtk_policy_type_literals[3] = {
++ { "always", GTK_POLICY_ALWAYS },
++ { "automatic", GTK_POLICY_AUTOMATIC },
++ { "never", GTK_POLICY_NEVER },
++};
++sgtk_enum_info sgtk_gtk_policy_type_info = {
++ { "GtkPolicyType", G_TYPE_ENUM }, 3, _gtk_policy_type_literals,
++};
++
++static sgtk_enum_literal _gtk_position_type_literals[4] = {
++ { "left", GTK_POS_LEFT },
++ { "right", GTK_POS_RIGHT },
++ { "top", GTK_POS_TOP },
++ { "bottom", GTK_POS_BOTTOM },
++};
++sgtk_enum_info sgtk_gtk_position_type_info = {
++ { "GtkPositionType", G_TYPE_ENUM }, 4, _gtk_position_type_literals,
++};
++
++static sgtk_enum_literal _gtk_preview_type_literals[2] = {
++ { "color", GTK_PREVIEW_COLOR },
++ { "grayscale", GTK_PREVIEW_GRAYSCALE },
++};
++sgtk_enum_info sgtk_gtk_preview_type_info = {
++ { "GtkPreviewType", G_TYPE_ENUM }, 2, _gtk_preview_type_literals,
++};
++
++static sgtk_enum_literal _gtk_relief_style_literals[3] = {
++ { "normal", GTK_RELIEF_NORMAL },
++ { "half", GTK_RELIEF_HALF },
++ { "none", GTK_RELIEF_NONE },
++};
++sgtk_enum_info sgtk_gtk_relief_style_info = {
++ { "GtkReliefStyle", G_TYPE_ENUM }, 3, _gtk_relief_style_literals,
++};
++
++static sgtk_enum_literal _gtk_resize_mode_literals[3] = {
++ { "parent", GTK_RESIZE_PARENT },
++ { "queue", GTK_RESIZE_QUEUE },
++ { "immediate", GTK_RESIZE_IMMEDIATE },
++};
++sgtk_enum_info sgtk_gtk_resize_mode_info = {
++ { "GtkResizeMode", G_TYPE_ENUM }, 3, _gtk_resize_mode_literals,
++};
++
++static sgtk_enum_literal _gtk_scroll_type_literals[14] = {
++ { "none", GTK_SCROLL_NONE },
++ { "jump", GTK_SCROLL_JUMP },
++ { "step-backward", GTK_SCROLL_STEP_BACKWARD },
++ { "step-forward", GTK_SCROLL_STEP_FORWARD },
++ { "page-backward", GTK_SCROLL_PAGE_BACKWARD },
++ { "page-forward", GTK_SCROLL_PAGE_FORWARD },
++ { "step-up", GTK_SCROLL_STEP_UP },
++ { "step-down", GTK_SCROLL_STEP_DOWN },
++ { "page-up", GTK_SCROLL_PAGE_UP },
++ { "page-down", GTK_SCROLL_PAGE_DOWN },
++ { "step-left", GTK_SCROLL_STEP_LEFT },
++ { "step-right", GTK_SCROLL_STEP_RIGHT },
++ { "start", GTK_SCROLL_START },
++ { "end", GTK_SCROLL_END },
++};
++sgtk_enum_info sgtk_gtk_scroll_type_info = {
++ { "GtkScrollType", G_TYPE_ENUM }, 14, _gtk_scroll_type_literals,
++};
++
++static sgtk_enum_literal _gtk_selection_mode_literals[4] = {
++ { "none", GTK_SELECTION_NONE },
++ { "single", GTK_SELECTION_SINGLE },
++ { "browse", GTK_SELECTION_BROWSE },
++ { "multiple", GTK_SELECTION_MULTIPLE },
++};
++sgtk_enum_info sgtk_gtk_selection_mode_info = {
++ { "GtkSelectionMode", G_TYPE_ENUM }, 4, _gtk_selection_mode_literals,
++};
++
++static sgtk_enum_literal _gtk_shadow_type_literals[5] = {
++ { "none", GTK_SHADOW_NONE },
++ { "in", GTK_SHADOW_IN },
++ { "out", GTK_SHADOW_OUT },
++ { "etched-in", GTK_SHADOW_ETCHED_IN },
++ { "etched-out", GTK_SHADOW_ETCHED_OUT },
++};
++sgtk_enum_info sgtk_gtk_shadow_type_info = {
++ { "GtkShadowType", G_TYPE_ENUM }, 5, _gtk_shadow_type_literals,
++};
++
++static sgtk_enum_literal _gtk_state_type_literals[5] = {
++ { "normal", GTK_STATE_NORMAL },
++ { "active", GTK_STATE_ACTIVE },
++ { "prelight", GTK_STATE_PRELIGHT },
++ { "selected", GTK_STATE_SELECTED },
++ { "insensitive", GTK_STATE_INSENSITIVE },
++};
++sgtk_enum_info sgtk_gtk_state_type_info = {
++ { "GtkStateType", G_TYPE_ENUM }, 5, _gtk_state_type_literals,
++};
++
++static sgtk_enum_literal _gtk_submenu_direction_literals[2] = {
++ { "left", GTK_DIRECTION_LEFT },
++ { "right", GTK_DIRECTION_RIGHT },
++};
++sgtk_enum_info sgtk_gtk_submenu_direction_info = {
++ { "GtkSubmenuDirection", G_TYPE_ENUM }, 2, _gtk_submenu_direction_literals,
++};
++
++static sgtk_enum_literal _gtk_submenu_placement_literals[2] = {
++ { "top-bottom", GTK_TOP_BOTTOM },
++ { "left-right", GTK_LEFT_RIGHT },
++};
++sgtk_enum_info sgtk_gtk_submenu_placement_info = {
++ { "GtkSubmenuPlacement", G_TYPE_ENUM }, 2, _gtk_submenu_placement_literals,
++};
++
++static sgtk_enum_literal _gtk_toolbar_style_literals[4] = {
++ { "icons", GTK_TOOLBAR_ICONS },
++ { "text", GTK_TOOLBAR_TEXT },
++ { "both", GTK_TOOLBAR_BOTH },
++ { "both-horiz", GTK_TOOLBAR_BOTH_HORIZ },
++};
++sgtk_enum_info sgtk_gtk_toolbar_style_info = {
++ { "GtkToolbarStyle", G_TYPE_ENUM }, 4, _gtk_toolbar_style_literals,
++};
++
++static sgtk_enum_literal _gtk_update_type_literals[3] = {
++ { "continuous", GTK_UPDATE_CONTINUOUS },
++ { "discontinuous", GTK_UPDATE_DISCONTINUOUS },
++ { "delayed", GTK_UPDATE_DELAYED },
++};
++sgtk_enum_info sgtk_gtk_update_type_info = {
++ { "GtkUpdateType", G_TYPE_ENUM }, 3, _gtk_update_type_literals,
++};
++
++static sgtk_enum_literal _gtk_visibility_literals[3] = {
++ { "none", GTK_VISIBILITY_NONE },
++ { "partial", GTK_VISIBILITY_PARTIAL },
++ { "full", GTK_VISIBILITY_FULL },
++};
++sgtk_enum_info sgtk_gtk_visibility_info = {
++ { "GtkVisibility", G_TYPE_ENUM }, 3, _gtk_visibility_literals,
++};
++
++static sgtk_enum_literal _gtk_window_position_literals[5] = {
++ { "none", GTK_WIN_POS_NONE },
++ { "center", GTK_WIN_POS_CENTER },
++ { "mouse", GTK_WIN_POS_MOUSE },
++ { "center-always", GTK_WIN_POS_CENTER_ALWAYS },
++ { "center-on-parent", GTK_WIN_POS_CENTER_ON_PARENT },
++};
++sgtk_enum_info sgtk_gtk_window_position_info = {
++ { "GtkWindowPosition", G_TYPE_ENUM }, 5, _gtk_window_position_literals,
++};
++
++static sgtk_enum_literal _gtk_window_type_literals[2] = {
++ { "toplevel", GTK_WINDOW_TOPLEVEL },
++ { "popup", GTK_WINDOW_POPUP },
++};
++sgtk_enum_info sgtk_gtk_window_type_info = {
++ { "GtkWindowType", G_TYPE_ENUM }, 2, _gtk_window_type_literals,
++};
++
++static sgtk_enum_literal _gtk_wrap_mode_literals[3] = {
++ { "none", GTK_WRAP_NONE },
++ { "char", GTK_WRAP_CHAR },
++ { "word", GTK_WRAP_WORD },
++};
++sgtk_enum_info sgtk_gtk_wrap_mode_info = {
++ { "GtkWrapMode", G_TYPE_ENUM }, 3, _gtk_wrap_mode_literals,
++};
++
++static sgtk_enum_literal _gtk_sort_type_literals[2] = {
++ { "ascending", GTK_SORT_ASCENDING },
++ { "descending", GTK_SORT_DESCENDING },
++};
++sgtk_enum_info sgtk_gtk_sort_type_info = {
++ { "GtkSortType", G_TYPE_ENUM }, 2, _gtk_sort_type_literals,
++};
++
++static sgtk_enum_literal _gtk_toolbar_child_type_literals[5] = {
++ { "space", GTK_TOOLBAR_CHILD_SPACE },
++ { "button", GTK_TOOLBAR_CHILD_BUTTON },
++ { "toggle-button", GTK_TOOLBAR_CHILD_TOGGLEBUTTON },
++ { "radio-button", GTK_TOOLBAR_CHILD_RADIOBUTTON },
++ { "widget", GTK_TOOLBAR_CHILD_WIDGET },
++};
++sgtk_enum_info sgtk_gtk_toolbar_child_type_info = {
++ { "GtkToolbarChildType", G_TYPE_ENUM }, 5, _gtk_toolbar_child_type_literals,
++};
++
++static sgtk_enum_literal _gtk_fundamental_type_literals[14] = {
++ { "invalid", GTK_TYPE_INVALID },
++ { "none", GTK_TYPE_NONE },
++ { "char", GTK_TYPE_CHAR },
++ { "bool", GTK_TYPE_BOOL },
++ { "int", GTK_TYPE_INT },
++ { "uint", GTK_TYPE_UINT },
++ { "long", GTK_TYPE_LONG },
++ { "ulong", GTK_TYPE_ULONG },
++ { "float", GTK_TYPE_FLOAT },
++ { "string", GTK_TYPE_STRING },
++ { "enum", GTK_TYPE_ENUM },
++ { "flags", GTK_TYPE_FLAGS },
++ { "boxed", GTK_TYPE_BOXED },
++ { "pointer", GTK_TYPE_POINTER },
++};
++sgtk_enum_info sgtk_gtk_fundamental_type_info = {
++ { "GtkFundamentalType", G_TYPE_ENUM }, 14, _gtk_fundamental_type_literals,
++};
++
++static sgtk_enum_literal _gtk_spin_button_update_policy_literals[2] = {
++ { "always", GTK_UPDATE_ALWAYS },
++ { "if-valid", GTK_UPDATE_IF_VALID },
++};
++sgtk_enum_info sgtk_gtk_spin_button_update_policy_info = {
++ { "GtkSpinButtonUpdatePolicy", G_TYPE_ENUM }, 2, _gtk_spin_button_update_policy_literals,
++};
++
++static sgtk_enum_literal _gtk_spin_type_literals[7] = {
++ { "step-forward", GTK_SPIN_STEP_FORWARD },
++ { "step-backward", GTK_SPIN_STEP_BACKWARD },
++ { "page-forward", GTK_SPIN_PAGE_FORWARD },
++ { "page-backward", GTK_SPIN_PAGE_BACKWARD },
++ { "home", GTK_SPIN_HOME },
++ { "end", GTK_SPIN_END },
++ { "user-defined", GTK_SPIN_USER_DEFINED },
++};
++sgtk_enum_info sgtk_gtk_spin_type_info = {
++ { "GtkSpinType", G_TYPE_ENUM }, 7, _gtk_spin_type_literals,
++};
++
++static sgtk_enum_literal _gtk_cell_type_literals[5] = {
++ { "empty", GTK_CELL_EMPTY },
++ { "text", GTK_CELL_TEXT },
++ { "pixmap", GTK_CELL_PIXMAP },
++ { "pixtext", GTK_CELL_PIXTEXT },
++ { "widget", GTK_CELL_WIDGET },
++};
++sgtk_enum_info sgtk_gtk_cell_type_info = {
++ { "GtkCellType", G_TYPE_ENUM }, 5, _gtk_cell_type_literals,
++};
++
++static sgtk_enum_literal _gtk_progress_bar_orientation_literals[4] = {
++ { "left-to-right", GTK_PROGRESS_LEFT_TO_RIGHT },
++ { "right-to-left", GTK_PROGRESS_RIGHT_TO_LEFT },
++ { "bottom-to-top", GTK_PROGRESS_BOTTOM_TO_TOP },
++ { "top-to-bottom", GTK_PROGRESS_TOP_TO_BOTTOM },
++};
++sgtk_enum_info sgtk_gtk_progress_bar_orientation_info = {
++ { "GtkProgressBarOrientation", G_TYPE_ENUM }, 4, _gtk_progress_bar_orientation_literals,
++};
++
++static sgtk_enum_literal _gtk_text_window_type_literals[7] = {
++ { "private", GTK_TEXT_WINDOW_PRIVATE },
++ { "widget", GTK_TEXT_WINDOW_WIDGET },
++ { "text", GTK_TEXT_WINDOW_TEXT },
++ { "left", GTK_TEXT_WINDOW_LEFT },
++ { "right", GTK_TEXT_WINDOW_RIGHT },
++ { "top", GTK_TEXT_WINDOW_TOP },
++ { "bottom", GTK_TEXT_WINDOW_BOTTOM },
++};
++sgtk_enum_info sgtk_gtk_text_window_type_info = {
++ { "GtkTextWindowType", G_TYPE_ENUM }, 7, _gtk_text_window_type_literals,
++};
++
++
++/* Flags definitions */
++
++static sgtk_enum_literal _gtk_attach_options_literals[3] = {
++ { "expand", GTK_EXPAND },
++ { "shrink", GTK_SHRINK },
++ { "fill", GTK_FILL },
++};
++sgtk_enum_info sgtk_gtk_attach_options_info = {
++ { "GtkAttachOptions", G_TYPE_FLAGS }, 3, _gtk_attach_options_literals,
++};
++
++static sgtk_enum_literal _gtk_signal_run_type_literals[6] = {
++ { "first", GTK_RUN_FIRST },
++ { "last", GTK_RUN_LAST },
++ { "both", GTK_RUN_BOTH },
++ { "no-recurse", GTK_RUN_NO_RECURSE },
++ { "action", GTK_RUN_ACTION },
++ { "no-hooks", GTK_RUN_NO_HOOKS },
++};
++sgtk_enum_info sgtk_gtk_signal_run_type_info = {
++ { "GtkSignalRunType", G_TYPE_FLAGS }, 6, _gtk_signal_run_type_literals,
++};
++
++static sgtk_enum_literal _gtk_widget_flags_literals[18] = {
++ { "toplevel", GTK_TOPLEVEL },
++ { "no-window", GTK_NO_WINDOW },
++ { "realized", GTK_REALIZED },
++ { "mapped", GTK_MAPPED },
++ { "visible", GTK_VISIBLE },
++ { "sensitive", GTK_SENSITIVE },
++ { "parent-sensitive", GTK_PARENT_SENSITIVE },
++ { "can-focus", GTK_CAN_FOCUS },
++ { "has-focus", GTK_HAS_FOCUS },
++ { "can-default", GTK_CAN_DEFAULT },
++ { "has-default", GTK_HAS_DEFAULT },
++ { "has-grab", GTK_HAS_GRAB },
++ { "rc-style", GTK_RC_STYLE },
++ { "composite-child", GTK_COMPOSITE_CHILD },
++ { "no-reparent", GTK_NO_REPARENT },
++ { "app-paintable", GTK_APP_PAINTABLE },
++ { "receives-default", GTK_RECEIVES_DEFAULT },
++ { "double-buffered", GTK_DOUBLE_BUFFERED },
++};
++sgtk_enum_info sgtk_gtk_widget_flags_info = {
++ { "GtkWidgetFlags", G_TYPE_FLAGS }, 18, _gtk_widget_flags_literals,
++};
++
++static sgtk_enum_literal _gtk_arg_flags_literals[6] = {
++ { "readable", GTK_ARG_READABLE },
++ { "writeable", GTK_ARG_WRITABLE },
++ { "construct", GTK_ARG_CONSTRUCT },
++ { "construct-only", GTK_ARG_CONSTRUCT_ONLY },
++ { "child-arg", GTK_ARG_CHILD_ARG },
++ { "readwrite", GTK_ARG_READWRITE },
++};
++sgtk_enum_info sgtk_gtk_arg_flags_info = {
++ { "GtkArgFlags", G_TYPE_FLAGS }, 6, _gtk_arg_flags_literals,
++};
++
++static sgtk_enum_literal _gtk_accel_flags_literals[2] = {
++ { "visible", GTK_ACCEL_VISIBLE },
++ { "locked", GTK_ACCEL_LOCKED },
++};
++sgtk_enum_info sgtk_gtk_accel_flags_info = {
++ { "GtkAccelFlags", G_TYPE_FLAGS }, 2, _gtk_accel_flags_literals,
++};
++
++static sgtk_enum_literal _gtk_calendar_display_options_literals[5] = {
++ { "show-heading", GTK_CALENDAR_SHOW_HEADING },
++ { "show-day-names", GTK_CALENDAR_SHOW_DAY_NAMES },
++ { "no-month-changed", GTK_CALENDAR_NO_MONTH_CHANGE },
++ { "show-week-numbers", GTK_CALENDAR_SHOW_WEEK_NUMBERS },
++ { "week-start-monday", GTK_CALENDAR_WEEK_START_MONDAY },
++};
++sgtk_enum_info sgtk_gtk_calendar_display_options_info = {
++ { "GtkCalendarDisplayOptions", G_TYPE_FLAGS }, 5, _gtk_calendar_display_options_literals,
++};
++
++static sgtk_enum_literal _gtk_text_search_flags_literals[2] = {
++ { "visible-only", GTK_TEXT_SEARCH_VISIBLE_ONLY },
++ { "text-only", GTK_TEXT_SEARCH_TEXT_ONLY },
++};
++sgtk_enum_info sgtk_gtk_text_search_flags_info = {
++ { "GtkTextSearchFlags", G_TYPE_FLAGS }, 2, _gtk_text_search_flags_literals,
++};
++
++
++/* Boxed structure definitions */
++
++sgtk_boxed_info sgtk_gtk_icon_set_info = {
++ { "GtkIconSet", G_TYPE_BOXED, NULL },
++ (void *(*)(void*))gtk_icon_set_copy,
++ (void (*)(void*))gtk_icon_set_unref,
++ 0
++};
++
++sgtk_boxed_info sgtk_gtk_text_iter_info = {
++ { "GtkTextIter", G_TYPE_BOXED, NULL },
++ (void *(*)(void*))gtk_text_iter_copy,
++ (void (*)(void*))gtk_text_iter_free,
++ 0
++};
++
++
++/* GTK object definitions */
++
++sgtk_object_info sgtk_gtk_widget_info = {
++ { "GtkWidget", G_TYPE_OBJECT }, gtk_widget_get_type
++};
++
++sgtk_object_info sgtk_gtk_accel_group_info = {
++ { "GtkAccelGroup", G_TYPE_OBJECT }, gtk_accel_group_get_type
++};
++
++sgtk_object_info sgtk_gtk_style_info = {
++ { "GtkStyle", G_TYPE_OBJECT }, gtk_style_get_type
++};
++
++sgtk_object_info sgtk_gtk_rc_style_info = {
++ { "GtkRcStyle", G_TYPE_OBJECT }, gtk_rc_style_get_type
++};
++
++sgtk_object_info sgtk_gtk_object_info = {
++ { "GtkObject", G_TYPE_OBJECT }, gtk_object_get_type
++};
++
++sgtk_object_info sgtk_gtk_adjustment_info = {
++ { "GtkAdjustment", G_TYPE_OBJECT }, gtk_adjustment_get_type
++};
++
++sgtk_object_info sgtk_gtk_container_info = {
++ { "GtkContainer", G_TYPE_OBJECT }, gtk_container_get_type
++};
++
++sgtk_object_info sgtk_gtk_fixed_info = {
++ { "GtkFixed", G_TYPE_OBJECT }, gtk_fixed_get_type
++};
++
++sgtk_object_info sgtk_gtk_tree_item_info = {
++ { "GtkTreeItem", G_TYPE_OBJECT }, gtk_tree_item_get_type
++};
++
++sgtk_object_info sgtk_gtk_tree_info = {
++ { "GtkTree", G_TYPE_OBJECT }, gtk_tree_get_type
++};
++
++sgtk_object_info sgtk_gtk_clist_info = {
++ { "GtkCList", G_TYPE_OBJECT }, gtk_clist_get_type
++};
++
++sgtk_object_info sgtk_gtk_bin_info = {
++ { "GtkBin", G_TYPE_OBJECT }, gtk_bin_get_type
++};
++
++sgtk_object_info sgtk_gtk_event_box_info = {
++ { "GtkEventBox", G_TYPE_OBJECT }, gtk_event_box_get_type
++};
++
++sgtk_object_info sgtk_gtk_window_info = {
++ { "GtkWindow", G_TYPE_OBJECT }, gtk_window_get_type
++};
++
++sgtk_object_info sgtk_gtk_handle_box_info = {
++ { "GtkHandleBox", G_TYPE_OBJECT }, gtk_handle_box_get_type
++};
++
++sgtk_object_info sgtk_gtk_box_info = {
++ { "GtkBox", G_TYPE_OBJECT }, gtk_box_get_type
++};
++
++sgtk_object_info sgtk_gtk_button_box_info = {
++ { "GtkButtonBox", G_TYPE_OBJECT }, gtk_button_box_get_type
++};
++
++sgtk_object_info sgtk_gtk_hbutton_box_info = {
++ { "GtkHButtonBox", G_TYPE_OBJECT }, gtk_hbutton_box_get_type
++};
++
++sgtk_object_info sgtk_gtk_vbutton_box_info = {
++ { "GtkVButtonBox", G_TYPE_OBJECT }, gtk_vbutton_box_get_type
++};
++
++sgtk_object_info sgtk_gtk_toolbar_info = {
++ { "GtkToolbar", G_TYPE_OBJECT }, gtk_toolbar_get_type
++};
++
++sgtk_object_info sgtk_gtk_table_info = {
++ { "GtkTable", G_TYPE_OBJECT }, gtk_table_get_type
++};
++
++sgtk_object_info sgtk_gtk_button_info = {
++ { "GtkButton", G_TYPE_OBJECT }, gtk_button_get_type
++};
++
++sgtk_object_info sgtk_gtk_toggle_button_info = {
++ { "GtkToggleButton", G_TYPE_OBJECT }, gtk_toggle_button_get_type
++};
++
++sgtk_object_info sgtk_gtk_check_button_info = {
++ { "GtkCheckButton", G_TYPE_OBJECT }, gtk_check_button_get_type
++};
++
++sgtk_object_info sgtk_gtk_radio_button_info = {
++ { "GtkRadioButton", G_TYPE_OBJECT }, gtk_radio_button_get_type
++};
++
++sgtk_object_info sgtk_gtk_misc_info = {
++ { "GtkMisc", G_TYPE_OBJECT }, gtk_misc_get_type
++};
++
++sgtk_object_info sgtk_gtk_arrow_info = {
++ { "GtkArrow", G_TYPE_OBJECT }, gtk_arrow_get_type
++};
++
++sgtk_object_info sgtk_gtk_label_info = {
++ { "GtkLabel", G_TYPE_OBJECT }, gtk_label_get_type
++};
++
++sgtk_object_info sgtk_gtk_layout_info = {
++ { "GtkLayout", G_TYPE_OBJECT }, gtk_layout_get_type
++};
++
++sgtk_object_info sgtk_gtk_tips_query_info = {
++ { "GtkTipsQuery", G_TYPE_OBJECT }, gtk_tips_query_get_type
++};
++
++sgtk_object_info sgtk_gtk_vbox_info = {
++ { "GtkVBox", G_TYPE_OBJECT }, gtk_vbox_get_type
++};
++
++sgtk_object_info sgtk_gtk_hbox_info = {
++ { "GtkHBox", G_TYPE_OBJECT }, gtk_hbox_get_type
++};
++
++sgtk_object_info sgtk_gtk_item_info = {
++ { "GtkItem", G_TYPE_OBJECT }, gtk_item_get_type
++};
++
++sgtk_object_info sgtk_gtk_combo_info = {
++ { "GtkCombo", G_TYPE_OBJECT }, gtk_combo_get_type
++};
++
++sgtk_object_info sgtk_gtk_statusbar_info = {
++ { "GtkStatusbar", G_TYPE_OBJECT }, gtk_statusbar_get_type
++};
++
++sgtk_object_info sgtk_gtk_gamma_curve_info = {
++ { "GtkGammaCurve", G_TYPE_OBJECT }, gtk_gamma_curve_get_type
++};
++
++sgtk_object_info sgtk_gtk_separator_info = {
++ { "GtkSeparator", G_TYPE_OBJECT }, gtk_separator_get_type
++};
++
++sgtk_object_info sgtk_gtk_hseparator_info = {
++ { "GtkHSeparator", G_TYPE_OBJECT }, gtk_hseparator_get_type
++};
++
++sgtk_object_info sgtk_gtk_vseparator_info = {
++ { "GtkVSeparator", G_TYPE_OBJECT }, gtk_vseparator_get_type
++};
++
++sgtk_object_info sgtk_gtk_frame_info = {
++ { "GtkFrame", G_TYPE_OBJECT }, gtk_frame_get_type
++};
++
++sgtk_object_info sgtk_gtk_aspect_frame_info = {
++ { "GtkAspectFrame", G_TYPE_OBJECT }, gtk_aspect_frame_get_type
++};
++
++sgtk_object_info sgtk_gtk_progress_info = {
++ { "GtkProgress", G_TYPE_OBJECT }, gtk_progress_get_type
++};
++
++sgtk_object_info sgtk_gtk_progress_bar_info = {
++ { "GtkProgressBar", G_TYPE_OBJECT }, gtk_progress_bar_get_type
++};
++
++sgtk_object_info sgtk_gtk_tooltips_info = {
++ { "GtkTooltips", G_TYPE_OBJECT }, gtk_tooltips_get_type
++};
++
++sgtk_object_info sgtk_gtk_menu_shell_info = {
++ { "GtkMenuShell", G_TYPE_OBJECT }, gtk_menu_shell_get_type
++};
++
++sgtk_object_info sgtk_gtk_menu_bar_info = {
++ { "GtkMenuBar", G_TYPE_OBJECT }, gtk_menu_bar_get_type
++};
++
++sgtk_object_info sgtk_gtk_menu_info = {
++ { "GtkMenu", G_TYPE_OBJECT }, gtk_menu_get_type
++};
++
++sgtk_object_info sgtk_gtk_menu_item_info = {
++ { "GtkMenuItem", G_TYPE_OBJECT }, gtk_menu_item_get_type
++};
++
++sgtk_object_info sgtk_gtk_check_menu_item_info = {
++ { "GtkCheckMenuItem", G_TYPE_OBJECT }, gtk_check_menu_item_get_type
++};
++
++sgtk_object_info sgtk_gtk_radio_menu_item_info = {
++ { "GtkRadioMenuItem", G_TYPE_OBJECT }, gtk_radio_menu_item_get_type
++};
++
++sgtk_object_info sgtk_gtk_option_menu_info = {
++ { "GtkOptionMenu", G_TYPE_OBJECT }, gtk_option_menu_get_type
++};
++
++sgtk_object_info sgtk_gtk_pixmap_info = {
++ { "GtkPixmap", G_TYPE_OBJECT }, gtk_pixmap_get_type
++};
++
++sgtk_object_info sgtk_gtk_viewport_info = {
++ { "GtkViewport", G_TYPE_OBJECT }, gtk_viewport_get_type
++};
++
++sgtk_object_info sgtk_gtk_scrolled_window_info = {
++ { "GtkScrolledWindow", G_TYPE_OBJECT }, gtk_scrolled_window_get_type
++};
++
++sgtk_object_info sgtk_gtk_list_item_info = {
++ { "GtkListItem", G_TYPE_OBJECT }, gtk_list_item_get_type
++};
++
++sgtk_object_info sgtk_gtk_list_info = {
++ { "GtkList", G_TYPE_OBJECT }, gtk_list_get_type
++};
++
++sgtk_object_info sgtk_gtk_notebook_info = {
++ { "GtkNotebook", G_TYPE_OBJECT }, gtk_notebook_get_type
++};
++
++sgtk_object_info sgtk_gtk_editable_info = {
++ { "GtkEditable", G_TYPE_OBJECT }, gtk_editable_get_type
++};
++
++sgtk_object_info sgtk_gtk_entry_info = {
++ { "GtkEntry", G_TYPE_OBJECT }, gtk_entry_get_type
++};
++
++sgtk_object_info sgtk_gtk_spin_button_info = {
++ { "GtkSpinButton", G_TYPE_OBJECT }, gtk_spin_button_get_type
++};
++
++sgtk_object_info sgtk_gtk_alignment_info = {
++ { "GtkAlignment", G_TYPE_OBJECT }, gtk_alignment_get_type
++};
++
++sgtk_object_info sgtk_gtk_drawing_area_info = {
++ { "GtkDrawingArea", G_TYPE_OBJECT }, gtk_drawing_area_get_type
++};
++
++sgtk_object_info sgtk_gtk_curve_info = {
++ { "GtkCurve", G_TYPE_OBJECT }, gtk_curve_get_type
++};
++
++sgtk_object_info sgtk_gtk_preview_info = {
++ { "GtkPreview", G_TYPE_OBJECT }, gtk_preview_get_type
++};
++
++sgtk_object_info sgtk_gtk_file_selection_info = {
++ { "GtkFileSelection", G_TYPE_OBJECT }, gtk_file_selection_get_type
++};
++
++sgtk_object_info sgtk_gtk_font_selection_dialog_info = {
++ { "GtkFontSelectionDialog", G_TYPE_OBJECT }, gtk_font_selection_dialog_get_type
++};
++
++sgtk_object_info sgtk_gtk_color_selection_dialog_info = {
++ { "GtkColorSelectionDialog", G_TYPE_OBJECT }, gtk_color_selection_dialog_get_type
++};
++
++sgtk_object_info sgtk_gtk_color_selection_info = {
++ { "GtkColorSelection", G_TYPE_OBJECT }, gtk_color_selection_get_type
++};
++
++sgtk_object_info sgtk_gtk_range_info = {
++ { "GtkRange", G_TYPE_OBJECT }, gtk_range_get_type
++};
++
++sgtk_object_info sgtk_gtk_scale_info = {
++ { "GtkScale", G_TYPE_OBJECT }, gtk_scale_get_type
++};
++
++sgtk_object_info sgtk_gtk_hscale_info = {
++ { "GtkHScale", G_TYPE_OBJECT }, gtk_hscale_get_type
++};
++
++sgtk_object_info sgtk_gtk_vscale_info = {
++ { "GtkVScale", G_TYPE_OBJECT }, gtk_vscale_get_type
++};
++
++sgtk_object_info sgtk_gtk_scrollbar_info = {
++ { "GtkScrollbar", G_TYPE_OBJECT }, gtk_scrollbar_get_type
++};
++
++sgtk_object_info sgtk_gtk_hscrollbar_info = {
++ { "GtkHScrollbar", G_TYPE_OBJECT }, gtk_hscrollbar_get_type
++};
++
++sgtk_object_info sgtk_gtk_vscrollbar_info = {
++ { "GtkVScrollbar", G_TYPE_OBJECT }, gtk_vscrollbar_get_type
++};
++
++sgtk_object_info sgtk_gtk_ruler_info = {
++ { "GtkRuler", G_TYPE_OBJECT }, gtk_ruler_get_type
++};
++
++sgtk_object_info sgtk_gtk_hruler_info = {
++ { "GtkHRuler", G_TYPE_OBJECT }, gtk_hruler_get_type
++};
++
++sgtk_object_info sgtk_gtk_vruler_info = {
++ { "GtkVRuler", G_TYPE_OBJECT }, gtk_vruler_get_type
++};
++
++sgtk_object_info sgtk_gtk_dialog_info = {
++ { "GtkDialog", G_TYPE_OBJECT }, gtk_dialog_get_type
++};
++
++sgtk_object_info sgtk_gtk_input_dialog_info = {
++ { "GtkInputDialog", G_TYPE_OBJECT }, gtk_input_dialog_get_type
++};
++
++sgtk_object_info sgtk_gtk_paned_info = {
++ { "GtkPaned", G_TYPE_OBJECT }, gtk_paned_get_type
++};
++
++sgtk_object_info sgtk_gtk_hpaned_info = {
++ { "GtkHPaned", G_TYPE_OBJECT }, gtk_hpaned_get_type
++};
++
++sgtk_object_info sgtk_gtk_vpaned_info = {
++ { "GtkVPaned", G_TYPE_OBJECT }, gtk_vpaned_get_type
++};
++
++sgtk_object_info sgtk_gtk_plug_info = {
++ { "GtkPlug", G_TYPE_OBJECT }, gtk_plug_get_type
++};
++
++sgtk_object_info sgtk_gtk_socket_info = {
++ { "GtkSocket", G_TYPE_OBJECT }, gtk_socket_get_type
++};
++
++sgtk_object_info sgtk_gtk_tearoff_menu_item_info = {
++ { "GtkTearoffMenuItem", G_TYPE_OBJECT }, gtk_tearoff_menu_item_get_type
++};
++
++sgtk_object_info sgtk_gtk_calendar_info = {
++ { "GtkCalendar", G_TYPE_OBJECT }, gtk_calendar_get_type
++};
++
++sgtk_object_info sgtk_gtk_icon_factory_info = {
++ { "GtkIconFactory", G_TYPE_OBJECT }, gtk_icon_factory_get_type
++};
++
++sgtk_object_info sgtk_gtk_image_info = {
++ { "GtkImage", G_TYPE_OBJECT }, gtk_image_get_type
++};
++
++sgtk_object_info sgtk_gtk_image_menu_item_info = {
++ { "GtkImageMenuItem", G_TYPE_OBJECT }, gtk_image_menu_item_get_type
++};
++
++sgtk_object_info sgtk_gtk_invisible_info = {
++ { "GtkInvisible", G_TYPE_OBJECT }, gtk_invisible_get_type
++};
++
++sgtk_object_info sgtk_gtk_separator_menu_item_info = {
++ { "GtkSeparatorMenuItem", G_TYPE_OBJECT }, gtk_separator_menu_item_get_type
++};
++
++sgtk_object_info sgtk_gtk_text_buffer_info = {
++ { "GtkTextBuffer", G_TYPE_OBJECT }, gtk_text_buffer_get_type
++};
++
++sgtk_object_info sgtk_gtk_text_mark_info = {
++ { "GtkTextMark", G_TYPE_OBJECT }, gtk_text_mark_get_type
++};
++
++sgtk_object_info sgtk_gtk_text_tag_info = {
++ { "GtkTextTag", G_TYPE_OBJECT }, gtk_text_tag_get_type
++};
++
++sgtk_object_info sgtk_gtk_text_tag_table_info = {
++ { "GtkTextTagTable", G_TYPE_OBJECT }, gtk_text_tag_table_get_type
++};
++
++sgtk_object_info sgtk_gtk_text_view_info = {
++ { "GtkTextView", G_TYPE_OBJECT }, gtk_text_view_get_type
++};
++
++
++/* Defuns */
++
++DEFUN("gtk-style-get-white-interp", Fgtk_style_get_white_interp, Sgtk_style_get_white_interp, (repv p_style), rep_Subr1)
++{
++ repv pr_ret;
++ GtkStyle* c_style;
++ GdkColor* cr_ret;
++
++ rep_DECLARE (1, p_style, sgtk_is_a_gobj (gtk_style_get_type (), p_style));
++
++ c_style = (GtkStyle*) sgtk_get_gobj (p_style);
++
++ cr_ret = gtk_style_get_white_interp (c_style);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_color_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-style-fg-gc", Fgtk_style_fg_gc, Sgtk_style_fg_gc, (repv p_style, repv p_state), rep_Subr2)
++{
++ repv pr_ret;
++ GtkStyle* c_style;
++ GtkStateType c_state;
++ GdkGC* cr_ret;
++
++ rep_DECLARE (1, p_style, sgtk_is_a_gobj (gtk_style_get_type (), p_style));
++ rep_DECLARE (2, p_state, sgtk_valid_enum (p_state, &sgtk_gtk_state_type_info));
++
++ c_style = (GtkStyle*) sgtk_get_gobj (p_style);
++ c_state = (GtkStateType) sgtk_rep_to_enum (p_state, &sgtk_gtk_state_type_info);
++
++ cr_ret = gtk_style_fg_gc (c_style, c_state);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_gc_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-style-bg-gc", Fgtk_style_bg_gc, Sgtk_style_bg_gc, (repv p_style, repv p_state), rep_Subr2)
++{
++ repv pr_ret;
++ GtkStyle* c_style;
++ GtkStateType c_state;
++ GdkGC* cr_ret;
++
++ rep_DECLARE (1, p_style, sgtk_is_a_gobj (gtk_style_get_type (), p_style));
++ rep_DECLARE (2, p_state, sgtk_valid_enum (p_state, &sgtk_gtk_state_type_info));
++
++ c_style = (GtkStyle*) sgtk_get_gobj (p_style);
++ c_state = (GtkStateType) sgtk_rep_to_enum (p_state, &sgtk_gtk_state_type_info);
++
++ cr_ret = gtk_style_bg_gc (c_style, c_state);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_gc_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-set-locale", Fgtk_set_locale, Sgtk_set_locale, (void), rep_Subr0)
++{
++ repv pr_ret;
++ const char* cr_ret;
++
++ cr_ret = gtk_set_locale ();
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-events-pending", Fgtk_events_pending, Sgtk_events_pending, (void), rep_Subr0)
++{
++ repv pr_ret;
++ gint cr_ret;
++
++ cr_ret = gtk_events_pending ();
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-main", Fgtk_main, Sgtk_main, (void), rep_Subr0)
++{
++ gtk_main ();
++
++ return Qnil;
++}
++
++DEFUN("gtk-main-level", Fgtk_main_level, Sgtk_main_level, (void), rep_Subr0)
++{
++ repv pr_ret;
++ guint cr_ret;
++
++ cr_ret = gtk_main_level ();
++
++ pr_ret = sgtk_uint_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-main-quit", Fgtk_main_quit, Sgtk_main_quit, (void), rep_Subr0)
++{
++ gtk_main_quit ();
++
++ return Qnil;
++}
++
++DEFUN("gtk-main-iteration", Fgtk_main_iteration, Sgtk_main_iteration, (void), rep_Subr0)
++{
++ repv pr_ret;
++ int cr_ret;
++
++ cr_ret = gtk_main_iteration ();
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-main-iteration-do", Fgtk_main_iteration_do, Sgtk_main_iteration_do, (repv p_blocking), rep_Subr1)
++{
++ repv pr_ret;
++ int c_blocking;
++ int cr_ret;
++
++
++ c_blocking = sgtk_rep_to_bool (p_blocking);
++
++ cr_ret = gtk_main_iteration_do (c_blocking);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-true", Fgtk_true, Sgtk_true, (void), rep_Subr0)
++{
++ repv pr_ret;
++ int cr_ret;
++
++ cr_ret = gtk_true ();
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-false", Fgtk_false, Sgtk_false, (void), rep_Subr0)
++{
++ repv pr_ret;
++ int cr_ret;
++
++ cr_ret = gtk_false ();
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-grab-add", Fgtk_grab_add, Sgtk_grab_add, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_grab_add (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-grab-get-current", Fgtk_grab_get_current, Sgtk_grab_get_current, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_grab_get_current ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-grab-remove", Fgtk_grab_remove, Sgtk_grab_remove, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_grab_remove (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-quit-add", Fgtk_quit_add, Sgtk_quit_add, (repv p_main_level, repv p_function), rep_Subr2)
++{
++ repv pr_ret;
++ rep_GC_root gc_function;
++ guint c_main_level;
++ sgtk_protshell* c_function;
++ guint cr_ret;
++
++ rep_DECLARE (1, p_main_level, sgtk_valid_uint (p_main_level));
++ rep_DECLARE (2, p_function, sgtk_valid_function (p_function));
++
++ rep_PUSHGC (gc_function, p_function);
++ c_main_level = sgtk_rep_to_uint (p_main_level);
++ c_function = sgtk_protect (Qt, p_function);
++
++ cr_ret = gtk_quit_add_full (c_main_level, 0, sgtk_callback_marshal, (gpointer)c_function, sgtk_callback_destroy);
++
++ pr_ret = sgtk_uint_to_rep (cr_ret);
++ rep_POPGC;
++ return pr_ret;
++}
++
++DEFUN("gtk-quit-remove", Fgtk_quit_remove, Sgtk_quit_remove, (repv p_handler_id), rep_Subr1)
++{
++ guint c_handler_id;
++
++ rep_DECLARE (1, p_handler_id, sgtk_valid_uint (p_handler_id));
++
++ c_handler_id = sgtk_rep_to_uint (p_handler_id);
++
++ gtk_quit_remove (c_handler_id);
++
++ return Qnil;
++}
++
++DEFUN("gtk-timeout-add", Fgtk_timeout_add, Sgtk_timeout_add, (repv p_interval, repv p_function), rep_Subr2)
++{
++ repv pr_ret;
++ rep_GC_root gc_function;
++ gint c_interval;
++ sgtk_protshell* c_function;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_interval, sgtk_valid_int (p_interval));
++ rep_DECLARE (2, p_function, sgtk_valid_function (p_function));
++
++ rep_PUSHGC (gc_function, p_function);
++ c_interval = sgtk_rep_to_int (p_interval);
++ c_function = sgtk_protect (Qt, p_function);
++
++ cr_ret = gtk_timeout_add_full (c_interval, 0, sgtk_callback_marshal, (gpointer)c_function, sgtk_callback_destroy);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ rep_POPGC;
++ return pr_ret;
++}
++
++DEFUN("gtk-timeout-remove", Fgtk_timeout_remove, Sgtk_timeout_remove, (repv p_tag), rep_Subr1)
++{
++ gint c_tag;
++
++ rep_DECLARE (1, p_tag, sgtk_valid_int (p_tag));
++
++ c_tag = sgtk_rep_to_int (p_tag);
++
++ gtk_timeout_remove (c_tag);
++
++ return Qnil;
++}
++
++DEFUN("gtk-idle-add", Fgtk_idle_add, Sgtk_idle_add, (repv p_priority, repv p_function), rep_Subr2)
++{
++ repv pr_ret;
++ rep_GC_root gc_function;
++ gint c_priority;
++ sgtk_protshell* c_function;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_priority, sgtk_valid_int (p_priority));
++ rep_DECLARE (2, p_function, sgtk_valid_function (p_function));
++
++ rep_PUSHGC (gc_function, p_function);
++ c_priority = sgtk_rep_to_int (p_priority);
++ c_function = sgtk_protect (Qt, p_function);
++
++ cr_ret = gtk_idle_add_full (c_priority, 0, sgtk_callback_marshal, (gpointer)c_function, sgtk_callback_destroy);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ rep_POPGC;
++ return pr_ret;
++}
++
++DEFUN("gtk-idle-remove", Fgtk_idle_remove, Sgtk_idle_remove, (repv p_tag), rep_Subr1)
++{
++ gint c_tag;
++
++ rep_DECLARE (1, p_tag, sgtk_valid_int (p_tag));
++
++ c_tag = sgtk_rep_to_int (p_tag);
++
++ gtk_idle_remove (c_tag);
++
++ return Qnil;
++}
++
++DEFUN("gtk-input-add", Fgtk_input_add, Sgtk_input_add, (repv p_source, repv p_condition, repv p_callback), rep_Subr3)
++{
++ repv pr_ret;
++ rep_GC_root gc_callback;
++ int c_source;
++ GdkInputCondition c_condition;
++ sgtk_protshell* c_callback;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_source, sgtk_valid_fd (p_source));
++ rep_DECLARE (2, p_condition, sgtk_valid_flags (p_condition, &sgtk_gdk_input_condition_info));
++ rep_DECLARE (3, p_callback, sgtk_valid_function (p_callback));
++
++ rep_PUSHGC (gc_callback, p_callback);
++ c_source = sgtk_rep_to_fd (p_source);
++ c_condition = (GdkInputCondition) sgtk_rep_to_flags (p_condition, &sgtk_gdk_input_condition_info);
++ c_callback = sgtk_protect (Qt, p_callback);
++
++ cr_ret = gtk_input_add_full (c_source, c_condition, 0, sgtk_callback_marshal, (gpointer)c_callback, sgtk_callback_destroy);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ rep_POPGC;
++ return pr_ret;
++}
++
++DEFUN("gtk-input-remove", Fgtk_input_remove, Sgtk_input_remove, (repv p_tag), rep_Subr1)
++{
++ gint c_tag;
++
++ rep_DECLARE (1, p_tag, sgtk_valid_int (p_tag));
++
++ c_tag = sgtk_rep_to_int (p_tag);
++
++ gtk_input_remove (c_tag);
++
++ return Qnil;
++}
++
++DEFUN("gtk-get-current-event", Fgtk_get_current_event, Sgtk_get_current_event, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GdkEvent* cr_ret;
++
++ cr_ret = gtk_get_current_event ();
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_event_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-get-current-event-time", Fgtk_get_current_event_time, Sgtk_get_current_event_time, (void), rep_Subr0)
++{
++ repv pr_ret;
++ gulong cr_ret;
++
++ cr_ret = gtk_get_current_event_time ();
++
++ pr_ret = sgtk_ulong_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-rc-add-default-file", Fgtk_rc_add_default_file, Sgtk_rc_add_default_file, (repv p_filename), rep_Subr1)
++{
++ char* c_filename;
++
++ rep_DECLARE (1, p_filename, sgtk_valid_string (p_filename));
++
++ c_filename = sgtk_rep_to_string (p_filename);
++
++ gtk_rc_add_default_file (c_filename);
++
++ return Qnil;
++}
++
++DEFUN("gtk-rc-get-style", Fgtk_rc_get_style, Sgtk_rc_get_style, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GtkStyle* cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_rc_get_style (c_widget);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-rc-parse", Fgtk_rc_parse, Sgtk_rc_parse, (repv p_file), rep_Subr1)
++{
++ char* c_file;
++
++ rep_DECLARE (1, p_file, sgtk_valid_string (p_file));
++
++ c_file = sgtk_rep_to_string (p_file);
++
++ gtk_rc_parse (c_file);
++
++ return Qnil;
++}
++
++DEFUN("gtk-object-destroy", Fgtk_object_destroy, Sgtk_object_destroy, (repv p_object), rep_Subr1)
++{
++ GtkObject* c_object;
++
++ rep_DECLARE (1, p_object, sgtk_is_a_gobj (gtk_object_get_type (), p_object));
++
++ c_object = (GtkObject*) sgtk_get_gobj (p_object);
++
++ gtk_object_destroy (c_object);
++
++ return Qnil;
++}
++
++DEFUN("GTK-OBJECT-TYPE", FGTK_OBJECT_TYPE, SGTK_OBJECT_TYPE, (repv p_object), rep_Subr1)
++{
++ repv pr_ret;
++ GtkObject* c_object;
++ GtkType cr_ret;
++
++ rep_DECLARE (1, p_object, sgtk_is_a_gobj (gtk_object_get_type (), p_object));
++
++ c_object = (GtkObject*) sgtk_get_gobj (p_object);
++
++ cr_ret = GTK_OBJECT_TYPE (c_object);
++
++ pr_ret = sgtk_type_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("GTK-WIDGET-STATE", FGTK_WIDGET_STATE, SGTK_WIDGET_STATE, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GtkStateType cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = GTK_WIDGET_STATE (c_widget);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_state_type_info);
++ return pr_ret;
++}
++
++DEFUN("GTK-WIDGET-FLAGS", FGTK_WIDGET_FLAGS, SGTK_WIDGET_FLAGS, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GtkWidgetFlags cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = GTK_WIDGET_FLAGS (c_widget);
++
++ pr_ret = sgtk_flags_to_rep (cr_ret, &sgtk_gtk_widget_flags_info);
++ return pr_ret;
++}
++
++DEFUN("GTK-WIDGET-SET-FLAGS", FGTK_WIDGET_SET_FLAGS, SGTK_WIDGET_SET_FLAGS, (repv p_widget, repv p_flags), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GtkWidgetFlags c_flags;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_flags, sgtk_valid_flags (p_flags, &sgtk_gtk_widget_flags_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_flags = (GtkWidgetFlags) sgtk_rep_to_flags (p_flags, &sgtk_gtk_widget_flags_info);
++
++ GTK_WIDGET_SET_FLAGS (c_widget, c_flags);
++
++ return Qnil;
++}
++
++DEFUN("GTK-WIDGET-UNSET-FLAGS", FGTK_WIDGET_UNSET_FLAGS, SGTK_WIDGET_UNSET_FLAGS, (repv p_widget, repv p_flags), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GtkWidgetFlags c_flags;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_flags, sgtk_valid_flags (p_flags, &sgtk_gtk_widget_flags_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_flags = (GtkWidgetFlags) sgtk_rep_to_flags (p_flags, &sgtk_gtk_widget_flags_info);
++
++ GTK_WIDGET_UNSET_FLAGS (c_widget, c_flags);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-destroy", Fgtk_widget_destroy, Sgtk_widget_destroy, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_destroy (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-unparent", Fgtk_widget_unparent, Sgtk_widget_unparent, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_unparent (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-show", Fgtk_widget_show, Sgtk_widget_show, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_show (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-show-now", Fgtk_widget_show_now, Sgtk_widget_show_now, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_show_now (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-hide", Fgtk_widget_hide, Sgtk_widget_hide, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_hide (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-show-all", Fgtk_widget_show_all, Sgtk_widget_show_all, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_show_all (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-hide-all", Fgtk_widget_hide_all, Sgtk_widget_hide_all, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_hide_all (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-map", Fgtk_widget_map, Sgtk_widget_map, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_map (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-unmap", Fgtk_widget_unmap, Sgtk_widget_unmap, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_unmap (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-realize", Fgtk_widget_realize, Sgtk_widget_realize, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_realize (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-unrealize", Fgtk_widget_unrealize, Sgtk_widget_unrealize, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_unrealize (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-draw-interp", Fgtk_widget_draw_interp, Sgtk_widget_draw_interp, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_draw_interp (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-queue-draw", Fgtk_widget_queue_draw, Sgtk_widget_queue_draw, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_queue_draw (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-queue-draw-area", Fgtk_widget_queue_draw_area, Sgtk_widget_queue_draw_area, (repv p_widget, repv p_x, repv p_y, repv p_width, repv p_height), rep_Subr5)
++{
++ GtkWidget* c_widget;
++ gint c_x;
++ gint c_y;
++ gint c_width;
++ gint c_height;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_x, sgtk_valid_int (p_x));
++ rep_DECLARE (3, p_y, sgtk_valid_int (p_y));
++ rep_DECLARE (4, p_width, sgtk_valid_int (p_width));
++ rep_DECLARE (5, p_height, sgtk_valid_int (p_height));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_x = sgtk_rep_to_int (p_x);
++ c_y = sgtk_rep_to_int (p_y);
++ c_width = sgtk_rep_to_int (p_width);
++ c_height = sgtk_rep_to_int (p_height);
++
++ gtk_widget_queue_draw_area (c_widget, c_x, c_y, c_width, c_height);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-queue-resize", Fgtk_widget_queue_resize, Sgtk_widget_queue_resize, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_queue_resize (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-add-accelerator", Fgtk_widget_add_accelerator, Sgtk_widget_add_accelerator, (repv args), rep_SubrN)
++{
++ repv p_widget, p_accel_signal, p_accel_group, p_accel_key, p_accel_mods, p_accel_flags;
++
++ GtkWidget* c_widget;
++ char* c_accel_signal;
++ GtkAccelGroup* c_accel_group;
++ guint c_accel_key;
++ GdkModifierType c_accel_mods;
++ GtkAccelFlags c_accel_flags;
++
++ if (!rep_CONSP(args))
++ p_widget = Qnil;
++ else {
++ p_widget = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_accel_signal = Qnil;
++ else {
++ p_accel_signal = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_accel_group = Qnil;
++ else {
++ p_accel_group = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_accel_key = Qnil;
++ else {
++ p_accel_key = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_accel_mods = Qnil;
++ else {
++ p_accel_mods = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_accel_flags = Qnil;
++ else {
++ p_accel_flags = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_accel_signal, sgtk_valid_string (p_accel_signal));
++ rep_DECLARE (3, p_accel_group, sgtk_is_a_gobj (gtk_accel_group_get_type (), p_accel_group));
++ rep_DECLARE (4, p_accel_key, sgtk_valid_uint (p_accel_key));
++ rep_DECLARE (5, p_accel_mods, sgtk_valid_flags (p_accel_mods, &sgtk_gdk_modifier_type_info));
++ rep_DECLARE (6, p_accel_flags, sgtk_valid_flags (p_accel_flags, &sgtk_gtk_accel_flags_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_accel_signal = sgtk_rep_to_string (p_accel_signal);
++ c_accel_group = (GtkAccelGroup*) sgtk_get_gobj (p_accel_group);
++ c_accel_key = sgtk_rep_to_uint (p_accel_key);
++ c_accel_mods = (GdkModifierType) sgtk_rep_to_flags (p_accel_mods, &sgtk_gdk_modifier_type_info);
++ c_accel_flags = (GtkAccelFlags) sgtk_rep_to_flags (p_accel_flags, &sgtk_gtk_accel_flags_info);
++
++ gtk_widget_add_accelerator (c_widget, c_accel_signal, c_accel_group, c_accel_key, c_accel_mods, c_accel_flags);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-remove-accelerator", Fgtk_widget_remove_accelerator, Sgtk_widget_remove_accelerator, (repv p_widget, repv p_accel_group, repv p_accel_key, repv p_accel_mods), rep_Subr4)
++{
++ GtkWidget* c_widget;
++ GtkAccelGroup* c_accel_group;
++ guint c_accel_key;
++ GdkModifierType c_accel_mods;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_accel_group, sgtk_is_a_gobj (gtk_accel_group_get_type (), p_accel_group));
++ rep_DECLARE (3, p_accel_key, sgtk_valid_uint (p_accel_key));
++ rep_DECLARE (4, p_accel_mods, sgtk_valid_flags (p_accel_mods, &sgtk_gdk_modifier_type_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_accel_group = (GtkAccelGroup*) sgtk_get_gobj (p_accel_group);
++ c_accel_key = sgtk_rep_to_uint (p_accel_key);
++ c_accel_mods = (GdkModifierType) sgtk_rep_to_flags (p_accel_mods, &sgtk_gdk_modifier_type_info);
++
++ gtk_widget_remove_accelerator (c_widget, c_accel_group, c_accel_key, c_accel_mods);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-event", Fgtk_widget_event, Sgtk_widget_event, (repv p_widget, repv p_event), rep_Subr2)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GdkEvent* c_event;
++ int cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_event, sgtk_valid_boxed (p_event, &sgtk_gdk_event_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_event = (GdkEvent*) sgtk_rep_to_boxed (p_event);
++
++ cr_ret = gtk_widget_event (c_widget, c_event);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-activate", Fgtk_widget_activate, Sgtk_widget_activate, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_activate (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-scroll-adjustments", Fgtk_widget_set_scroll_adjustments, Sgtk_widget_set_scroll_adjustments, (repv p_widget, repv p_hadj, repv p_vadj), rep_Subr3)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GtkAdjustment* c_hadj;
++ GtkAdjustment* c_vadj;
++ int cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_hadj, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_hadj));
++ rep_DECLARE (3, p_vadj, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_vadj));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_hadj = (GtkAdjustment*) sgtk_get_gobj (p_hadj);
++ c_vadj = (GtkAdjustment*) sgtk_get_gobj (p_vadj);
++
++ cr_ret = gtk_widget_set_scroll_adjustments (c_widget, c_hadj, c_vadj);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-reparent", Fgtk_widget_reparent, Sgtk_widget_reparent, (repv p_widget, repv p_new_parent), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GtkWidget* c_new_parent;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_new_parent, sgtk_is_a_gobj (gtk_widget_get_type (), p_new_parent));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_new_parent = (GtkWidget*) sgtk_get_gobj (p_new_parent);
++
++ gtk_widget_reparent (c_widget, c_new_parent);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-is-focus", Fgtk_widget_is_focus, Sgtk_widget_is_focus, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ int cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_is_focus (c_widget);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-grab-focus", Fgtk_widget_grab_focus, Sgtk_widget_grab_focus, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_grab_focus (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-grab-default", Fgtk_widget_grab_default, Sgtk_widget_grab_default, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_grab_default (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-name", Fgtk_widget_set_name, Sgtk_widget_set_name, (repv p_widget, repv p_name), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ char* c_name;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_name, sgtk_valid_string (p_name));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_name = sgtk_rep_to_string (p_name);
++
++ gtk_widget_set_name (c_widget, c_name);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-get-name", Fgtk_widget_get_name, Sgtk_widget_get_name, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_name (c_widget);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-set-state", Fgtk_widget_set_state, Sgtk_widget_set_state, (repv p_widget, repv p_state), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GtkStateType c_state;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_state, sgtk_valid_enum (p_state, &sgtk_gtk_state_type_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_state = (GtkStateType) sgtk_rep_to_enum (p_state, &sgtk_gtk_state_type_info);
++
++ gtk_widget_set_state (c_widget, c_state);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-sensitive", Fgtk_widget_set_sensitive, Sgtk_widget_set_sensitive, (repv p_widget, repv p_sensitive), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ int c_sensitive;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_sensitive = sgtk_rep_to_bool (p_sensitive);
++
++ gtk_widget_set_sensitive (c_widget, c_sensitive);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-app-paintable", Fgtk_widget_set_app_paintable, Sgtk_widget_set_app_paintable, (repv p_widget, repv p_app_paintable), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ int c_app_paintable;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_app_paintable = sgtk_rep_to_bool (p_app_paintable);
++
++ gtk_widget_set_app_paintable (c_widget, c_app_paintable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-double-buffered", Fgtk_widget_set_double_buffered, Sgtk_widget_set_double_buffered, (repv p_widget, repv p_double_buffered), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ int c_double_buffered;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_double_buffered = sgtk_rep_to_bool (p_double_buffered);
++
++ gtk_widget_set_double_buffered (c_widget, c_double_buffered);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-redraw-on-allocate", Fgtk_widget_set_redraw_on_allocate, Sgtk_widget_set_redraw_on_allocate, (repv p_widget, repv p_redraw_on_allocate), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ int c_redraw_on_allocate;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_redraw_on_allocate = sgtk_rep_to_bool (p_redraw_on_allocate);
++
++ gtk_widget_set_redraw_on_allocate (c_widget, c_redraw_on_allocate);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-parent", Fgtk_widget_set_parent, Sgtk_widget_set_parent, (repv p_widget, repv p_parent), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GtkWidget* c_parent;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_parent, sgtk_is_a_gobj (gtk_widget_get_type (), p_parent));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_parent = (GtkWidget*) sgtk_get_gobj (p_parent);
++
++ gtk_widget_set_parent (c_widget, c_parent);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-parent-window", Fgtk_widget_set_parent_window, Sgtk_widget_set_parent_window, (repv p_widget, repv p_parent_window), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GdkWindow* c_parent_window;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_parent_window, sgtk_valid_boxed (p_parent_window, &sgtk_gdk_window_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_parent_window = (GdkWindow*) sgtk_rep_to_boxed (p_parent_window);
++
++ gtk_widget_set_parent_window (c_widget, c_parent_window);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-child-visible", Fgtk_widget_set_child_visible, Sgtk_widget_set_child_visible, (repv p_widget, repv p_child_visible), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ int c_child_visible;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_child_visible = sgtk_rep_to_bool (p_child_visible);
++
++ gtk_widget_set_child_visible (c_widget, c_child_visible);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-get-child-visible", Fgtk_widget_get_child_visible, Sgtk_widget_get_child_visible, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ int cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_child_visible (c_widget);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-get-parent", Fgtk_widget_get_parent, Sgtk_widget_get_parent, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_parent (c_widget);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-get-parent-window", Fgtk_widget_get_parent_window, Sgtk_widget_get_parent_window, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GdkWindow* cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_parent_window (c_widget);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_window_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-child-focus", Fgtk_widget_child_focus, Sgtk_widget_child_focus, (repv p_widget, repv p_direction), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GtkDirectionType c_direction;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_direction, sgtk_valid_enum (p_direction, &sgtk_gtk_direction_type_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_direction = (GtkDirectionType) sgtk_rep_to_enum (p_direction, &sgtk_gtk_direction_type_info);
++
++ gtk_widget_child_focus (c_widget, c_direction);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-size-request", Fgtk_widget_set_size_request, Sgtk_widget_set_size_request, (repv p_widget, repv p_width, repv p_height), rep_Subr3)
++{
++ GtkWidget* c_widget;
++ gint c_width;
++ gint c_height;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_width, sgtk_valid_int (p_width));
++ rep_DECLARE (3, p_height, sgtk_valid_int (p_height));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_width = sgtk_rep_to_int (p_width);
++ c_height = sgtk_rep_to_int (p_height);
++
++ gtk_widget_set_size_request (c_widget, c_width, c_height);
++
++ return Qnil;
++}
++
++/* helpers for int */
++static int
++_sgtk_helper_valid_int (repv obj)
++{
++ return obj == Qnil || (sgtk_valid_int (obj));
++}
++static void
++_sgtk_helper_fromrep_int (repv obj, void *mem)
++{
++ *(gint*)mem = sgtk_rep_to_int (obj);
++}
++static repv
++_sgtk_helper_torep_copy_int (void *mem)
++{
++ return sgtk_int_to_rep (*(gint*)mem);
++}
++static repv
++_sgtk_helper_torep_nocopy_int (void *mem)
++{
++ return sgtk_int_to_rep (*(gint*)mem);
++}
++
++DEFUN("gtk-widget-get-size-request", Fgtk_widget_get_size_request, Sgtk_widget_get_size_request, (repv p_widget, repv p_width, repv p_height), rep_Subr3)
++{
++ rep_GC_root gc_width;
++ rep_GC_root gc_height;
++ GtkWidget* c_widget;
++ sgtk_cvec c_width;
++ sgtk_cvec c_height;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_width, sgtk_valid_complen (p_width, NULL, 1));
++ rep_DECLARE (3, p_height, sgtk_valid_complen (p_height, NULL, 1));
++
++ rep_PUSHGC (gc_width, p_width);
++ rep_PUSHGC (gc_height, p_height);
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_width = sgtk_rep_to_cvec (p_width, 0, sizeof (gint));
++ c_height = sgtk_rep_to_cvec (p_height, 0, sizeof (gint));
++
++ gtk_widget_get_size_request (c_widget, (gint*) c_width.vec, (gint*) c_height.vec);
++
++ sgtk_cvec_finish (&c_width, p_width, _sgtk_helper_torep_nocopy_int, sizeof (gint));
++ sgtk_cvec_finish (&c_height, p_height, _sgtk_helper_torep_nocopy_int, sizeof (gint));
++ rep_POPGC;
++ rep_POPGC;
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-events", Fgtk_widget_set_events, Sgtk_widget_set_events, (repv p_widget, repv p_events), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GdkEventMask c_events;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_events, sgtk_valid_flags (p_events, &sgtk_gdk_event_mask_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_events = (GdkEventMask) sgtk_rep_to_flags (p_events, &sgtk_gdk_event_mask_info);
++
++ gtk_widget_set_events (c_widget, c_events);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-add-events", Fgtk_widget_add_events, Sgtk_widget_add_events, (repv p_widget, repv p_events), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GdkEventMask c_events;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_events, sgtk_valid_flags (p_events, &sgtk_gdk_event_mask_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_events = (GdkEventMask) sgtk_rep_to_flags (p_events, &sgtk_gdk_event_mask_info);
++
++ gtk_widget_add_events (c_widget, c_events);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-extension-events", Fgtk_widget_set_extension_events, Sgtk_widget_set_extension_events, (repv p_widget, repv p_events), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GdkEventMask c_events;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_events, sgtk_valid_flags (p_events, &sgtk_gdk_event_mask_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_events = (GdkEventMask) sgtk_rep_to_flags (p_events, &sgtk_gdk_event_mask_info);
++
++ gtk_widget_set_extension_events (c_widget, c_events);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-get-toplevel", Fgtk_widget_get_toplevel, Sgtk_widget_get_toplevel, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_toplevel (c_widget);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-get-colormap", Fgtk_widget_get_colormap, Sgtk_widget_get_colormap, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GdkColormap* cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_colormap (c_widget);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_colormap_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-get-visual", Fgtk_widget_get_visual, Sgtk_widget_get_visual, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GdkVisual* cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_visual (c_widget);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_visual_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-is-ancestor", Fgtk_widget_is_ancestor, Sgtk_widget_is_ancestor, (repv p_widget, repv p_ancestor), rep_Subr2)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GtkWidget* c_ancestor;
++ int cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_ancestor, sgtk_is_a_gobj (gtk_widget_get_type (), p_ancestor));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_ancestor = (GtkWidget*) sgtk_get_gobj (p_ancestor);
++
++ cr_ret = gtk_widget_is_ancestor (c_widget, c_ancestor);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-hide-on-delete", Fgtk_widget_hide_on_delete, Sgtk_widget_hide_on_delete, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ int cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_hide_on_delete (c_widget);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-set-style", Fgtk_widget_set_style, Sgtk_widget_set_style, (repv p_widget, repv p_style), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GtkStyle* c_style;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_style, sgtk_is_a_gobj (gtk_style_get_type (), p_style));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_style = (GtkStyle*) sgtk_get_gobj (p_style);
++
++ gtk_widget_set_style (c_widget, c_style);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-ensure-style", Fgtk_widget_ensure_style, Sgtk_widget_ensure_style, (repv p_widget), rep_Subr1)
++{
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_widget_ensure_style (c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-get-style", Fgtk_widget_get_style, Sgtk_widget_get_style, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GtkStyle* cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_style (c_widget);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-modify-style", Fgtk_widget_modify_style, Sgtk_widget_modify_style, (repv p_widget, repv p_style), rep_Subr2)
++{
++ GtkWidget* c_widget;
++ GtkRcStyle* c_style;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_style, sgtk_is_a_gobj (gtk_rc_style_get_type (), p_style));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_style = (GtkRcStyle*) sgtk_get_gobj (p_style);
++
++ gtk_widget_modify_style (c_widget, c_style);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-get-modifier-style", Fgtk_widget_get_modifier_style, Sgtk_widget_get_modifier_style, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GtkRcStyle* cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_modifier_style (c_widget);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-modify-fg", Fgtk_widget_modify_fg, Sgtk_widget_modify_fg, (repv p_widget, repv p_state, repv p_color), rep_Subr3)
++{
++ GtkWidget* c_widget;
++ GtkStateType c_state;
++ GdkColor* c_color;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_state, sgtk_valid_enum (p_state, &sgtk_gtk_state_type_info));
++ rep_DECLARE (3, p_color, sgtk_valid_boxed (p_color, &sgtk_gdk_color_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_state = (GtkStateType) sgtk_rep_to_enum (p_state, &sgtk_gtk_state_type_info);
++ c_color = (GdkColor*) sgtk_rep_to_boxed (p_color);
++
++ gtk_widget_modify_fg (c_widget, c_state, c_color);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-modify-bg", Fgtk_widget_modify_bg, Sgtk_widget_modify_bg, (repv p_widget, repv p_state, repv p_color), rep_Subr3)
++{
++ GtkWidget* c_widget;
++ GtkStateType c_state;
++ GdkColor* c_color;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_state, sgtk_valid_enum (p_state, &sgtk_gtk_state_type_info));
++ rep_DECLARE (3, p_color, sgtk_valid_boxed (p_color, &sgtk_gdk_color_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_state = (GtkStateType) sgtk_rep_to_enum (p_state, &sgtk_gtk_state_type_info);
++ c_color = (GdkColor*) sgtk_rep_to_boxed (p_color);
++
++ gtk_widget_modify_bg (c_widget, c_state, c_color);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-modify-text", Fgtk_widget_modify_text, Sgtk_widget_modify_text, (repv p_widget, repv p_state, repv p_color), rep_Subr3)
++{
++ GtkWidget* c_widget;
++ GtkStateType c_state;
++ GdkColor* c_color;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_state, sgtk_valid_enum (p_state, &sgtk_gtk_state_type_info));
++ rep_DECLARE (3, p_color, sgtk_valid_boxed (p_color, &sgtk_gdk_color_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_state = (GtkStateType) sgtk_rep_to_enum (p_state, &sgtk_gtk_state_type_info);
++ c_color = (GdkColor*) sgtk_rep_to_boxed (p_color);
++
++ gtk_widget_modify_text (c_widget, c_state, c_color);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-modify-base", Fgtk_widget_modify_base, Sgtk_widget_modify_base, (repv p_widget, repv p_state, repv p_color), rep_Subr3)
++{
++ GtkWidget* c_widget;
++ GtkStateType c_state;
++ GdkColor* c_color;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_state, sgtk_valid_enum (p_state, &sgtk_gtk_state_type_info));
++ rep_DECLARE (3, p_color, sgtk_valid_boxed (p_color, &sgtk_gdk_color_info));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_state = (GtkStateType) sgtk_rep_to_enum (p_state, &sgtk_gtk_state_type_info);
++ c_color = (GdkColor*) sgtk_rep_to_boxed (p_color);
++
++ gtk_widget_modify_base (c_widget, c_state, c_color);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-render-icon", Fgtk_widget_render_icon, Sgtk_widget_render_icon, (repv p_widget, repv p_stock_id, repv p_size, repv p_detail), rep_Subr4)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ char* c_stock_id;
++ GtkIconSize c_size;
++ char* c_detail;
++ GdkPixbuf* cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (2, p_stock_id, sgtk_valid_string (p_stock_id));
++ rep_DECLARE (3, p_size, sgtk_valid_enum (p_size, &sgtk_gtk_icon_size_info));
++ rep_DECLARE (4, p_detail, sgtk_valid_string (p_detail));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_stock_id = sgtk_rep_to_string (p_stock_id);
++ c_size = (GtkIconSize) sgtk_rep_to_enum (p_size, &sgtk_gtk_icon_size_info);
++ c_detail = sgtk_rep_to_string (p_detail);
++
++ cr_ret = gtk_widget_render_icon (c_widget, c_stock_id, c_size, c_detail);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_pixbuf_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-get-events", Fgtk_widget_get_events, Sgtk_widget_get_events, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GdkEventMask cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_events (c_widget);
++
++ pr_ret = sgtk_flags_to_rep (cr_ret, &sgtk_gdk_event_mask_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-get-extension-events", Fgtk_widget_get_extension_events, Sgtk_widget_get_extension_events, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_widget;
++ GdkEventMask cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_widget_get_extension_events (c_widget);
++
++ pr_ret = sgtk_flags_to_rep (cr_ret, &sgtk_gdk_event_mask_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-push-colormap", Fgtk_widget_push_colormap, Sgtk_widget_push_colormap, (repv p_cmap), rep_Subr1)
++{
++ GdkColormap* c_cmap;
++
++ rep_DECLARE (1, p_cmap, sgtk_valid_boxed (p_cmap, &sgtk_gdk_colormap_info));
++
++ c_cmap = (GdkColormap*) sgtk_rep_to_boxed (p_cmap);
++
++ gtk_widget_push_colormap (c_cmap);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-push-composite-child", Fgtk_widget_push_composite_child, Sgtk_widget_push_composite_child, (void), rep_Subr0)
++{
++ gtk_widget_push_composite_child ();
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-pop-colormap", Fgtk_widget_pop_colormap, Sgtk_widget_pop_colormap, (void), rep_Subr0)
++{
++ gtk_widget_pop_colormap ();
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-pop-composite-child", Fgtk_widget_pop_composite_child, Sgtk_widget_pop_composite_child, (void), rep_Subr0)
++{
++ gtk_widget_pop_composite_child ();
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-set-default-colormap", Fgtk_widget_set_default_colormap, Sgtk_widget_set_default_colormap, (repv p_cmap), rep_Subr1)
++{
++ GdkColormap* c_cmap;
++
++ rep_DECLARE (1, p_cmap, sgtk_valid_boxed (p_cmap, &sgtk_gdk_colormap_info));
++
++ c_cmap = (GdkColormap*) sgtk_rep_to_boxed (p_cmap);
++
++ gtk_widget_set_default_colormap (c_cmap);
++
++ return Qnil;
++}
++
++DEFUN("gtk-widget-get-default-colormap", Fgtk_widget_get_default_colormap, Sgtk_widget_get_default_colormap, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GdkColormap* cr_ret;
++
++ cr_ret = gtk_widget_get_default_colormap ();
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_colormap_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-get-default-visual", Fgtk_widget_get_default_visual, Sgtk_widget_get_default_visual, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GdkVisual* cr_ret;
++
++ cr_ret = gtk_widget_get_default_visual ();
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_visual_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-get-default-style", Fgtk_widget_get_default_style, Sgtk_widget_get_default_style, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkStyle* cr_ret;
++
++ cr_ret = gtk_widget_get_default_style ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-container-set-border-width", Fgtk_container_set_border_width, Sgtk_container_set_border_width, (repv p_container, repv p_border_width), rep_Subr2)
++{
++ GtkContainer* c_container;
++ gint c_border_width;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++ rep_DECLARE (2, p_border_width, sgtk_valid_int (p_border_width));
++
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++ c_border_width = sgtk_rep_to_int (p_border_width);
++
++ gtk_container_set_border_width (c_container, c_border_width);
++
++ return Qnil;
++}
++
++DEFUN("gtk-container-get-border-width", Fgtk_container_get_border_width, Sgtk_container_get_border_width, (repv p_container), rep_Subr1)
++{
++ repv pr_ret;
++ GtkContainer* c_container;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++
++ cr_ret = gtk_container_get_border_width (c_container);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-container-add", Fgtk_container_add, Sgtk_container_add, (repv p_container, repv p_widget), rep_Subr2)
++{
++ GtkContainer* c_container;
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++ rep_DECLARE (2, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_container_add (c_container, c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-container-remove", Fgtk_container_remove, Sgtk_container_remove, (repv p_container, repv p_widget), rep_Subr2)
++{
++ GtkContainer* c_container;
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++ rep_DECLARE (2, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_container_remove (c_container, c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-container-set-resize-mode", Fgtk_container_set_resize_mode, Sgtk_container_set_resize_mode, (repv p_container, repv p_resize_mode), rep_Subr2)
++{
++ GtkContainer* c_container;
++ GtkResizeMode c_resize_mode;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++ rep_DECLARE (2, p_resize_mode, sgtk_valid_enum (p_resize_mode, &sgtk_gtk_resize_mode_info));
++
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++ c_resize_mode = (GtkResizeMode) sgtk_rep_to_enum (p_resize_mode, &sgtk_gtk_resize_mode_info);
++
++ gtk_container_set_resize_mode (c_container, c_resize_mode);
++
++ return Qnil;
++}
++
++DEFUN("gtk-container-get-resize-mode", Fgtk_container_get_resize_mode, Sgtk_container_get_resize_mode, (repv p_container), rep_Subr1)
++{
++ repv pr_ret;
++ GtkContainer* c_container;
++ GtkResizeMode cr_ret;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++
++ cr_ret = gtk_container_get_resize_mode (c_container);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_resize_mode_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-container-check-resize", Fgtk_container_check_resize, Sgtk_container_check_resize, (repv p_container), rep_Subr1)
++{
++ GtkContainer* c_container;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++
++ gtk_container_check_resize (c_container);
++
++ return Qnil;
++}
++
++DEFUN("gtk-container-foreach", Fgtk_container_foreach, Sgtk_container_foreach, (repv p_container, repv p_function), rep_Subr2)
++{
++ rep_GC_root gc_function;
++ GtkContainer* c_container;
++ sgtk_protshell* c_function;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++ rep_DECLARE (2, p_function, sgtk_valid_function (p_function));
++
++ rep_PUSHGC (gc_function, p_function);
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++ c_function = sgtk_protect (Qt, p_function);
++
++ gtk_container_foreach_full (c_container, 0, sgtk_callback_marshal, (gpointer)c_function, sgtk_callback_destroy);
++
++ rep_POPGC;
++ return Qnil;
++}
++
++/* helpers for GtkWidget */
++static int
++_sgtk_helper_valid_GtkWidget (repv obj)
++{
++ return obj == Qnil || (sgtk_is_a_gobj (gtk_widget_get_type (), obj));
++}
++static void
++_sgtk_helper_fromrep_GtkWidget (repv obj, void *mem)
++{
++ *(GtkWidget**)mem = (GtkWidget*) sgtk_get_gobj (obj);
++}
++static repv
++_sgtk_helper_torep_copy_GtkWidget (void *mem)
++{
++ return sgtk_wrap_gobj ((GObject*) (*(GtkWidget**)mem));
++}
++static repv
++_sgtk_helper_torep_nocopy_GtkWidget (void *mem)
++{
++ return sgtk_wrap_gobj ((GObject*) (*(GtkWidget**)mem));
++}
++
++DEFUN("gtk-container-get-children", Fgtk_container_get_children, Sgtk_container_get_children, (repv p_container), rep_Subr1)
++{
++ repv pr_ret;
++ GtkContainer* c_container;
++ GList* cr_ret;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++
++ cr_ret = gtk_container_get_children (c_container);
++
++ pr_ret = sgtk_list_to_rep (cr_ret, _sgtk_helper_torep_copy_GtkWidget);
++ return pr_ret;
++}
++
++DEFUN("gtk-container-set-focus-chain", Fgtk_container_set_focus_chain, Sgtk_container_set_focus_chain, (repv p_container, repv p_focusable_widgets), rep_Subr2)
++{
++ rep_GC_root gc_focusable_widgets;
++ GtkContainer* c_container;
++ GList* c_focusable_widgets;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++ rep_DECLARE (2, p_focusable_widgets, sgtk_valid_composite (p_focusable_widgets, _sgtk_helper_valid_GtkWidget));
++
++ rep_PUSHGC (gc_focusable_widgets, p_focusable_widgets);
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++ c_focusable_widgets = sgtk_rep_to_list (p_focusable_widgets, _sgtk_helper_fromrep_GtkWidget);
++
++ gtk_container_set_focus_chain (c_container, c_focusable_widgets);
++
++ sgtk_list_finish (c_focusable_widgets, p_focusable_widgets, 0);
++ rep_POPGC;
++ return Qnil;
++}
++
++DEFUN("gtk-container-unset-focus-chain", Fgtk_container_unset_focus_chain, Sgtk_container_unset_focus_chain, (repv p_container), rep_Subr1)
++{
++ GtkContainer* c_container;
++
++ rep_DECLARE (1, p_container, sgtk_is_a_gobj (gtk_container_get_type (), p_container));
++
++ c_container = (GtkContainer*) sgtk_get_gobj (p_container);
++
++ gtk_container_unset_focus_chain (c_container);
++
++ return Qnil;
++}
++
++DEFUN("gtk-fixed-new", Fgtk_fixed_new, Sgtk_fixed_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_fixed_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-fixed-put", Fgtk_fixed_put, Sgtk_fixed_put, (repv p_fixed, repv p_widget, repv p_x, repv p_y), rep_Subr4)
++{
++ GtkFixed* c_fixed;
++ GtkWidget* c_widget;
++ gint c_x;
++ gint c_y;
++
++ rep_DECLARE (1, p_fixed, sgtk_is_a_gobj (gtk_fixed_get_type (), p_fixed));
++ rep_DECLARE (2, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (3, p_x, sgtk_valid_int (p_x));
++ rep_DECLARE (4, p_y, sgtk_valid_int (p_y));
++
++ c_fixed = (GtkFixed*) sgtk_get_gobj (p_fixed);
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_x = sgtk_rep_to_int (p_x);
++ c_y = sgtk_rep_to_int (p_y);
++
++ gtk_fixed_put (c_fixed, c_widget, c_x, c_y);
++
++ return Qnil;
++}
++
++DEFUN("gtk-fixed-move", Fgtk_fixed_move, Sgtk_fixed_move, (repv p_fixed, repv p_widget, repv p_x, repv p_y), rep_Subr4)
++{
++ GtkFixed* c_fixed;
++ GtkWidget* c_widget;
++ gint c_x;
++ gint c_y;
++
++ rep_DECLARE (1, p_fixed, sgtk_is_a_gobj (gtk_fixed_get_type (), p_fixed));
++ rep_DECLARE (2, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (3, p_x, sgtk_valid_int (p_x));
++ rep_DECLARE (4, p_y, sgtk_valid_int (p_y));
++
++ c_fixed = (GtkFixed*) sgtk_get_gobj (p_fixed);
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_x = sgtk_rep_to_int (p_x);
++ c_y = sgtk_rep_to_int (p_y);
++
++ gtk_fixed_move (c_fixed, c_widget, c_x, c_y);
++
++ return Qnil;
++}
++
++DEFUN("gtk-fixed-set-has-window", Fgtk_fixed_set_has_window, Sgtk_fixed_set_has_window, (repv p_fixed, repv p_has_window), rep_Subr2)
++{
++ GtkFixed* c_fixed;
++ int c_has_window;
++
++ rep_DECLARE (1, p_fixed, sgtk_is_a_gobj (gtk_fixed_get_type (), p_fixed));
++
++ c_fixed = (GtkFixed*) sgtk_get_gobj (p_fixed);
++ c_has_window = sgtk_rep_to_bool (p_has_window);
++
++ gtk_fixed_set_has_window (c_fixed, c_has_window);
++
++ return Qnil;
++}
++
++DEFUN("gtk-fixed-get-has-window", Fgtk_fixed_get_has_window, Sgtk_fixed_get_has_window, (repv p_fixed), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFixed* c_fixed;
++ int cr_ret;
++
++ rep_DECLARE (1, p_fixed, sgtk_is_a_gobj (gtk_fixed_get_type (), p_fixed));
++
++ c_fixed = (GtkFixed*) sgtk_get_gobj (p_fixed);
++
++ cr_ret = gtk_fixed_get_has_window (c_fixed);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-tree-item-new", Fgtk_tree_item_new, Sgtk_tree_item_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_tree_item_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-tree-item-new-with-label", Fgtk_tree_item_new_with_label, Sgtk_tree_item_new_with_label, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_tree_item_new_with_label (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-tree-item-set-subtree", Fgtk_tree_item_set_subtree, Sgtk_tree_item_set_subtree, (repv p_tree_item, repv p_subtree), rep_Subr2)
++{
++ GtkTreeItem* c_tree_item;
++ GtkWidget* c_subtree;
++
++ rep_DECLARE (1, p_tree_item, sgtk_is_a_gobj (gtk_tree_item_get_type (), p_tree_item));
++ rep_DECLARE (2, p_subtree, sgtk_is_a_gobj (gtk_widget_get_type (), p_subtree));
++
++ c_tree_item = (GtkTreeItem*) sgtk_get_gobj (p_tree_item);
++ c_subtree = (GtkWidget*) sgtk_get_gobj (p_subtree);
++
++ gtk_tree_item_set_subtree (c_tree_item, c_subtree);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-item-remove-subtree", Fgtk_tree_item_remove_subtree, Sgtk_tree_item_remove_subtree, (repv p_tree_item), rep_Subr1)
++{
++ GtkTreeItem* c_tree_item;
++
++ rep_DECLARE (1, p_tree_item, sgtk_is_a_gobj (gtk_tree_item_get_type (), p_tree_item));
++
++ c_tree_item = (GtkTreeItem*) sgtk_get_gobj (p_tree_item);
++
++ gtk_tree_item_remove_subtree (c_tree_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-item-select", Fgtk_tree_item_select, Sgtk_tree_item_select, (repv p_tree_item), rep_Subr1)
++{
++ GtkTreeItem* c_tree_item;
++
++ rep_DECLARE (1, p_tree_item, sgtk_is_a_gobj (gtk_tree_item_get_type (), p_tree_item));
++
++ c_tree_item = (GtkTreeItem*) sgtk_get_gobj (p_tree_item);
++
++ gtk_tree_item_select (c_tree_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-item-deselect", Fgtk_tree_item_deselect, Sgtk_tree_item_deselect, (repv p_tree_item), rep_Subr1)
++{
++ GtkTreeItem* c_tree_item;
++
++ rep_DECLARE (1, p_tree_item, sgtk_is_a_gobj (gtk_tree_item_get_type (), p_tree_item));
++
++ c_tree_item = (GtkTreeItem*) sgtk_get_gobj (p_tree_item);
++
++ gtk_tree_item_deselect (c_tree_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-item-expand", Fgtk_tree_item_expand, Sgtk_tree_item_expand, (repv p_tree_item), rep_Subr1)
++{
++ GtkTreeItem* c_tree_item;
++
++ rep_DECLARE (1, p_tree_item, sgtk_is_a_gobj (gtk_tree_item_get_type (), p_tree_item));
++
++ c_tree_item = (GtkTreeItem*) sgtk_get_gobj (p_tree_item);
++
++ gtk_tree_item_expand (c_tree_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-item-collapse", Fgtk_tree_item_collapse, Sgtk_tree_item_collapse, (repv p_tree_item), rep_Subr1)
++{
++ GtkTreeItem* c_tree_item;
++
++ rep_DECLARE (1, p_tree_item, sgtk_is_a_gobj (gtk_tree_item_get_type (), p_tree_item));
++
++ c_tree_item = (GtkTreeItem*) sgtk_get_gobj (p_tree_item);
++
++ gtk_tree_item_collapse (c_tree_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-new", Fgtk_tree_new, Sgtk_tree_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_tree_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-tree-append", Fgtk_tree_append, Sgtk_tree_append, (repv p_tree, repv p_child), rep_Subr2)
++{
++ GtkTree* c_tree;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_tree_append (c_tree, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-prepend", Fgtk_tree_prepend, Sgtk_tree_prepend, (repv p_tree, repv p_child), rep_Subr2)
++{
++ GtkTree* c_tree;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_tree_prepend (c_tree, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-insert", Fgtk_tree_insert, Sgtk_tree_insert, (repv p_tree, repv p_child, repv p_position), rep_Subr3)
++{
++ GtkTree* c_tree;
++ GtkWidget* c_child;
++ gint c_position;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_position, sgtk_valid_int (p_position));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_tree_insert (c_tree, c_child, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-remove-item", Fgtk_tree_remove_item, Sgtk_tree_remove_item, (repv p_tree, repv p_child), rep_Subr2)
++{
++ GtkTree* c_tree;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_tree_remove_item (c_tree, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-clear-items", Fgtk_tree_clear_items, Sgtk_tree_clear_items, (repv p_tree, repv p_start, repv p_end), rep_Subr3)
++{
++ GtkTree* c_tree;
++ gint c_start;
++ gint c_end;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_start, sgtk_valid_int (p_start));
++ rep_DECLARE (3, p_end, sgtk_valid_int (p_end));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_start = sgtk_rep_to_int (p_start);
++ c_end = sgtk_rep_to_int (p_end);
++
++ gtk_tree_clear_items (c_tree, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-select-item", Fgtk_tree_select_item, Sgtk_tree_select_item, (repv p_tree, repv p_item), rep_Subr2)
++{
++ GtkTree* c_tree;
++ gint c_item;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_item, sgtk_valid_int (p_item));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_item = sgtk_rep_to_int (p_item);
++
++ gtk_tree_select_item (c_tree, c_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-unselect-item", Fgtk_tree_unselect_item, Sgtk_tree_unselect_item, (repv p_tree, repv p_item), rep_Subr2)
++{
++ GtkTree* c_tree;
++ gint c_item;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_item, sgtk_valid_int (p_item));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_item = sgtk_rep_to_int (p_item);
++
++ gtk_tree_unselect_item (c_tree, c_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-select-child", Fgtk_tree_select_child, Sgtk_tree_select_child, (repv p_tree, repv p_child), rep_Subr2)
++{
++ GtkTree* c_tree;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_tree_select_child (c_tree, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-unselect-child", Fgtk_tree_unselect_child, Sgtk_tree_unselect_child, (repv p_tree, repv p_child), rep_Subr2)
++{
++ GtkTree* c_tree;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_tree_unselect_child (c_tree, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-child-position", Fgtk_tree_child_position, Sgtk_tree_child_position, (repv p_tree, repv p_child), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTree* c_tree;
++ GtkWidget* c_child;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ cr_ret = gtk_tree_child_position (c_tree, c_child);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-tree-set-selection-mode", Fgtk_tree_set_selection_mode, Sgtk_tree_set_selection_mode, (repv p_tree, repv p_mode), rep_Subr2)
++{
++ GtkTree* c_tree;
++ GtkSelectionMode c_mode;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++ rep_DECLARE (2, p_mode, sgtk_valid_enum (p_mode, &sgtk_gtk_selection_mode_info));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_mode = (GtkSelectionMode) sgtk_rep_to_enum (p_mode, &sgtk_gtk_selection_mode_info);
++
++ gtk_tree_set_selection_mode (c_tree, c_mode);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tree-set-view-lines", Fgtk_tree_set_view_lines, Sgtk_tree_set_view_lines, (repv p_tree, repv p_flag), rep_Subr2)
++{
++ GtkTree* c_tree;
++ int c_flag;
++
++ rep_DECLARE (1, p_tree, sgtk_is_a_gobj (gtk_tree_get_type (), p_tree));
++
++ c_tree = (GtkTree*) sgtk_get_gobj (p_tree);
++ c_flag = sgtk_rep_to_bool (p_flag);
++
++ gtk_tree_set_view_lines (c_tree, c_flag);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-new", Fgtk_clist_new, Sgtk_clist_new, (repv p_columns), rep_Subr1)
++{
++ repv pr_ret;
++ gint c_columns;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_columns, sgtk_valid_int (p_columns));
++
++ c_columns = sgtk_rep_to_int (p_columns);
++
++ cr_ret = gtk_clist_new (c_columns);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++/* helpers for string */
++static int
++_sgtk_helper_valid_string (repv obj)
++{
++ return obj == Qnil || (sgtk_valid_string (obj));
++}
++static void
++_sgtk_helper_fromrep_string (repv obj, void *mem)
++{
++ *(char**)mem = sgtk_rep_to_string (obj);
++}
++static repv
++_sgtk_helper_torep_copy_string (void *mem)
++{
++ return sgtk_string_to_rep (*(char**)mem);
++}
++static repv
++_sgtk_helper_torep_nocopy_string (void *mem)
++{
++ return sgtk_string_to_rep (*(char**)mem);
++}
++
++DEFUN("gtk-clist-new-with-titles", Fgtk_clist_new_with_titles, Sgtk_clist_new_with_titles, (repv p_titles), rep_Subr1)
++{
++ repv pr_ret;
++ rep_GC_root gc_titles;
++ sgtk_cvec c_titles;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_titles, sgtk_valid_composite (p_titles, _sgtk_helper_valid_string));
++
++ rep_PUSHGC (gc_titles, p_titles);
++ c_titles = sgtk_rep_to_cvec (p_titles, _sgtk_helper_fromrep_string, sizeof (char*));
++
++ cr_ret = gtk_clist_new_with_titles (c_titles.count, (char**) c_titles.vec);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ sgtk_cvec_finish (&c_titles, p_titles, 0, sizeof (char*));
++ rep_POPGC;
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-set-hadjustment", Fgtk_clist_set_hadjustment, Sgtk_clist_set_hadjustment, (repv p_clist, repv p_adjustment), rep_Subr2)
++{
++ GtkCList* c_clist;
++ GtkAdjustment* c_adjustment;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ gtk_clist_set_hadjustment (c_clist, c_adjustment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-vadjustment", Fgtk_clist_set_vadjustment, Sgtk_clist_set_vadjustment, (repv p_clist, repv p_adjustment), rep_Subr2)
++{
++ GtkCList* c_clist;
++ GtkAdjustment* c_adjustment;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ gtk_clist_set_vadjustment (c_clist, c_adjustment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-get-hadjustment", Fgtk_clist_get_hadjustment, Sgtk_clist_get_hadjustment, (repv p_clist), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCList* c_clist;
++ GtkAdjustment* cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ cr_ret = gtk_clist_get_hadjustment (c_clist);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-get-vadjustment", Fgtk_clist_get_vadjustment, Sgtk_clist_get_vadjustment, (repv p_clist), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCList* c_clist;
++ GtkAdjustment* cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ cr_ret = gtk_clist_get_vadjustment (c_clist);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-set-shadow-type", Fgtk_clist_set_shadow_type, Sgtk_clist_set_shadow_type, (repv p_clist, repv p_type), rep_Subr2)
++{
++ GtkCList* c_clist;
++ GtkShadowType c_type;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_shadow_type_info));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_type = (GtkShadowType) sgtk_rep_to_enum (p_type, &sgtk_gtk_shadow_type_info);
++
++ gtk_clist_set_shadow_type (c_clist, c_type);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-selection-mode", Fgtk_clist_set_selection_mode, Sgtk_clist_set_selection_mode, (repv p_clist, repv p_mode), rep_Subr2)
++{
++ GtkCList* c_clist;
++ GtkSelectionMode c_mode;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_mode, sgtk_valid_enum (p_mode, &sgtk_gtk_selection_mode_info));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_mode = (GtkSelectionMode) sgtk_rep_to_enum (p_mode, &sgtk_gtk_selection_mode_info);
++
++ gtk_clist_set_selection_mode (c_clist, c_mode);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-reorderable", Fgtk_clist_set_reorderable, Sgtk_clist_set_reorderable, (repv p_clist, repv p_reorderable), rep_Subr2)
++{
++ GtkCList* c_clist;
++ int c_reorderable;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_reorderable = sgtk_rep_to_bool (p_reorderable);
++
++ gtk_clist_set_reorderable (c_clist, c_reorderable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-use-drag-icons", Fgtk_clist_set_use_drag_icons, Sgtk_clist_set_use_drag_icons, (repv p_list, repv p_use_icons), rep_Subr2)
++{
++ GtkCList* c_list;
++ int c_use_icons;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_clist_get_type (), p_list));
++
++ c_list = (GtkCList*) sgtk_get_gobj (p_list);
++ c_use_icons = sgtk_rep_to_bool (p_use_icons);
++
++ gtk_clist_set_use_drag_icons (c_list, c_use_icons);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-button-actions", Fgtk_clist_set_button_actions, Sgtk_clist_set_button_actions, (repv p_list, repv p_button, repv p_button_actions), rep_Subr3)
++{
++ GtkCList* c_list;
++ guint c_button;
++ guint c_button_actions;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_clist_get_type (), p_list));
++ rep_DECLARE (2, p_button, sgtk_valid_uint (p_button));
++ rep_DECLARE (3, p_button_actions, sgtk_valid_uint (p_button_actions));
++
++ c_list = (GtkCList*) sgtk_get_gobj (p_list);
++ c_button = sgtk_rep_to_uint (p_button);
++ c_button_actions = sgtk_rep_to_uint (p_button_actions);
++
++ gtk_clist_set_button_actions (c_list, c_button, c_button_actions);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-freeze", Fgtk_clist_freeze, Sgtk_clist_freeze, (repv p_clist), rep_Subr1)
++{
++ GtkCList* c_clist;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ gtk_clist_freeze (c_clist);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-thaw", Fgtk_clist_thaw, Sgtk_clist_thaw, (repv p_clist), rep_Subr1)
++{
++ GtkCList* c_clist;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ gtk_clist_thaw (c_clist);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-column-titles-show", Fgtk_clist_column_titles_show, Sgtk_clist_column_titles_show, (repv p_clist), rep_Subr1)
++{
++ GtkCList* c_clist;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ gtk_clist_column_titles_show (c_clist);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-column-titles-hide", Fgtk_clist_column_titles_hide, Sgtk_clist_column_titles_hide, (repv p_clist), rep_Subr1)
++{
++ GtkCList* c_clist;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ gtk_clist_column_titles_hide (c_clist);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-column-title-active", Fgtk_clist_column_title_active, Sgtk_clist_column_title_active, (repv p_clist, repv p_column), rep_Subr2)
++{
++ GtkCList* c_clist;
++ gint c_column;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++
++ gtk_clist_column_title_active (c_clist, c_column);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-column-title-passive", Fgtk_clist_column_title_passive, Sgtk_clist_column_title_passive, (repv p_clist, repv p_column), rep_Subr2)
++{
++ GtkCList* c_clist;
++ gint c_column;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++
++ gtk_clist_column_title_passive (c_clist, c_column);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-column-titles-active", Fgtk_clist_column_titles_active, Sgtk_clist_column_titles_active, (repv p_clist), rep_Subr1)
++{
++ GtkCList* c_clist;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ gtk_clist_column_titles_active (c_clist);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-column-titles-passive", Fgtk_clist_column_titles_passive, Sgtk_clist_column_titles_passive, (repv p_clist), rep_Subr1)
++{
++ GtkCList* c_clist;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ gtk_clist_column_titles_passive (c_clist);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-column-title", Fgtk_clist_set_column_title, Sgtk_clist_set_column_title, (repv p_clist, repv p_column, repv p_title), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_column;
++ char* c_title;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++ rep_DECLARE (3, p_title, sgtk_valid_string (p_title));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++ c_title = sgtk_rep_to_string (p_title);
++
++ gtk_clist_set_column_title (c_clist, c_column, c_title);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-column-widget", Fgtk_clist_set_column_widget, Sgtk_clist_set_column_widget, (repv p_clist, repv p_column, repv p_widget), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_column;
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++ rep_DECLARE (3, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_clist_set_column_widget (c_clist, c_column, c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-get-column-widget", Fgtk_clist_get_column_widget, Sgtk_clist_get_column_widget, (repv p_clist, repv p_column), rep_Subr2)
++{
++ repv pr_ret;
++ GtkCList* c_clist;
++ gint c_column;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++
++ cr_ret = gtk_clist_get_column_widget (c_clist, c_column);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-set-column-justification", Fgtk_clist_set_column_justification, Sgtk_clist_set_column_justification, (repv p_clist, repv p_column, repv p_justification), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_column;
++ GtkJustification c_justification;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++ rep_DECLARE (3, p_justification, sgtk_valid_enum (p_justification, &sgtk_gtk_justification_info));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++ c_justification = (GtkJustification) sgtk_rep_to_enum (p_justification, &sgtk_gtk_justification_info);
++
++ gtk_clist_set_column_justification (c_clist, c_column, c_justification);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-column-visibility", Fgtk_clist_set_column_visibility, Sgtk_clist_set_column_visibility, (repv p_clist, repv p_column, repv p_visible), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_column;
++ int c_visible;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++ c_visible = sgtk_rep_to_bool (p_visible);
++
++ gtk_clist_set_column_visibility (c_clist, c_column, c_visible);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-column-resizeable", Fgtk_clist_set_column_resizeable, Sgtk_clist_set_column_resizeable, (repv p_clist, repv p_column, repv p_resizeable), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_column;
++ int c_resizeable;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++ c_resizeable = sgtk_rep_to_bool (p_resizeable);
++
++ gtk_clist_set_column_resizeable (c_clist, c_column, c_resizeable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-column-auto-resize", Fgtk_clist_set_column_auto_resize, Sgtk_clist_set_column_auto_resize, (repv p_clist, repv p_column, repv p_auto_resize), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_column;
++ int c_auto_resize;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++ c_auto_resize = sgtk_rep_to_bool (p_auto_resize);
++
++ gtk_clist_set_column_auto_resize (c_clist, c_column, c_auto_resize);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-columns-autosize", Fgtk_clist_columns_autosize, Sgtk_clist_columns_autosize, (repv p_clist), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCList* c_clist;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ cr_ret = gtk_clist_columns_autosize (c_clist);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-optimal-column-width", Fgtk_clist_optimal_column_width, Sgtk_clist_optimal_column_width, (repv p_clist, repv p_column), rep_Subr2)
++{
++ repv pr_ret;
++ GtkCList* c_clist;
++ gint c_column;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++
++ cr_ret = gtk_clist_optimal_column_width (c_clist, c_column);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-set-column-width", Fgtk_clist_set_column_width, Sgtk_clist_set_column_width, (repv p_clist, repv p_column, repv p_width), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_column;
++ gint c_width;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++ rep_DECLARE (3, p_width, sgtk_valid_int (p_width));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++ c_width = sgtk_rep_to_int (p_width);
++
++ gtk_clist_set_column_width (c_clist, c_column, c_width);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-column-min-width", Fgtk_clist_set_column_min_width, Sgtk_clist_set_column_min_width, (repv p_clist, repv p_column, repv p_min_width), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_column;
++ gint c_min_width;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++ rep_DECLARE (3, p_min_width, sgtk_valid_int (p_min_width));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++ c_min_width = sgtk_rep_to_int (p_min_width);
++
++ gtk_clist_set_column_min_width (c_clist, c_column, c_min_width);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-column-max-width", Fgtk_clist_set_column_max_width, Sgtk_clist_set_column_max_width, (repv p_clist, repv p_column, repv p_max_width), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_column;
++ gint c_max_width;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++ rep_DECLARE (3, p_max_width, sgtk_valid_int (p_max_width));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++ c_max_width = sgtk_rep_to_int (p_max_width);
++
++ gtk_clist_set_column_max_width (c_clist, c_column, c_max_width);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-row-height", Fgtk_clist_set_row_height, Sgtk_clist_set_row_height, (repv p_clist, repv p_height), rep_Subr2)
++{
++ GtkCList* c_clist;
++ gint c_height;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_height, sgtk_valid_int (p_height));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_height = sgtk_rep_to_int (p_height);
++
++ gtk_clist_set_row_height (c_clist, c_height);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-moveto", Fgtk_clist_moveto, Sgtk_clist_moveto, (repv p_clist, repv p_row, repv p_column, repv p_row_align, repv p_column_align), rep_Subr5)
++{
++ GtkCList* c_clist;
++ gint c_row;
++ gint c_column;
++ gfloat c_row_align;
++ gfloat c_column_align;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_column = sgtk_rep_to_int (p_column);
++ if (p_row_align == Qnil)
++ c_row_align = 0.5;
++ else
++ c_row_align = sgtk_rep_to_float (p_row_align);
++ if (p_column_align == Qnil)
++ c_column_align = 0.5;
++ else
++ c_column_align = sgtk_rep_to_float (p_column_align);
++
++ gtk_clist_moveto (c_clist, c_row, c_column, c_row_align, c_column_align);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-row-is-visible", Fgtk_clist_row_is_visible, Sgtk_clist_row_is_visible, (repv p_clist, repv p_row), rep_Subr2)
++{
++ repv pr_ret;
++ GtkCList* c_clist;
++ gint c_row;
++ GtkVisibility cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++
++ cr_ret = gtk_clist_row_is_visible (c_clist, c_row);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_visibility_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-get-cell-type", Fgtk_clist_get_cell_type, Sgtk_clist_get_cell_type, (repv p_clist, repv p_row, repv p_column), rep_Subr3)
++{
++ repv pr_ret;
++ GtkCList* c_clist;
++ gint c_row;
++ gint c_column;
++ GtkCellType cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_column = sgtk_rep_to_int (p_column);
++
++ cr_ret = gtk_clist_get_cell_type (c_clist, c_row, c_column);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_cell_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-set-text", Fgtk_clist_set_text, Sgtk_clist_set_text, (repv p_clist, repv p_row, repv p_column, repv p_text), rep_Subr4)
++{
++ GtkCList* c_clist;
++ gint c_row;
++ gint c_column;
++ char* c_text;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_column, sgtk_valid_int (p_column));
++ rep_DECLARE (4, p_text, sgtk_valid_string (p_text));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_column = sgtk_rep_to_int (p_column);
++ c_text = sgtk_rep_to_string (p_text);
++
++ gtk_clist_set_text (c_clist, c_row, c_column, c_text);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-get-text", Fgtk_clist_get_text, Sgtk_clist_get_text, (repv p_clist, repv p_row, repv p_column, repv p_text), rep_Subr4)
++{
++ repv pr_ret;
++ rep_GC_root gc_text;
++ GtkCList* c_clist;
++ gint c_row;
++ gint c_column;
++ sgtk_cvec c_text;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_column, sgtk_valid_int (p_column));
++ rep_DECLARE (4, p_text, sgtk_valid_complen (p_text, NULL, 1));
++
++ rep_PUSHGC (gc_text, p_text);
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_column = sgtk_rep_to_int (p_column);
++ c_text = sgtk_rep_to_cvec (p_text, 0, sizeof (char*));
++
++ cr_ret = gtk_clist_get_text (c_clist, c_row, c_column, (char**) c_text.vec);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ sgtk_cvec_finish (&c_text, p_text, _sgtk_helper_torep_nocopy_string, sizeof (char*));
++ rep_POPGC;
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-set-foreground", Fgtk_clist_set_foreground, Sgtk_clist_set_foreground, (repv p_clist, repv p_row, repv p_color), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_row;
++ GdkColor* c_color;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_color, sgtk_valid_boxed (p_color, &sgtk_gdk_color_info));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_color = (GdkColor*) sgtk_rep_to_boxed (p_color);
++
++ gtk_clist_set_foreground (c_clist, c_row, c_color);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-background", Fgtk_clist_set_background, Sgtk_clist_set_background, (repv p_clist, repv p_row, repv p_color), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_row;
++ GdkColor* c_color;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_color, sgtk_valid_boxed (p_color, &sgtk_gdk_color_info));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_color = (GdkColor*) sgtk_rep_to_boxed (p_color);
++
++ gtk_clist_set_background (c_clist, c_row, c_color);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-cell-style", Fgtk_clist_set_cell_style, Sgtk_clist_set_cell_style, (repv p_clist, repv p_row, repv p_column, repv p_style), rep_Subr4)
++{
++ GtkCList* c_clist;
++ gint c_row;
++ gint c_column;
++ GtkStyle* c_style;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_column, sgtk_valid_int (p_column));
++ rep_DECLARE (4, p_style, sgtk_is_a_gobj (gtk_style_get_type (), p_style));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_column = sgtk_rep_to_int (p_column);
++ c_style = (GtkStyle*) sgtk_get_gobj (p_style);
++
++ gtk_clist_set_cell_style (c_clist, c_row, c_column, c_style);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-get-cell-style", Fgtk_clist_get_cell_style, Sgtk_clist_get_cell_style, (repv p_clist, repv p_row, repv p_column), rep_Subr3)
++{
++ repv pr_ret;
++ GtkCList* c_clist;
++ gint c_row;
++ gint c_column;
++ GtkStyle* cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_column = sgtk_rep_to_int (p_column);
++
++ cr_ret = gtk_clist_get_cell_style (c_clist, c_row, c_column);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-set-row-style", Fgtk_clist_set_row_style, Sgtk_clist_set_row_style, (repv p_clist, repv p_row, repv p_style), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_row;
++ GtkStyle* c_style;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_style, sgtk_is_a_gobj (gtk_style_get_type (), p_style));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_style = (GtkStyle*) sgtk_get_gobj (p_style);
++
++ gtk_clist_set_row_style (c_clist, c_row, c_style);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-get-row-style", Fgtk_clist_get_row_style, Sgtk_clist_get_row_style, (repv p_clist, repv p_row), rep_Subr2)
++{
++ repv pr_ret;
++ GtkCList* c_clist;
++ gint c_row;
++ GtkStyle* cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++
++ cr_ret = gtk_clist_get_row_style (c_clist, c_row);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-set-shift", Fgtk_clist_set_shift, Sgtk_clist_set_shift, (repv p_clist, repv p_row, repv p_column, repv p_vertical, repv p_horizontal), rep_Subr5)
++{
++ GtkCList* c_clist;
++ gint c_row;
++ gint c_column;
++ gint c_vertical;
++ gint c_horizontal;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_column, sgtk_valid_int (p_column));
++ rep_DECLARE (4, p_vertical, sgtk_valid_int (p_vertical));
++ rep_DECLARE (5, p_horizontal, sgtk_valid_int (p_horizontal));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_column = sgtk_rep_to_int (p_column);
++ c_vertical = sgtk_rep_to_int (p_vertical);
++ c_horizontal = sgtk_rep_to_int (p_horizontal);
++
++ gtk_clist_set_shift (c_clist, c_row, c_column, c_vertical, c_horizontal);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-selectable", Fgtk_clist_set_selectable, Sgtk_clist_set_selectable, (repv p_clist, repv p_row, repv p_selectable), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_row;
++ int c_selectable;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_selectable = sgtk_rep_to_bool (p_selectable);
++
++ gtk_clist_set_selectable (c_clist, c_row, c_selectable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-get-selectable", Fgtk_clist_get_selectable, Sgtk_clist_get_selectable, (repv p_clist, repv p_row), rep_Subr2)
++{
++ repv pr_ret;
++ GtkCList* c_clist;
++ gint c_row;
++ int cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++
++ cr_ret = gtk_clist_get_selectable (c_clist, c_row);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-prepend", Fgtk_clist_prepend, Sgtk_clist_prepend, (repv p_clist, repv p_text), rep_Subr2)
++{
++ repv pr_ret;
++ rep_GC_root gc_text;
++ GtkCList* c_clist;
++ sgtk_cvec c_text;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_text, sgtk_valid_complen (p_text, _sgtk_helper_valid_string, ((GtkCList*)sgtk_get_gtkobj (p_clist))->columns));
++
++ rep_PUSHGC (gc_text, p_text);
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_text = sgtk_rep_to_cvec (p_text, _sgtk_helper_fromrep_string, sizeof (char*));
++
++ cr_ret = gtk_clist_prepend (c_clist, (char**) c_text.vec);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ sgtk_cvec_finish (&c_text, p_text, 0, sizeof (char*));
++ rep_POPGC;
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-append", Fgtk_clist_append, Sgtk_clist_append, (repv p_clist, repv p_text), rep_Subr2)
++{
++ repv pr_ret;
++ rep_GC_root gc_text;
++ GtkCList* c_clist;
++ sgtk_cvec c_text;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_text, sgtk_valid_complen (p_text, _sgtk_helper_valid_string, ((GtkCList*)sgtk_get_gtkobj (p_clist))->columns));
++
++ rep_PUSHGC (gc_text, p_text);
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_text = sgtk_rep_to_cvec (p_text, _sgtk_helper_fromrep_string, sizeof (char*));
++
++ cr_ret = gtk_clist_append (c_clist, (char**) c_text.vec);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ sgtk_cvec_finish (&c_text, p_text, 0, sizeof (char*));
++ rep_POPGC;
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-insert", Fgtk_clist_insert, Sgtk_clist_insert, (repv p_clist, repv p_row, repv p_text), rep_Subr3)
++{
++ repv pr_ret;
++ rep_GC_root gc_text;
++ GtkCList* c_clist;
++ gint c_row;
++ sgtk_cvec c_text;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++ rep_DECLARE (3, p_text, sgtk_valid_complen (p_text, _sgtk_helper_valid_string, ((GtkCList*)sgtk_get_gtkobj (p_clist))->columns));
++
++ rep_PUSHGC (gc_text, p_text);
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ c_text = sgtk_rep_to_cvec (p_text, _sgtk_helper_fromrep_string, sizeof (char*));
++
++ cr_ret = gtk_clist_insert (c_clist, c_row, (char**) c_text.vec);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ sgtk_cvec_finish (&c_text, p_text, 0, sizeof (char*));
++ rep_POPGC;
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-remove", Fgtk_clist_remove, Sgtk_clist_remove, (repv p_clist, repv p_row), rep_Subr2)
++{
++ GtkCList* c_clist;
++ gint c_row;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++
++ gtk_clist_remove (c_clist, c_row);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-select-row", Fgtk_clist_select_row, Sgtk_clist_select_row, (repv p_clist, repv p_row, repv p_column), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_row;
++ gint c_column;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ if (p_column == Qnil)
++ c_column = 0;
++ else
++ c_column = sgtk_rep_to_int (p_column);
++
++ gtk_clist_select_row (c_clist, c_row, c_column);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-unselect-row", Fgtk_clist_unselect_row, Sgtk_clist_unselect_row, (repv p_clist, repv p_row, repv p_column), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_row;
++ gint c_column;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row, sgtk_valid_int (p_row));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row = sgtk_rep_to_int (p_row);
++ if (p_column == Qnil)
++ c_column = 0;
++ else
++ c_column = sgtk_rep_to_int (p_column);
++
++ gtk_clist_unselect_row (c_clist, c_row, c_column);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-undo-selection", Fgtk_clist_undo_selection, Sgtk_clist_undo_selection, (repv p_clist), rep_Subr1)
++{
++ GtkCList* c_clist;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ gtk_clist_undo_selection (c_clist);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-clear", Fgtk_clist_clear, Sgtk_clist_clear, (repv p_clist), rep_Subr1)
++{
++ GtkCList* c_clist;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ gtk_clist_clear (c_clist);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-get-selection-info", Fgtk_clist_get_selection_info, Sgtk_clist_get_selection_info, (repv p_clist, repv p_x, repv p_y, repv p_row, repv p_column), rep_Subr5)
++{
++ repv pr_ret;
++ rep_GC_root gc_row;
++ rep_GC_root gc_column;
++ GtkCList* c_clist;
++ gint c_x;
++ gint c_y;
++ sgtk_cvec c_row;
++ sgtk_cvec c_column;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_x, sgtk_valid_int (p_x));
++ rep_DECLARE (3, p_y, sgtk_valid_int (p_y));
++ rep_DECLARE (4, p_row, sgtk_valid_complen (p_row, NULL, 1));
++ rep_DECLARE (5, p_column, sgtk_valid_complen (p_column, NULL, 1));
++
++ rep_PUSHGC (gc_row, p_row);
++ rep_PUSHGC (gc_column, p_column);
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_x = sgtk_rep_to_int (p_x);
++ c_y = sgtk_rep_to_int (p_y);
++ c_row = sgtk_rep_to_cvec (p_row, 0, sizeof (gint));
++ c_column = sgtk_rep_to_cvec (p_column, 0, sizeof (gint));
++
++ cr_ret = gtk_clist_get_selection_info (c_clist, c_x, c_y, (gint*) c_row.vec, (gint*) c_column.vec);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ sgtk_cvec_finish (&c_row, p_row, _sgtk_helper_torep_nocopy_int, sizeof (gint));
++ sgtk_cvec_finish (&c_column, p_column, _sgtk_helper_torep_nocopy_int, sizeof (gint));
++ rep_POPGC;
++ rep_POPGC;
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-unselect-all", Fgtk_clist_unselect_all, Sgtk_clist_unselect_all, (repv p_clist), rep_Subr1)
++{
++ GtkCList* c_clist;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ gtk_clist_unselect_all (c_clist);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-swap-rows", Fgtk_clist_swap_rows, Sgtk_clist_swap_rows, (repv p_clist, repv p_row1, repv p_row2), rep_Subr3)
++{
++ GtkCList* c_clist;
++ gint c_row1;
++ gint c_row2;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_row1, sgtk_valid_int (p_row1));
++ rep_DECLARE (3, p_row2, sgtk_valid_int (p_row2));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_row1 = sgtk_rep_to_int (p_row1);
++ c_row2 = sgtk_rep_to_int (p_row2);
++
++ gtk_clist_swap_rows (c_clist, c_row1, c_row2);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-sort-column", Fgtk_clist_set_sort_column, Sgtk_clist_set_sort_column, (repv p_clist, repv p_column), rep_Subr2)
++{
++ GtkCList* c_clist;
++ gint c_column;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_column, sgtk_valid_int (p_column));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_column = sgtk_rep_to_int (p_column);
++
++ gtk_clist_set_sort_column (c_clist, c_column);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-sort-type", Fgtk_clist_set_sort_type, Sgtk_clist_set_sort_type, (repv p_clist, repv p_sort_type), rep_Subr2)
++{
++ GtkCList* c_clist;
++ GtkSortType c_sort_type;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++ rep_DECLARE (2, p_sort_type, sgtk_valid_enum (p_sort_type, &sgtk_gtk_sort_type_info));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_sort_type = (GtkSortType) sgtk_rep_to_enum (p_sort_type, &sgtk_gtk_sort_type_info);
++
++ gtk_clist_set_sort_type (c_clist, c_sort_type);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-sort", Fgtk_clist_sort, Sgtk_clist_sort, (repv p_clist), rep_Subr1)
++{
++ GtkCList* c_clist;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++
++ gtk_clist_sort (c_clist);
++
++ return Qnil;
++}
++
++DEFUN("gtk-clist-set-auto-sort", Fgtk_clist_set_auto_sort, Sgtk_clist_set_auto_sort, (repv p_clist, repv p_auto_sort), rep_Subr2)
++{
++ GtkCList* c_clist;
++ int c_auto_sort;
++
++ rep_DECLARE (1, p_clist, sgtk_is_a_gobj (gtk_clist_get_type (), p_clist));
++
++ c_clist = (GtkCList*) sgtk_get_gobj (p_clist);
++ c_auto_sort = sgtk_rep_to_bool (p_auto_sort);
++
++ gtk_clist_set_auto_sort (c_clist, c_auto_sort);
++
++ return Qnil;
++}
++
++DEFUN("gtk-event-box-new", Fgtk_event_box_new, Sgtk_event_box_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_event_box_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-new", Fgtk_window_new, Sgtk_window_new, (repv p_type), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindowType c_type;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_window_type_info));
++
++ c_type = (GtkWindowType) sgtk_rep_to_enum (p_type, &sgtk_gtk_window_type_info);
++
++ cr_ret = gtk_window_new (c_type);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-set-title", Fgtk_window_set_title, Sgtk_window_set_title, (repv p_window, repv p_title), rep_Subr2)
++{
++ GtkWindow* c_window;
++ char* c_title;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_title, sgtk_valid_string (p_title));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_title = sgtk_rep_to_string (p_title);
++
++ gtk_window_set_title (c_window, c_title);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-get-title", Fgtk_window_get_title, Sgtk_window_get_title, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_get_title (c_window);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-set-wmclass", Fgtk_window_set_wmclass, Sgtk_window_set_wmclass, (repv p_window, repv p_wmclass_class, repv p_wmclass_name), rep_Subr3)
++{
++ GtkWindow* c_window;
++ char* c_wmclass_class;
++ char* c_wmclass_name;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_wmclass_class, sgtk_valid_string (p_wmclass_class));
++ rep_DECLARE (3, p_wmclass_name, sgtk_valid_string (p_wmclass_name));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_wmclass_class = sgtk_rep_to_string (p_wmclass_class);
++ c_wmclass_name = sgtk_rep_to_string (p_wmclass_name);
++
++ gtk_window_set_wmclass (c_window, c_wmclass_class, c_wmclass_name);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-set-role", Fgtk_window_set_role, Sgtk_window_set_role, (repv p_window, repv p_role), rep_Subr2)
++{
++ GtkWindow* c_window;
++ char* c_role;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_role, sgtk_valid_string (p_role));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_role = sgtk_rep_to_string (p_role);
++
++ gtk_window_set_role (c_window, c_role);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-get-role", Fgtk_window_get_role, Sgtk_window_get_role, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_get_role (c_window);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-add-accel-group", Fgtk_window_add_accel_group, Sgtk_window_add_accel_group, (repv p_window, repv p_accel_gruop), rep_Subr2)
++{
++ GtkWindow* c_window;
++ GtkAccelGroup* c_accel_gruop;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_accel_gruop, sgtk_is_a_gobj (gtk_accel_group_get_type (), p_accel_gruop));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_accel_gruop = (GtkAccelGroup*) sgtk_get_gobj (p_accel_gruop);
++
++ gtk_window_add_accel_group (c_window, c_accel_gruop);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-remove-accel-group", Fgtk_window_remove_accel_group, Sgtk_window_remove_accel_group, (repv p_window, repv p_accel_group), rep_Subr2)
++{
++ GtkWindow* c_window;
++ GtkAccelGroup* c_accel_group;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_accel_group, sgtk_is_a_gobj (gtk_accel_group_get_type (), p_accel_group));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_accel_group = (GtkAccelGroup*) sgtk_get_gobj (p_accel_group);
++
++ gtk_window_remove_accel_group (c_window, c_accel_group);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-set-position", Fgtk_window_set_position, Sgtk_window_set_position, (repv p_window, repv p_position), rep_Subr2)
++{
++ GtkWindow* c_window;
++ GtkWindowPosition c_position;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_position, sgtk_valid_enum (p_position, &sgtk_gtk_window_position_info));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_position = (GtkWindowPosition) sgtk_rep_to_enum (p_position, &sgtk_gtk_window_position_info);
++
++ gtk_window_set_position (c_window, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-set-default", Fgtk_window_set_default, Sgtk_window_set_default, (repv p_window, repv p_default), rep_Subr2)
++{
++ GtkWindow* c_window;
++ GtkWidget* c_default;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_default, sgtk_is_a_gobj (gtk_widget_get_type (), p_default));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_default = (GtkWidget*) sgtk_get_gobj (p_default);
++
++ gtk_window_set_default (c_window, c_default);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-activate-focus", Fgtk_window_activate_focus, Sgtk_window_activate_focus, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_activate_focus (c_window);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-activate-default", Fgtk_window_activate_default, Sgtk_window_activate_default, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_activate_default (c_window);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-set-transient-for", Fgtk_window_set_transient_for, Sgtk_window_set_transient_for, (repv p_window, repv p_parent), rep_Subr2)
++{
++ GtkWindow* c_window;
++ GtkWindow* c_parent;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ if (p_parent != Qnil)
++ rep_DECLARE (2, p_parent, sgtk_is_a_gobj (gtk_window_get_type (), p_parent));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ if (p_parent == Qnil)
++ c_parent = 0;
++ else
++ c_parent = (GtkWindow*) sgtk_get_gobj (p_parent);
++
++ gtk_window_set_transient_for (c_window, c_parent);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-get-transient-for", Fgtk_window_get_transient_for, Sgtk_window_get_transient_for, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ GtkWindow* cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_get_transient_for (c_window);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-set-destroy-with-parent", Fgtk_window_set_destroy_with_parent, Sgtk_window_set_destroy_with_parent, (repv p_window, repv p_setting), rep_Subr2)
++{
++ GtkWindow* c_window;
++ int c_setting;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_window_set_destroy_with_parent (c_window, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-get-destroy-with-parent", Fgtk_window_get_destroy_with_parent, Sgtk_window_get_destroy_with_parent, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ int cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_get_destroy_with_parent (c_window);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-set-resizable", Fgtk_window_set_resizable, Sgtk_window_set_resizable, (repv p_window, repv p_resizable), rep_Subr2)
++{
++ GtkWindow* c_window;
++ int c_resizable;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_resizable = sgtk_rep_to_bool (p_resizable);
++
++ gtk_window_set_resizable (c_window, c_resizable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-get-resizable", Fgtk_window_get_resizable, Sgtk_window_get_resizable, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ int cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_get_resizable (c_window);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-set-has-frame", Fgtk_window_set_has_frame, Sgtk_window_set_has_frame, (repv p_window, repv p_has_frame), rep_Subr2)
++{
++ GtkWindow* c_window;
++ int c_has_frame;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_has_frame = sgtk_rep_to_bool (p_has_frame);
++
++ gtk_window_set_has_frame (c_window, c_has_frame);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-get-has-frame", Fgtk_window_get_has_frame, Sgtk_window_get_has_frame, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ int cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_get_has_frame (c_window);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-set-frame-dimensions", Fgtk_window_set_frame_dimensions, Sgtk_window_set_frame_dimensions, (repv p_window, repv p_left, repv p_top, repv p_right, repv p_bottom), rep_Subr5)
++{
++ GtkWindow* c_window;
++ gint c_left;
++ gint c_top;
++ gint c_right;
++ gint c_bottom;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_left, sgtk_valid_int (p_left));
++ rep_DECLARE (3, p_top, sgtk_valid_int (p_top));
++ rep_DECLARE (4, p_right, sgtk_valid_int (p_right));
++ rep_DECLARE (5, p_bottom, sgtk_valid_int (p_bottom));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_left = sgtk_rep_to_int (p_left);
++ c_top = sgtk_rep_to_int (p_top);
++ c_right = sgtk_rep_to_int (p_right);
++ c_bottom = sgtk_rep_to_int (p_bottom);
++
++ gtk_window_set_frame_dimensions (c_window, c_left, c_top, c_right, c_bottom);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-set-decorated", Fgtk_window_set_decorated, Sgtk_window_set_decorated, (repv p_window, repv p_decorated), rep_Subr2)
++{
++ GtkWindow* c_window;
++ int c_decorated;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_decorated = sgtk_rep_to_bool (p_decorated);
++
++ gtk_window_set_decorated (c_window, c_decorated);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-get-decorated", Fgtk_window_get_decorated, Sgtk_window_get_decorated, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ int cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_get_decorated (c_window);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-set-modal", Fgtk_window_set_modal, Sgtk_window_set_modal, (repv p_window, repv p_modal), rep_Subr2)
++{
++ GtkWindow* c_window;
++ int c_modal;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_modal = sgtk_rep_to_bool (p_modal);
++
++ gtk_window_set_modal (c_window, c_modal);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-get-modal", Fgtk_window_get_modal, Sgtk_window_get_modal, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ int cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_get_modal (c_window);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++/* helpers for GtkWindow */
++static int
++_sgtk_helper_valid_GtkWindow (repv obj)
++{
++ return obj == Qnil || (sgtk_is_a_gobj (gtk_window_get_type (), obj));
++}
++static void
++_sgtk_helper_fromrep_GtkWindow (repv obj, void *mem)
++{
++ *(GtkWindow**)mem = (GtkWindow*) sgtk_get_gobj (obj);
++}
++static repv
++_sgtk_helper_torep_copy_GtkWindow (void *mem)
++{
++ return sgtk_wrap_gobj ((GObject*) (*(GtkWindow**)mem));
++}
++static repv
++_sgtk_helper_torep_nocopy_GtkWindow (void *mem)
++{
++ return sgtk_wrap_gobj ((GObject*) (*(GtkWindow**)mem));
++}
++
++DEFUN("gtk-window-list-toplevels", Fgtk_window_list_toplevels, Sgtk_window_list_toplevels, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GList* cr_ret;
++
++ cr_ret = gtk_window_list_toplevels ();
++
++ pr_ret = sgtk_list_to_rep (cr_ret, _sgtk_helper_torep_copy_GtkWindow);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-add-mnemonic", Fgtk_window_add_mnemonic, Sgtk_window_add_mnemonic, (repv p_window, repv p_keyval, repv p_target), rep_Subr3)
++{
++ GtkWindow* c_window;
++ guint c_keyval;
++ GtkWidget* c_target;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_keyval, sgtk_valid_uint (p_keyval));
++ rep_DECLARE (3, p_target, sgtk_is_a_gobj (gtk_widget_get_type (), p_target));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_keyval = sgtk_rep_to_uint (p_keyval);
++ c_target = (GtkWidget*) sgtk_get_gobj (p_target);
++
++ gtk_window_add_mnemonic (c_window, c_keyval, c_target);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-remove-mnemonic", Fgtk_window_remove_mnemonic, Sgtk_window_remove_mnemonic, (repv p_window, repv p_keyval, repv p_target), rep_Subr3)
++{
++ GtkWindow* c_window;
++ guint c_keyval;
++ GtkWidget* c_target;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_keyval, sgtk_valid_uint (p_keyval));
++ rep_DECLARE (3, p_target, sgtk_is_a_gobj (gtk_widget_get_type (), p_target));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_keyval = sgtk_rep_to_uint (p_keyval);
++ c_target = (GtkWidget*) sgtk_get_gobj (p_target);
++
++ gtk_window_remove_mnemonic (c_window, c_keyval, c_target);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-mnemonic-activate", Fgtk_window_mnemonic_activate, Sgtk_window_mnemonic_activate, (repv p_window, repv p_keyval, repv p_modifier), rep_Subr3)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ guint c_keyval;
++ GdkModifierType c_modifier;
++ int cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_keyval, sgtk_valid_uint (p_keyval));
++ rep_DECLARE (3, p_modifier, sgtk_valid_flags (p_modifier, &sgtk_gdk_modifier_type_info));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_keyval = sgtk_rep_to_uint (p_keyval);
++ c_modifier = (GdkModifierType) sgtk_rep_to_flags (p_modifier, &sgtk_gdk_modifier_type_info);
++
++ cr_ret = gtk_window_mnemonic_activate (c_window, c_keyval, c_modifier);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-set-mnemonic-modifier", Fgtk_window_set_mnemonic_modifier, Sgtk_window_set_mnemonic_modifier, (repv p_window, repv p_modifier), rep_Subr2)
++{
++ GtkWindow* c_window;
++ GdkModifierType c_modifier;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_modifier, sgtk_valid_flags (p_modifier, &sgtk_gdk_modifier_type_info));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_modifier = (GdkModifierType) sgtk_rep_to_flags (p_modifier, &sgtk_gdk_modifier_type_info);
++
++ gtk_window_set_mnemonic_modifier (c_window, c_modifier);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-get-mnemonic-modifier", Fgtk_window_get_mnemonic_modifier, Sgtk_window_get_mnemonic_modifier, (repv p_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ GdkModifierType cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ cr_ret = gtk_window_get_mnemonic_modifier (c_window);
++
++ pr_ret = sgtk_flags_to_rep (cr_ret, &sgtk_gdk_modifier_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-present", Fgtk_window_present, Sgtk_window_present, (repv p_window), rep_Subr1)
++{
++ GtkWindow* c_window;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ gtk_window_present (c_window);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-iconify", Fgtk_window_iconify, Sgtk_window_iconify, (repv p_window), rep_Subr1)
++{
++ GtkWindow* c_window;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ gtk_window_iconify (c_window);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-deiconify", Fgtk_window_deiconify, Sgtk_window_deiconify, (repv p_window), rep_Subr1)
++{
++ GtkWindow* c_window;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ gtk_window_deiconify (c_window);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-stick", Fgtk_window_stick, Sgtk_window_stick, (repv p_window), rep_Subr1)
++{
++ GtkWindow* c_window;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ gtk_window_stick (c_window);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-unstick", Fgtk_window_unstick, Sgtk_window_unstick, (repv p_window), rep_Subr1)
++{
++ GtkWindow* c_window;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ gtk_window_unstick (c_window);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-maximize", Fgtk_window_maximize, Sgtk_window_maximize, (repv p_window), rep_Subr1)
++{
++ GtkWindow* c_window;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ gtk_window_maximize (c_window);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-unmaximize", Fgtk_window_unmaximize, Sgtk_window_unmaximize, (repv p_window), rep_Subr1)
++{
++ GtkWindow* c_window;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++
++ gtk_window_unmaximize (c_window);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-set-default-size", Fgtk_window_set_default_size, Sgtk_window_set_default_size, (repv p_window, repv p_width, repv p_height), rep_Subr3)
++{
++ GtkWindow* c_window;
++ gint c_width;
++ gint c_height;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_width, sgtk_valid_int (p_width));
++ rep_DECLARE (3, p_height, sgtk_valid_int (p_height));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_width = sgtk_rep_to_int (p_width);
++ c_height = sgtk_rep_to_int (p_height);
++
++ gtk_window_set_default_size (c_window, c_width, c_height);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-resize", Fgtk_window_resize, Sgtk_window_resize, (repv p_window, repv p_width, repv p_height), rep_Subr3)
++{
++ GtkWindow* c_window;
++ gint c_width;
++ gint c_height;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_width, sgtk_valid_int (p_width));
++ rep_DECLARE (3, p_height, sgtk_valid_int (p_height));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_width = sgtk_rep_to_int (p_width);
++ c_height = sgtk_rep_to_int (p_height);
++
++ gtk_window_resize (c_window, c_width, c_height);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-move", Fgtk_window_move, Sgtk_window_move, (repv p_window, repv p_x, repv p_y), rep_Subr3)
++{
++ GtkWindow* c_window;
++ gint c_x;
++ gint c_y;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_x, sgtk_valid_int (p_x));
++ rep_DECLARE (3, p_y, sgtk_valid_int (p_y));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_x = sgtk_rep_to_int (p_x);
++ c_y = sgtk_rep_to_int (p_y);
++
++ gtk_window_move (c_window, c_x, c_y);
++
++ return Qnil;
++}
++
++DEFUN("gtk-window-parse-geometry", Fgtk_window_parse_geometry, Sgtk_window_parse_geometry, (repv p_window, repv p_geometry), rep_Subr2)
++{
++ repv pr_ret;
++ GtkWindow* c_window;
++ char* c_geometry;
++ int cr_ret;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_geometry, sgtk_valid_string (p_geometry));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_geometry = sgtk_rep_to_string (p_geometry);
++
++ cr_ret = gtk_window_parse_geometry (c_window, c_geometry);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-window-set-focus", Fgtk_window_set_focus, Sgtk_window_set_focus, (repv p_window, repv p_focus), rep_Subr2)
++{
++ GtkWindow* c_window;
++ GtkWidget* c_focus;
++
++ rep_DECLARE (1, p_window, sgtk_is_a_gobj (gtk_window_get_type (), p_window));
++ rep_DECLARE (2, p_focus, sgtk_is_a_gobj (gtk_widget_get_type (), p_focus));
++
++ c_window = (GtkWindow*) sgtk_get_gobj (p_window);
++ c_focus = (GtkWidget*) sgtk_get_gobj (p_focus);
++
++ _gtk_window_internal_set_focus (c_window, c_focus);
++
++ return Qnil;
++}
++
++DEFUN("gtk-handle-box-new", Fgtk_handle_box_new, Sgtk_handle_box_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_handle_box_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-handle-box-set-shadow-type", Fgtk_handle_box_set_shadow_type, Sgtk_handle_box_set_shadow_type, (repv p_handlebox, repv p_type), rep_Subr2)
++{
++ GtkHandleBox* c_handlebox;
++ GtkShadowType c_type;
++
++ rep_DECLARE (1, p_handlebox, sgtk_is_a_gobj (gtk_handle_box_get_type (), p_handlebox));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_shadow_type_info));
++
++ c_handlebox = (GtkHandleBox*) sgtk_get_gobj (p_handlebox);
++ c_type = (GtkShadowType) sgtk_rep_to_enum (p_type, &sgtk_gtk_shadow_type_info);
++
++ gtk_handle_box_set_shadow_type (c_handlebox, c_type);
++
++ return Qnil;
++}
++
++DEFUN("gtk-handle-box-get-shadow-type", Fgtk_handle_box_get_shadow_type, Sgtk_handle_box_get_shadow_type, (repv p_handlebox), rep_Subr1)
++{
++ repv pr_ret;
++ GtkHandleBox* c_handlebox;
++ GtkShadowType cr_ret;
++
++ rep_DECLARE (1, p_handlebox, sgtk_is_a_gobj (gtk_handle_box_get_type (), p_handlebox));
++
++ c_handlebox = (GtkHandleBox*) sgtk_get_gobj (p_handlebox);
++
++ cr_ret = gtk_handle_box_get_shadow_type (c_handlebox);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_shadow_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-handle-box-set-handle-position", Fgtk_handle_box_set_handle_position, Sgtk_handle_box_set_handle_position, (repv p_handlebox, repv p_position), rep_Subr2)
++{
++ GtkHandleBox* c_handlebox;
++ GtkPositionType c_position;
++
++ rep_DECLARE (1, p_handlebox, sgtk_is_a_gobj (gtk_handle_box_get_type (), p_handlebox));
++ rep_DECLARE (2, p_position, sgtk_valid_enum (p_position, &sgtk_gtk_position_type_info));
++
++ c_handlebox = (GtkHandleBox*) sgtk_get_gobj (p_handlebox);
++ c_position = (GtkPositionType) sgtk_rep_to_enum (p_position, &sgtk_gtk_position_type_info);
++
++ gtk_handle_box_set_handle_position (c_handlebox, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-handle-box-get-handle-position", Fgtk_handle_box_get_handle_position, Sgtk_handle_box_get_handle_position, (repv p_handlebox), rep_Subr1)
++{
++ repv pr_ret;
++ GtkHandleBox* c_handlebox;
++ GtkPositionType cr_ret;
++
++ rep_DECLARE (1, p_handlebox, sgtk_is_a_gobj (gtk_handle_box_get_type (), p_handlebox));
++
++ c_handlebox = (GtkHandleBox*) sgtk_get_gobj (p_handlebox);
++
++ cr_ret = gtk_handle_box_get_handle_position (c_handlebox);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_position_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-handle-box-set-snap-edge", Fgtk_handle_box_set_snap_edge, Sgtk_handle_box_set_snap_edge, (repv p_handlebox, repv p_edge), rep_Subr2)
++{
++ GtkHandleBox* c_handlebox;
++ GtkPositionType c_edge;
++
++ rep_DECLARE (1, p_handlebox, sgtk_is_a_gobj (gtk_handle_box_get_type (), p_handlebox));
++ rep_DECLARE (2, p_edge, sgtk_valid_enum (p_edge, &sgtk_gtk_position_type_info));
++
++ c_handlebox = (GtkHandleBox*) sgtk_get_gobj (p_handlebox);
++ c_edge = (GtkPositionType) sgtk_rep_to_enum (p_edge, &sgtk_gtk_position_type_info);
++
++ gtk_handle_box_set_snap_edge (c_handlebox, c_edge);
++
++ return Qnil;
++}
++
++DEFUN("gtk-handle-box-get-snap-edge", Fgtk_handle_box_get_snap_edge, Sgtk_handle_box_get_snap_edge, (repv p_handlebox), rep_Subr1)
++{
++ repv pr_ret;
++ GtkHandleBox* c_handlebox;
++ GtkPositionType cr_ret;
++
++ rep_DECLARE (1, p_handlebox, sgtk_is_a_gobj (gtk_handle_box_get_type (), p_handlebox));
++
++ c_handlebox = (GtkHandleBox*) sgtk_get_gobj (p_handlebox);
++
++ cr_ret = gtk_handle_box_get_snap_edge (c_handlebox);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_position_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-box-pack-start", Fgtk_box_pack_start, Sgtk_box_pack_start, (repv p_box, repv p_child, repv p_expand, repv p_fill, repv p_padding), rep_Subr5)
++{
++ GtkBox* c_box;
++ GtkWidget* c_child;
++ int c_expand;
++ int c_fill;
++ gint c_padding;
++
++ rep_DECLARE (1, p_box, sgtk_is_a_gobj (gtk_box_get_type (), p_box));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_box = (GtkBox*) sgtk_get_gobj (p_box);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_expand = sgtk_rep_to_bool (p_expand);
++ c_fill = sgtk_rep_to_bool (p_fill);
++ if (p_padding == Qnil)
++ c_padding = 0;
++ else
++ c_padding = sgtk_rep_to_int (p_padding);
++
++ gtk_box_pack_start (c_box, c_child, c_expand, c_fill, c_padding);
++
++ return Qnil;
++}
++
++DEFUN("gtk-box-pack-end", Fgtk_box_pack_end, Sgtk_box_pack_end, (repv p_box, repv p_child, repv p_expand, repv p_fill, repv p_padding), rep_Subr5)
++{
++ GtkBox* c_box;
++ GtkWidget* c_child;
++ int c_expand;
++ int c_fill;
++ gint c_padding;
++
++ rep_DECLARE (1, p_box, sgtk_is_a_gobj (gtk_box_get_type (), p_box));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_box = (GtkBox*) sgtk_get_gobj (p_box);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_expand = sgtk_rep_to_bool (p_expand);
++ c_fill = sgtk_rep_to_bool (p_fill);
++ if (p_padding == Qnil)
++ c_padding = 0;
++ else
++ c_padding = sgtk_rep_to_int (p_padding);
++
++ gtk_box_pack_end (c_box, c_child, c_expand, c_fill, c_padding);
++
++ return Qnil;
++}
++
++DEFUN("gtk-box-pack-start-defaults", Fgtk_box_pack_start_defaults, Sgtk_box_pack_start_defaults, (repv p_box, repv p_child), rep_Subr2)
++{
++ GtkBox* c_box;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_box, sgtk_is_a_gobj (gtk_box_get_type (), p_box));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_box = (GtkBox*) sgtk_get_gobj (p_box);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_box_pack_start_defaults (c_box, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-box-pack-end-defaults", Fgtk_box_pack_end_defaults, Sgtk_box_pack_end_defaults, (repv p_box, repv p_child), rep_Subr2)
++{
++ GtkBox* c_box;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_box, sgtk_is_a_gobj (gtk_box_get_type (), p_box));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_box = (GtkBox*) sgtk_get_gobj (p_box);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_box_pack_end_defaults (c_box, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-box-set-homogeneous", Fgtk_box_set_homogeneous, Sgtk_box_set_homogeneous, (repv p_box, repv p_homogenous), rep_Subr2)
++{
++ GtkBox* c_box;
++ int c_homogenous;
++
++ rep_DECLARE (1, p_box, sgtk_is_a_gobj (gtk_box_get_type (), p_box));
++
++ c_box = (GtkBox*) sgtk_get_gobj (p_box);
++ c_homogenous = sgtk_rep_to_bool (p_homogenous);
++
++ gtk_box_set_homogeneous (c_box, c_homogenous);
++
++ return Qnil;
++}
++
++DEFUN("gtk-box-get-homogeneous", Fgtk_box_get_homogeneous, Sgtk_box_get_homogeneous, (repv p_box), rep_Subr1)
++{
++ repv pr_ret;
++ GtkBox* c_box;
++ int cr_ret;
++
++ rep_DECLARE (1, p_box, sgtk_is_a_gobj (gtk_box_get_type (), p_box));
++
++ c_box = (GtkBox*) sgtk_get_gobj (p_box);
++
++ cr_ret = gtk_box_get_homogeneous (c_box);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-box-set-spacing", Fgtk_box_set_spacing, Sgtk_box_set_spacing, (repv p_box, repv p_spacing), rep_Subr2)
++{
++ GtkBox* c_box;
++ gint c_spacing;
++
++ rep_DECLARE (1, p_box, sgtk_is_a_gobj (gtk_box_get_type (), p_box));
++ rep_DECLARE (2, p_spacing, sgtk_valid_int (p_spacing));
++
++ c_box = (GtkBox*) sgtk_get_gobj (p_box);
++ c_spacing = sgtk_rep_to_int (p_spacing);
++
++ gtk_box_set_spacing (c_box, c_spacing);
++
++ return Qnil;
++}
++
++DEFUN("gtk-box-get-spacing", Fgtk_box_get_spacing, Sgtk_box_get_spacing, (repv p_box), rep_Subr1)
++{
++ repv pr_ret;
++ GtkBox* c_box;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_box, sgtk_is_a_gobj (gtk_box_get_type (), p_box));
++
++ c_box = (GtkBox*) sgtk_get_gobj (p_box);
++
++ cr_ret = gtk_box_get_spacing (c_box);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-box-reorder-child", Fgtk_box_reorder_child, Sgtk_box_reorder_child, (repv p_box, repv p_child, repv p_pos), rep_Subr3)
++{
++ GtkBox* c_box;
++ GtkWidget* c_child;
++ gint c_pos;
++
++ rep_DECLARE (1, p_box, sgtk_is_a_gobj (gtk_box_get_type (), p_box));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_pos, sgtk_valid_int (p_pos));
++
++ c_box = (GtkBox*) sgtk_get_gobj (p_box);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_pos = sgtk_rep_to_int (p_pos);
++
++ gtk_box_reorder_child (c_box, c_child, c_pos);
++
++ return Qnil;
++}
++
++DEFUN("gtk-box-set-child-packing", Fgtk_box_set_child_packing, Sgtk_box_set_child_packing, (repv args), rep_SubrN)
++{
++ repv p_box, p_child, p_expand, p_fill, p_padding, p_pack_type;
++
++ GtkBox* c_box;
++ GtkWidget* c_child;
++ int c_expand;
++ int c_fill;
++ gint c_padding;
++ GtkPackType c_pack_type;
++
++ if (!rep_CONSP(args))
++ p_box = Qnil;
++ else {
++ p_box = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_child = Qnil;
++ else {
++ p_child = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_expand = Qnil;
++ else {
++ p_expand = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_fill = Qnil;
++ else {
++ p_fill = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_padding = Qnil;
++ else {
++ p_padding = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_pack_type = Qnil;
++ else {
++ p_pack_type = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_box, sgtk_is_a_gobj (gtk_box_get_type (), p_box));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (5, p_padding, sgtk_valid_int (p_padding));
++ rep_DECLARE (6, p_pack_type, sgtk_valid_enum (p_pack_type, &sgtk_gtk_pack_type_info));
++
++ c_box = (GtkBox*) sgtk_get_gobj (p_box);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_expand = sgtk_rep_to_bool (p_expand);
++ c_fill = sgtk_rep_to_bool (p_fill);
++ c_padding = sgtk_rep_to_int (p_padding);
++ c_pack_type = (GtkPackType) sgtk_rep_to_enum (p_pack_type, &sgtk_gtk_pack_type_info);
++
++ gtk_box_set_child_packing (c_box, c_child, c_expand, c_fill, c_padding, c_pack_type);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-box-set-layout", Fgtk_button_box_set_layout, Sgtk_button_box_set_layout, (repv p_widget, repv p_layout_style), rep_Subr2)
++{
++ GtkButtonBox* c_widget;
++ GtkButtonBoxStyle c_layout_style;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_button_box_get_type (), p_widget));
++ rep_DECLARE (2, p_layout_style, sgtk_valid_enum (p_layout_style, &sgtk_gtk_button_box_style_info));
++
++ c_widget = (GtkButtonBox*) sgtk_get_gobj (p_widget);
++ c_layout_style = (GtkButtonBoxStyle) sgtk_rep_to_enum (p_layout_style, &sgtk_gtk_button_box_style_info);
++
++ gtk_button_box_set_layout (c_widget, c_layout_style);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-box-get-layout", Fgtk_button_box_get_layout, Sgtk_button_box_get_layout, (repv p_widget), rep_Subr1)
++{
++ repv pr_ret;
++ GtkButtonBox* c_widget;
++ GtkButtonBoxStyle cr_ret;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_button_box_get_type (), p_widget));
++
++ c_widget = (GtkButtonBox*) sgtk_get_gobj (p_widget);
++
++ cr_ret = gtk_button_box_get_layout (c_widget);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_button_box_style_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-box-set-child-secondary", Fgtk_button_box_set_child_secondary, Sgtk_button_box_set_child_secondary, (repv p_widget, repv p_child, repv p_is_secondary), rep_Subr3)
++{
++ GtkButtonBox* c_widget;
++ GtkWidget* c_child;
++ int c_is_secondary;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_button_box_get_type (), p_widget));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_widget = (GtkButtonBox*) sgtk_get_gobj (p_widget);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_is_secondary = sgtk_rep_to_bool (p_is_secondary);
++
++ gtk_button_box_set_child_secondary (c_widget, c_child, c_is_secondary);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-box-set-child-size", Fgtk_button_box_set_child_size, Sgtk_button_box_set_child_size, (repv p_widget, repv p_min_width, repv p_min_height), rep_Subr3)
++{
++ GtkButtonBox* c_widget;
++ gint c_min_width;
++ gint c_min_height;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_button_box_get_type (), p_widget));
++ rep_DECLARE (2, p_min_width, sgtk_valid_int (p_min_width));
++ rep_DECLARE (3, p_min_height, sgtk_valid_int (p_min_height));
++
++ c_widget = (GtkButtonBox*) sgtk_get_gobj (p_widget);
++ c_min_width = sgtk_rep_to_int (p_min_width);
++ c_min_height = sgtk_rep_to_int (p_min_height);
++
++ gtk_button_box_set_child_size (c_widget, c_min_width, c_min_height);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-box-set-child-ipadding", Fgtk_button_box_set_child_ipadding, Sgtk_button_box_set_child_ipadding, (repv p_widget, repv p_ipad_x, repv p_ipad_y), rep_Subr3)
++{
++ GtkButtonBox* c_widget;
++ gint c_ipad_x;
++ gint c_ipad_y;
++
++ rep_DECLARE (1, p_widget, sgtk_is_a_gobj (gtk_button_box_get_type (), p_widget));
++ rep_DECLARE (2, p_ipad_x, sgtk_valid_int (p_ipad_x));
++ rep_DECLARE (3, p_ipad_y, sgtk_valid_int (p_ipad_y));
++
++ c_widget = (GtkButtonBox*) sgtk_get_gobj (p_widget);
++ c_ipad_x = sgtk_rep_to_int (p_ipad_x);
++ c_ipad_y = sgtk_rep_to_int (p_ipad_y);
++
++ gtk_button_box_set_child_ipadding (c_widget, c_ipad_x, c_ipad_y);
++
++ return Qnil;
++}
++
++DEFUN("gtk-hbutton-box-new", Fgtk_hbutton_box_new, Sgtk_hbutton_box_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_hbutton_box_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-vbutton-box-new", Fgtk_vbutton_box_new, Sgtk_vbutton_box_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_vbutton_box_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-toolbar-new", Fgtk_toolbar_new, Sgtk_toolbar_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_toolbar_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-toolbar-append-space", Fgtk_toolbar_append_space, Sgtk_toolbar_append_space, (repv p_toolbar), rep_Subr1)
++{
++ GtkToolbar* c_toolbar;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++
++ gtk_toolbar_append_space (c_toolbar);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-prepend-space", Fgtk_toolbar_prepend_space, Sgtk_toolbar_prepend_space, (repv p_toolbar), rep_Subr1)
++{
++ GtkToolbar* c_toolbar;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++
++ gtk_toolbar_prepend_space (c_toolbar);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-insert-space", Fgtk_toolbar_insert_space, Sgtk_toolbar_insert_space, (repv p_toolbar, repv p_position), rep_Subr2)
++{
++ GtkToolbar* c_toolbar;
++ gint c_position;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++ rep_DECLARE (2, p_position, sgtk_valid_int (p_position));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_toolbar_insert_space (c_toolbar, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-remove-space", Fgtk_toolbar_remove_space, Sgtk_toolbar_remove_space, (repv p_toolbar, repv p_position), rep_Subr2)
++{
++ GtkToolbar* c_toolbar;
++ gint c_position;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++ rep_DECLARE (2, p_position, sgtk_valid_int (p_position));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_toolbar_remove_space (c_toolbar, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-append-widget", Fgtk_toolbar_append_widget, Sgtk_toolbar_append_widget, (repv p_Toolbar, repv p_Widget, repv p_tooltip_text, repv p_tooltip_private_text), rep_Subr4)
++{
++ GtkToolbar* c_Toolbar;
++ GtkWidget* c_Widget;
++ char* c_tooltip_text;
++ char* c_tooltip_private_text;
++
++ rep_DECLARE (1, p_Toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_Toolbar));
++ rep_DECLARE (2, p_Widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_Widget));
++ rep_DECLARE (3, p_tooltip_text, sgtk_valid_string (p_tooltip_text));
++ rep_DECLARE (4, p_tooltip_private_text, sgtk_valid_string (p_tooltip_private_text));
++
++ c_Toolbar = (GtkToolbar*) sgtk_get_gobj (p_Toolbar);
++ c_Widget = (GtkWidget*) sgtk_get_gobj (p_Widget);
++ c_tooltip_text = sgtk_rep_to_string (p_tooltip_text);
++ c_tooltip_private_text = sgtk_rep_to_string (p_tooltip_private_text);
++
++ gtk_toolbar_append_widget (c_Toolbar, c_Widget, c_tooltip_text, c_tooltip_private_text);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-prepend-widget", Fgtk_toolbar_prepend_widget, Sgtk_toolbar_prepend_widget, (repv p_Toolbar, repv p_Widget, repv p_tooltip_text, repv p_tooltip_private_text), rep_Subr4)
++{
++ GtkToolbar* c_Toolbar;
++ GtkWidget* c_Widget;
++ char* c_tooltip_text;
++ char* c_tooltip_private_text;
++
++ rep_DECLARE (1, p_Toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_Toolbar));
++ rep_DECLARE (2, p_Widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_Widget));
++ rep_DECLARE (3, p_tooltip_text, sgtk_valid_string (p_tooltip_text));
++ rep_DECLARE (4, p_tooltip_private_text, sgtk_valid_string (p_tooltip_private_text));
++
++ c_Toolbar = (GtkToolbar*) sgtk_get_gobj (p_Toolbar);
++ c_Widget = (GtkWidget*) sgtk_get_gobj (p_Widget);
++ c_tooltip_text = sgtk_rep_to_string (p_tooltip_text);
++ c_tooltip_private_text = sgtk_rep_to_string (p_tooltip_private_text);
++
++ gtk_toolbar_prepend_widget (c_Toolbar, c_Widget, c_tooltip_text, c_tooltip_private_text);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-insert-widget", Fgtk_toolbar_insert_widget, Sgtk_toolbar_insert_widget, (repv p_toolbar, repv p_widget, repv p_tooltip_text, repv p_tooltip_private_text, repv p_position), rep_Subr5)
++{
++ GtkToolbar* c_toolbar;
++ GtkWidget* c_widget;
++ char* c_tooltip_text;
++ char* c_tooltip_private_text;
++ gint c_position;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++ rep_DECLARE (2, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ rep_DECLARE (3, p_tooltip_text, sgtk_valid_string (p_tooltip_text));
++ rep_DECLARE (4, p_tooltip_private_text, sgtk_valid_string (p_tooltip_private_text));
++ rep_DECLARE (5, p_position, sgtk_valid_int (p_position));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ c_tooltip_text = sgtk_rep_to_string (p_tooltip_text);
++ c_tooltip_private_text = sgtk_rep_to_string (p_tooltip_private_text);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_toolbar_insert_widget (c_toolbar, c_widget, c_tooltip_text, c_tooltip_private_text, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-set-orientation", Fgtk_toolbar_set_orientation, Sgtk_toolbar_set_orientation, (repv p_toolbar, repv p_orientation), rep_Subr2)
++{
++ GtkToolbar* c_toolbar;
++ GtkOrientation c_orientation;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++ rep_DECLARE (2, p_orientation, sgtk_valid_enum (p_orientation, &sgtk_gtk_orientation_info));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++ c_orientation = (GtkOrientation) sgtk_rep_to_enum (p_orientation, &sgtk_gtk_orientation_info);
++
++ gtk_toolbar_set_orientation (c_toolbar, c_orientation);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-set-style", Fgtk_toolbar_set_style, Sgtk_toolbar_set_style, (repv p_toolbar, repv p_style), rep_Subr2)
++{
++ GtkToolbar* c_toolbar;
++ GtkToolbarStyle c_style;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++ rep_DECLARE (2, p_style, sgtk_valid_enum (p_style, &sgtk_gtk_toolbar_style_info));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++ c_style = (GtkToolbarStyle) sgtk_rep_to_enum (p_style, &sgtk_gtk_toolbar_style_info);
++
++ gtk_toolbar_set_style (c_toolbar, c_style);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-set-icon-size", Fgtk_toolbar_set_icon_size, Sgtk_toolbar_set_icon_size, (repv p_toolbar, repv p_size), rep_Subr2)
++{
++ GtkToolbar* c_toolbar;
++ GtkIconSize c_size;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++ rep_DECLARE (2, p_size, sgtk_valid_enum (p_size, &sgtk_gtk_icon_size_info));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++ c_size = (GtkIconSize) sgtk_rep_to_enum (p_size, &sgtk_gtk_icon_size_info);
++
++ gtk_toolbar_set_icon_size (c_toolbar, c_size);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-set-tooltips", Fgtk_toolbar_set_tooltips, Sgtk_toolbar_set_tooltips, (repv p_toolbar, repv p_enable), rep_Subr2)
++{
++ GtkToolbar* c_toolbar;
++ int c_enable;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++ c_enable = sgtk_rep_to_bool (p_enable);
++
++ gtk_toolbar_set_tooltips (c_toolbar, c_enable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-unset-style", Fgtk_toolbar_unset_style, Sgtk_toolbar_unset_style, (repv p_toolbar), rep_Subr1)
++{
++ GtkToolbar* c_toolbar;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++
++ gtk_toolbar_unset_style (c_toolbar);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-unset-icon-size", Fgtk_toolbar_unset_icon_size, Sgtk_toolbar_unset_icon_size, (repv p_toolbar), rep_Subr1)
++{
++ GtkToolbar* c_toolbar;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++
++ gtk_toolbar_unset_icon_size (c_toolbar);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toolbar-get-orientation", Fgtk_toolbar_get_orientation, Sgtk_toolbar_get_orientation, (repv p_toolbar), rep_Subr1)
++{
++ repv pr_ret;
++ GtkToolbar* c_toolbar;
++ GtkOrientation cr_ret;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++
++ cr_ret = gtk_toolbar_get_orientation (c_toolbar);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_orientation_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-toolbar-get-style", Fgtk_toolbar_get_style, Sgtk_toolbar_get_style, (repv p_toolbar), rep_Subr1)
++{
++ repv pr_ret;
++ GtkToolbar* c_toolbar;
++ GtkToolbarStyle cr_ret;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++
++ cr_ret = gtk_toolbar_get_style (c_toolbar);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_toolbar_style_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-toolbar-get-icon-size", Fgtk_toolbar_get_icon_size, Sgtk_toolbar_get_icon_size, (repv p_toolbar), rep_Subr1)
++{
++ repv pr_ret;
++ GtkToolbar* c_toolbar;
++ GtkIconSize cr_ret;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++
++ cr_ret = gtk_toolbar_get_icon_size (c_toolbar);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_icon_size_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-toolbar-get-tooltips", Fgtk_toolbar_get_tooltips, Sgtk_toolbar_get_tooltips, (repv p_toolbar), rep_Subr1)
++{
++ repv pr_ret;
++ GtkToolbar* c_toolbar;
++ int cr_ret;
++
++ rep_DECLARE (1, p_toolbar, sgtk_is_a_gobj (gtk_toolbar_get_type (), p_toolbar));
++
++ c_toolbar = (GtkToolbar*) sgtk_get_gobj (p_toolbar);
++
++ cr_ret = gtk_toolbar_get_tooltips (c_toolbar);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-table-new", Fgtk_table_new, Sgtk_table_new, (repv p_rows, repv p_columns, repv p_homogenous), rep_Subr3)
++{
++ repv pr_ret;
++ guint c_rows;
++ guint c_columns;
++ int c_homogenous;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_rows, sgtk_valid_uint (p_rows));
++ rep_DECLARE (2, p_columns, sgtk_valid_uint (p_columns));
++
++ c_rows = sgtk_rep_to_uint (p_rows);
++ c_columns = sgtk_rep_to_uint (p_columns);
++ c_homogenous = sgtk_rep_to_bool (p_homogenous);
++
++ cr_ret = gtk_table_new (c_rows, c_columns, c_homogenous);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-table-resize", Fgtk_table_resize, Sgtk_table_resize, (repv p_table, repv p_rows, repv p_columns), rep_Subr3)
++{
++ GtkTable* c_table;
++ guint c_rows;
++ guint c_columns;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++ rep_DECLARE (2, p_rows, sgtk_valid_uint (p_rows));
++ rep_DECLARE (3, p_columns, sgtk_valid_uint (p_columns));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++ c_rows = sgtk_rep_to_uint (p_rows);
++ c_columns = sgtk_rep_to_uint (p_columns);
++
++ gtk_table_resize (c_table, c_rows, c_columns);
++
++ return Qnil;
++}
++
++DEFUN("gtk-table-attach", Fgtk_table_attach, Sgtk_table_attach, (repv args), rep_SubrN)
++{
++ repv p_table, p_child, p_left_attach, p_right_attach, p_top_attach, p_bottom_attach, p_xoptions, p_yoptions, p_xpadding, p_ypadding;
++
++ GtkTable* c_table;
++ GtkWidget* c_child;
++ guint c_left_attach;
++ guint c_right_attach;
++ guint c_top_attach;
++ guint c_bottom_attach;
++ GtkAttachOptions c_xoptions;
++ GtkAttachOptions c_yoptions;
++ guint c_xpadding;
++ guint c_ypadding;
++
++ if (!rep_CONSP(args))
++ p_table = Qnil;
++ else {
++ p_table = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_child = Qnil;
++ else {
++ p_child = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_left_attach = Qnil;
++ else {
++ p_left_attach = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_right_attach = Qnil;
++ else {
++ p_right_attach = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_top_attach = Qnil;
++ else {
++ p_top_attach = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_bottom_attach = Qnil;
++ else {
++ p_bottom_attach = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_xoptions = Qnil;
++ else {
++ p_xoptions = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_yoptions = Qnil;
++ else {
++ p_yoptions = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_xpadding = Qnil;
++ else {
++ p_xpadding = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_ypadding = Qnil;
++ else {
++ p_ypadding = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_left_attach, sgtk_valid_uint (p_left_attach));
++ rep_DECLARE (4, p_right_attach, sgtk_valid_uint (p_right_attach));
++ rep_DECLARE (5, p_top_attach, sgtk_valid_uint (p_top_attach));
++ rep_DECLARE (6, p_bottom_attach, sgtk_valid_uint (p_bottom_attach));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_left_attach = sgtk_rep_to_uint (p_left_attach);
++ c_right_attach = sgtk_rep_to_uint (p_right_attach);
++ c_top_attach = sgtk_rep_to_uint (p_top_attach);
++ c_bottom_attach = sgtk_rep_to_uint (p_bottom_attach);
++ if (p_xoptions == Qnil)
++ c_xoptions = GTK_EXPAND|GTK_FILL;
++ else
++ c_xoptions = (GtkAttachOptions) sgtk_rep_to_flags (p_xoptions, &sgtk_gtk_attach_options_info);
++ if (p_yoptions == Qnil)
++ c_yoptions = GTK_EXPAND|GTK_FILL;
++ else
++ c_yoptions = (GtkAttachOptions) sgtk_rep_to_flags (p_yoptions, &sgtk_gtk_attach_options_info);
++ if (p_xpadding == Qnil)
++ c_xpadding = 0;
++ else
++ c_xpadding = sgtk_rep_to_uint (p_xpadding);
++ if (p_ypadding == Qnil)
++ c_ypadding = 0;
++ else
++ c_ypadding = sgtk_rep_to_uint (p_ypadding);
++
++ gtk_table_attach (c_table, c_child, c_left_attach, c_right_attach, c_top_attach, c_bottom_attach, c_xoptions, c_yoptions, c_xpadding, c_ypadding);
++
++ return Qnil;
++}
++
++DEFUN("gtk-table-attach-defaults", Fgtk_table_attach_defaults, Sgtk_table_attach_defaults, (repv args), rep_SubrN)
++{
++ repv p_table, p_child, p_left_attach, p_right_attach, p_top_attach, p_bottom_attach;
++
++ GtkTable* c_table;
++ GtkWidget* c_child;
++ guint c_left_attach;
++ guint c_right_attach;
++ guint c_top_attach;
++ guint c_bottom_attach;
++
++ if (!rep_CONSP(args))
++ p_table = Qnil;
++ else {
++ p_table = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_child = Qnil;
++ else {
++ p_child = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_left_attach = Qnil;
++ else {
++ p_left_attach = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_right_attach = Qnil;
++ else {
++ p_right_attach = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_top_attach = Qnil;
++ else {
++ p_top_attach = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_bottom_attach = Qnil;
++ else {
++ p_bottom_attach = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_left_attach, sgtk_valid_uint (p_left_attach));
++ rep_DECLARE (4, p_right_attach, sgtk_valid_uint (p_right_attach));
++ rep_DECLARE (5, p_top_attach, sgtk_valid_uint (p_top_attach));
++ rep_DECLARE (6, p_bottom_attach, sgtk_valid_uint (p_bottom_attach));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_left_attach = sgtk_rep_to_uint (p_left_attach);
++ c_right_attach = sgtk_rep_to_uint (p_right_attach);
++ c_top_attach = sgtk_rep_to_uint (p_top_attach);
++ c_bottom_attach = sgtk_rep_to_uint (p_bottom_attach);
++
++ gtk_table_attach_defaults (c_table, c_child, c_left_attach, c_right_attach, c_top_attach, c_bottom_attach);
++
++ return Qnil;
++}
++
++DEFUN("gtk-table-set-row-spacing", Fgtk_table_set_row_spacing, Sgtk_table_set_row_spacing, (repv p_table, repv p_row, repv p_spacing), rep_Subr3)
++{
++ GtkTable* c_table;
++ guint c_row;
++ guint c_spacing;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++ rep_DECLARE (2, p_row, sgtk_valid_uint (p_row));
++ rep_DECLARE (3, p_spacing, sgtk_valid_uint (p_spacing));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++ c_row = sgtk_rep_to_uint (p_row);
++ c_spacing = sgtk_rep_to_uint (p_spacing);
++
++ gtk_table_set_row_spacing (c_table, c_row, c_spacing);
++
++ return Qnil;
++}
++
++DEFUN("gtk-table-get-row-spacing", Fgtk_table_get_row_spacing, Sgtk_table_get_row_spacing, (repv p_table, repv p_row), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTable* c_table;
++ guint c_row;
++ guint cr_ret;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++ rep_DECLARE (2, p_row, sgtk_valid_uint (p_row));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++ c_row = sgtk_rep_to_uint (p_row);
++
++ cr_ret = gtk_table_get_row_spacing (c_table, c_row);
++
++ pr_ret = sgtk_uint_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-table-set-col-spacing", Fgtk_table_set_col_spacing, Sgtk_table_set_col_spacing, (repv p_table, repv p_column, repv p_spacing), rep_Subr3)
++{
++ GtkTable* c_table;
++ guint c_column;
++ guint c_spacing;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++ rep_DECLARE (2, p_column, sgtk_valid_uint (p_column));
++ rep_DECLARE (3, p_spacing, sgtk_valid_uint (p_spacing));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++ c_column = sgtk_rep_to_uint (p_column);
++ c_spacing = sgtk_rep_to_uint (p_spacing);
++
++ gtk_table_set_col_spacing (c_table, c_column, c_spacing);
++
++ return Qnil;
++}
++
++DEFUN("gtk-table-get-col-spacing", Fgtk_table_get_col_spacing, Sgtk_table_get_col_spacing, (repv p_table, repv p_column), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTable* c_table;
++ guint c_column;
++ guint cr_ret;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++ rep_DECLARE (2, p_column, sgtk_valid_uint (p_column));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++ c_column = sgtk_rep_to_uint (p_column);
++
++ cr_ret = gtk_table_get_col_spacing (c_table, c_column);
++
++ pr_ret = sgtk_uint_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-table-set-row-spacings", Fgtk_table_set_row_spacings, Sgtk_table_set_row_spacings, (repv p_table, repv p_spacing), rep_Subr2)
++{
++ GtkTable* c_table;
++ gint c_spacing;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++ rep_DECLARE (2, p_spacing, sgtk_valid_int (p_spacing));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++ c_spacing = sgtk_rep_to_int (p_spacing);
++
++ gtk_table_set_row_spacings (c_table, c_spacing);
++
++ return Qnil;
++}
++
++DEFUN("gtk-table-get-default-row-spacing", Fgtk_table_get_default_row_spacing, Sgtk_table_get_default_row_spacing, (repv p_table), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTable* c_table;
++ guint cr_ret;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++
++ cr_ret = gtk_table_get_default_row_spacing (c_table);
++
++ pr_ret = sgtk_uint_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-table-set-col-spacings", Fgtk_table_set_col_spacings, Sgtk_table_set_col_spacings, (repv p_table, repv p_spacing), rep_Subr2)
++{
++ GtkTable* c_table;
++ guint c_spacing;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++ rep_DECLARE (2, p_spacing, sgtk_valid_uint (p_spacing));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++ c_spacing = sgtk_rep_to_uint (p_spacing);
++
++ gtk_table_set_col_spacings (c_table, c_spacing);
++
++ return Qnil;
++}
++
++DEFUN("gtk-table-set-homogeneous", Fgtk_table_set_homogeneous, Sgtk_table_set_homogeneous, (repv p_table, repv p_homogeneous), rep_Subr2)
++{
++ GtkTable* c_table;
++ int c_homogeneous;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++ c_homogeneous = sgtk_rep_to_bool (p_homogeneous);
++
++ gtk_table_set_homogeneous (c_table, c_homogeneous);
++
++ return Qnil;
++}
++
++DEFUN("gtk-table-get-homogeneous", Fgtk_table_get_homogeneous, Sgtk_table_get_homogeneous, (repv p_table), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTable* c_table;
++ int cr_ret;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_table_get_type (), p_table));
++
++ c_table = (GtkTable*) sgtk_get_gobj (p_table);
++
++ cr_ret = gtk_table_get_homogeneous (c_table);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-new", Fgtk_button_new, Sgtk_button_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_button_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-new-with-label", Fgtk_button_new_with_label, Sgtk_button_new_with_label, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_button_new_with_label (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-new-from-stock", Fgtk_button_new_from_stock, Sgtk_button_new_from_stock, (repv p_stock_id), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_stock_id;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_stock_id, sgtk_valid_string (p_stock_id));
++
++ c_stock_id = sgtk_rep_to_string (p_stock_id);
++
++ cr_ret = gtk_button_new_from_stock (c_stock_id);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-new-with-mnemonic", Fgtk_button_new_with_mnemonic, Sgtk_button_new_with_mnemonic, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_button_new_with_mnemonic (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-pressed", Fgtk_button_pressed, Sgtk_button_pressed, (repv p_button), rep_Subr1)
++{
++ GtkButton* c_button;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++
++ gtk_button_pressed (c_button);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-released", Fgtk_button_released, Sgtk_button_released, (repv p_button), rep_Subr1)
++{
++ GtkButton* c_button;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++
++ gtk_button_released (c_button);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-clicked", Fgtk_button_clicked, Sgtk_button_clicked, (repv p_button), rep_Subr1)
++{
++ GtkButton* c_button;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++
++ gtk_button_clicked (c_button);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-enter", Fgtk_button_enter, Sgtk_button_enter, (repv p_button), rep_Subr1)
++{
++ GtkButton* c_button;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++
++ gtk_button_enter (c_button);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-leave", Fgtk_button_leave, Sgtk_button_leave, (repv p_button), rep_Subr1)
++{
++ GtkButton* c_button;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++
++ gtk_button_leave (c_button);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-set-relief", Fgtk_button_set_relief, Sgtk_button_set_relief, (repv p_button, repv p_relief), rep_Subr2)
++{
++ GtkButton* c_button;
++ GtkReliefStyle c_relief;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++ rep_DECLARE (2, p_relief, sgtk_valid_enum (p_relief, &sgtk_gtk_relief_style_info));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++ c_relief = (GtkReliefStyle) sgtk_rep_to_enum (p_relief, &sgtk_gtk_relief_style_info);
++
++ gtk_button_set_relief (c_button, c_relief);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-get-relief", Fgtk_button_get_relief, Sgtk_button_get_relief, (repv p_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkButton* c_button;
++ GtkReliefStyle cr_ret;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++
++ cr_ret = gtk_button_get_relief (c_button);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_relief_style_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-set-label", Fgtk_button_set_label, Sgtk_button_set_label, (repv p_button, repv p_label), rep_Subr2)
++{
++ GtkButton* c_button;
++ char* c_label;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++ rep_DECLARE (2, p_label, sgtk_valid_string (p_label));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++ c_label = sgtk_rep_to_string (p_label);
++
++ gtk_button_set_label (c_button, c_label);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-get-label", Fgtk_button_get_label, Sgtk_button_get_label, (repv p_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkButton* c_button;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++
++ cr_ret = gtk_button_get_label (c_button);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-set-use-underline", Fgtk_button_set_use_underline, Sgtk_button_set_use_underline, (repv p_button, repv p_use_underline), rep_Subr2)
++{
++ GtkButton* c_button;
++ int c_use_underline;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++ c_use_underline = sgtk_rep_to_bool (p_use_underline);
++
++ gtk_button_set_use_underline (c_button, c_use_underline);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-get-use-underline", Fgtk_button_get_use_underline, Sgtk_button_get_use_underline, (repv p_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkButton* c_button;
++ int cr_ret;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++
++ cr_ret = gtk_button_get_use_underline (c_button);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-set-use-stock", Fgtk_button_set_use_stock, Sgtk_button_set_use_stock, (repv p_button, repv p_use_stock), rep_Subr2)
++{
++ GtkButton* c_button;
++ int c_use_stock;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++ c_use_stock = sgtk_rep_to_bool (p_use_stock);
++
++ gtk_button_set_use_stock (c_button, c_use_stock);
++
++ return Qnil;
++}
++
++DEFUN("gtk-button-get-use-stock", Fgtk_button_get_use_stock, Sgtk_button_get_use_stock, (repv p_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkButton* c_button;
++ int cr_ret;
++
++ rep_DECLARE (1, p_button, sgtk_is_a_gobj (gtk_button_get_type (), p_button));
++
++ c_button = (GtkButton*) sgtk_get_gobj (p_button);
++
++ cr_ret = gtk_button_get_use_stock (c_button);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-toggle-button-new", Fgtk_toggle_button_new, Sgtk_toggle_button_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_toggle_button_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-toggle-button-new-with-label", Fgtk_toggle_button_new_with_label, Sgtk_toggle_button_new_with_label, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_toggle_button_new_with_label (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-toggle-button-new-with-mnemonic", Fgtk_toggle_button_new_with_mnemonic, Sgtk_toggle_button_new_with_mnemonic, (repv p_mnemonic), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_mnemonic;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_mnemonic, sgtk_valid_string (p_mnemonic));
++
++ c_mnemonic = sgtk_rep_to_string (p_mnemonic);
++
++ cr_ret = gtk_toggle_button_new_with_mnemonic (c_mnemonic);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-toggle-button-set-mode", Fgtk_toggle_button_set_mode, Sgtk_toggle_button_set_mode, (repv p_toggle_button, repv p_draw_indicator), rep_Subr2)
++{
++ GtkToggleButton* c_toggle_button;
++ int c_draw_indicator;
++
++ rep_DECLARE (1, p_toggle_button, sgtk_is_a_gobj (gtk_toggle_button_get_type (), p_toggle_button));
++
++ c_toggle_button = (GtkToggleButton*) sgtk_get_gobj (p_toggle_button);
++ c_draw_indicator = sgtk_rep_to_bool (p_draw_indicator);
++
++ gtk_toggle_button_set_mode (c_toggle_button, c_draw_indicator);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toggle-button-get-mode", Fgtk_toggle_button_get_mode, Sgtk_toggle_button_get_mode, (repv p_toggle_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkToggleButton* c_toggle_button;
++ int cr_ret;
++
++ rep_DECLARE (1, p_toggle_button, sgtk_is_a_gobj (gtk_toggle_button_get_type (), p_toggle_button));
++
++ c_toggle_button = (GtkToggleButton*) sgtk_get_gobj (p_toggle_button);
++
++ cr_ret = gtk_toggle_button_get_mode (c_toggle_button);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-toggle-button-set-active", Fgtk_toggle_button_set_active, Sgtk_toggle_button_set_active, (repv p_toggle_button, repv p_is_active), rep_Subr2)
++{
++ GtkToggleButton* c_toggle_button;
++ int c_is_active;
++
++ rep_DECLARE (1, p_toggle_button, sgtk_is_a_gobj (gtk_toggle_button_get_type (), p_toggle_button));
++
++ c_toggle_button = (GtkToggleButton*) sgtk_get_gobj (p_toggle_button);
++ c_is_active = sgtk_rep_to_bool (p_is_active);
++
++ gtk_toggle_button_set_active (c_toggle_button, c_is_active);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toggle-button-get-active", Fgtk_toggle_button_get_active, Sgtk_toggle_button_get_active, (repv p_toggle_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkToggleButton* c_toggle_button;
++ int cr_ret;
++
++ rep_DECLARE (1, p_toggle_button, sgtk_is_a_gobj (gtk_toggle_button_get_type (), p_toggle_button));
++
++ c_toggle_button = (GtkToggleButton*) sgtk_get_gobj (p_toggle_button);
++
++ cr_ret = gtk_toggle_button_get_active (c_toggle_button);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-toggle-button-toggled", Fgtk_toggle_button_toggled, Sgtk_toggle_button_toggled, (repv p_toggle_button), rep_Subr1)
++{
++ GtkToggleButton* c_toggle_button;
++
++ rep_DECLARE (1, p_toggle_button, sgtk_is_a_gobj (gtk_toggle_button_get_type (), p_toggle_button));
++
++ c_toggle_button = (GtkToggleButton*) sgtk_get_gobj (p_toggle_button);
++
++ gtk_toggle_button_toggled (c_toggle_button);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toggle-button-set-inconsistent", Fgtk_toggle_button_set_inconsistent, Sgtk_toggle_button_set_inconsistent, (repv p_toggle_button, repv p_setting), rep_Subr2)
++{
++ GtkToggleButton* c_toggle_button;
++ int c_setting;
++
++ rep_DECLARE (1, p_toggle_button, sgtk_is_a_gobj (gtk_toggle_button_get_type (), p_toggle_button));
++
++ c_toggle_button = (GtkToggleButton*) sgtk_get_gobj (p_toggle_button);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_toggle_button_set_inconsistent (c_toggle_button, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-toggle-button-get-inconsistent", Fgtk_toggle_button_get_inconsistent, Sgtk_toggle_button_get_inconsistent, (repv p_toggle_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkToggleButton* c_toggle_button;
++ int cr_ret;
++
++ rep_DECLARE (1, p_toggle_button, sgtk_is_a_gobj (gtk_toggle_button_get_type (), p_toggle_button));
++
++ c_toggle_button = (GtkToggleButton*) sgtk_get_gobj (p_toggle_button);
++
++ cr_ret = gtk_toggle_button_get_inconsistent (c_toggle_button);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-check-button-new", Fgtk_check_button_new, Sgtk_check_button_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_check_button_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-check-button-new-with-label", Fgtk_check_button_new_with_label, Sgtk_check_button_new_with_label, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_check_button_new_with_label (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-check-button-new-with-mnemonic", Fgtk_check_button_new_with_mnemonic, Sgtk_check_button_new_with_mnemonic, (repv p_mnemonic), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_mnemonic;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_mnemonic, sgtk_valid_string (p_mnemonic));
++
++ c_mnemonic = sgtk_rep_to_string (p_mnemonic);
++
++ cr_ret = gtk_check_button_new_with_mnemonic (c_mnemonic);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-radio-button-new-from-widget", Fgtk_radio_button_new_from_widget, Sgtk_radio_button_new_from_widget, (repv p_group), rep_Subr1)
++{
++ repv pr_ret;
++ GtkRadioButton* c_group;
++ GtkWidget* cr_ret;
++
++ if (p_group != Qnil)
++ rep_DECLARE (1, p_group, sgtk_is_a_gobj (gtk_radio_button_get_type (), p_group));
++
++ if (p_group == Qnil)
++ c_group = 0;
++ else
++ c_group = (GtkRadioButton*) sgtk_get_gobj (p_group);
++
++ cr_ret = gtk_radio_button_new_from_widget (c_group);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-radio-button-new-with-label-from-widget", Fgtk_radio_button_new_with_label_from_widget, Sgtk_radio_button_new_with_label_from_widget, (repv p_group, repv p_label), rep_Subr2)
++{
++ repv pr_ret;
++ GtkRadioButton* c_group;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ if (p_group != Qnil)
++ rep_DECLARE (1, p_group, sgtk_is_a_gobj (gtk_radio_button_get_type (), p_group));
++ rep_DECLARE (2, p_label, sgtk_valid_string (p_label));
++
++ if (p_group == Qnil)
++ c_group = 0;
++ else
++ c_group = (GtkRadioButton*) sgtk_get_gobj (p_group);
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_radio_button_new_with_label_from_widget (c_group, c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-radio-button-new-with-mnemonic-from-widget", Fgtk_radio_button_new_with_mnemonic_from_widget, Sgtk_radio_button_new_with_mnemonic_from_widget, (repv p_group, repv p_label), rep_Subr2)
++{
++ repv pr_ret;
++ GtkRadioButton* c_group;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ if (p_group != Qnil)
++ rep_DECLARE (1, p_group, sgtk_is_a_gobj (gtk_radio_button_get_type (), p_group));
++ rep_DECLARE (2, p_label, sgtk_valid_string (p_label));
++
++ if (p_group == Qnil)
++ c_group = 0;
++ else
++ c_group = (GtkRadioButton*) sgtk_get_gobj (p_group);
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_radio_button_new_with_mnemonic_from_widget (c_group, c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-misc-set-alignment", Fgtk_misc_set_alignment, Sgtk_misc_set_alignment, (repv p_misc, repv p_xalign, repv p_yalign), rep_Subr3)
++{
++ GtkMisc* c_misc;
++ gfloat c_xalign;
++ gfloat c_yalign;
++
++ rep_DECLARE (1, p_misc, sgtk_is_a_gobj (gtk_misc_get_type (), p_misc));
++ rep_DECLARE (2, p_xalign, sgtk_valid_float (p_xalign));
++ rep_DECLARE (3, p_yalign, sgtk_valid_float (p_yalign));
++
++ c_misc = (GtkMisc*) sgtk_get_gobj (p_misc);
++ c_xalign = sgtk_rep_to_float (p_xalign);
++ c_yalign = sgtk_rep_to_float (p_yalign);
++
++ gtk_misc_set_alignment (c_misc, c_xalign, c_yalign);
++
++ return Qnil;
++}
++
++DEFUN("gtk-misc-set-padding", Fgtk_misc_set_padding, Sgtk_misc_set_padding, (repv p_misc, repv p_xpad, repv p_ypad), rep_Subr3)
++{
++ GtkMisc* c_misc;
++ gint c_xpad;
++ gint c_ypad;
++
++ rep_DECLARE (1, p_misc, sgtk_is_a_gobj (gtk_misc_get_type (), p_misc));
++ rep_DECLARE (2, p_xpad, sgtk_valid_int (p_xpad));
++ rep_DECLARE (3, p_ypad, sgtk_valid_int (p_ypad));
++
++ c_misc = (GtkMisc*) sgtk_get_gobj (p_misc);
++ c_xpad = sgtk_rep_to_int (p_xpad);
++ c_ypad = sgtk_rep_to_int (p_ypad);
++
++ gtk_misc_set_padding (c_misc, c_xpad, c_ypad);
++
++ return Qnil;
++}
++
++DEFUN("gtk-arrow-new", Fgtk_arrow_new, Sgtk_arrow_new, (repv p_arrow_type, repv p_shadow_type), rep_Subr2)
++{
++ repv pr_ret;
++ GtkArrowType c_arrow_type;
++ GtkShadowType c_shadow_type;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_arrow_type, sgtk_valid_enum (p_arrow_type, &sgtk_gtk_arrow_type_info));
++ rep_DECLARE (2, p_shadow_type, sgtk_valid_enum (p_shadow_type, &sgtk_gtk_shadow_type_info));
++
++ c_arrow_type = (GtkArrowType) sgtk_rep_to_enum (p_arrow_type, &sgtk_gtk_arrow_type_info);
++ c_shadow_type = (GtkShadowType) sgtk_rep_to_enum (p_shadow_type, &sgtk_gtk_shadow_type_info);
++
++ cr_ret = gtk_arrow_new (c_arrow_type, c_shadow_type);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-arrow-set", Fgtk_arrow_set, Sgtk_arrow_set, (repv p_arrow, repv p_arrow_type, repv p_shadow_type), rep_Subr3)
++{
++ GtkArrow* c_arrow;
++ GtkArrowType c_arrow_type;
++ GtkShadowType c_shadow_type;
++
++ rep_DECLARE (1, p_arrow, sgtk_is_a_gobj (gtk_arrow_get_type (), p_arrow));
++ rep_DECLARE (2, p_arrow_type, sgtk_valid_enum (p_arrow_type, &sgtk_gtk_arrow_type_info));
++ rep_DECLARE (3, p_shadow_type, sgtk_valid_enum (p_shadow_type, &sgtk_gtk_shadow_type_info));
++
++ c_arrow = (GtkArrow*) sgtk_get_gobj (p_arrow);
++ c_arrow_type = (GtkArrowType) sgtk_rep_to_enum (p_arrow_type, &sgtk_gtk_arrow_type_info);
++ c_shadow_type = (GtkShadowType) sgtk_rep_to_enum (p_shadow_type, &sgtk_gtk_shadow_type_info);
++
++ gtk_arrow_set (c_arrow, c_arrow_type, c_shadow_type);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-new", Fgtk_label_new, Sgtk_label_new, (repv p_str), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_str;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_str, sgtk_valid_string (p_str));
++
++ c_str = sgtk_rep_to_string (p_str);
++
++ cr_ret = gtk_label_new (c_str);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-new-with-mnemonic", Fgtk_label_new_with_mnemonic, Sgtk_label_new_with_mnemonic, (repv p_str), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_str;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_str, sgtk_valid_string (p_str));
++
++ c_str = sgtk_rep_to_string (p_str);
++
++ cr_ret = gtk_label_new_with_mnemonic (c_str);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-set-text", Fgtk_label_set_text, Sgtk_label_set_text, (repv p_label, repv p_str), rep_Subr2)
++{
++ GtkLabel* c_label;
++ char* c_str;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++ rep_DECLARE (2, p_str, sgtk_valid_string (p_str));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_str = sgtk_rep_to_string (p_str);
++
++ gtk_label_set_text (c_label, c_str);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-get-text", Fgtk_label_get_text, Sgtk_label_get_text, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLabel* c_label;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++
++ cr_ret = gtk_label_get_text (c_label);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-set-label", Fgtk_label_set_label, Sgtk_label_set_label, (repv p_label, repv p_str), rep_Subr2)
++{
++ GtkLabel* c_label;
++ char* c_str;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++ rep_DECLARE (2, p_str, sgtk_valid_string (p_str));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_str = sgtk_rep_to_string (p_str);
++
++ gtk_label_set_label (c_label, c_str);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-get-label", Fgtk_label_get_label, Sgtk_label_get_label, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLabel* c_label;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++
++ cr_ret = gtk_label_get_label (c_label);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-set-markup", Fgtk_label_set_markup, Sgtk_label_set_markup, (repv p_label, repv p_str), rep_Subr2)
++{
++ GtkLabel* c_label;
++ char* c_str;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++ rep_DECLARE (2, p_str, sgtk_valid_string (p_str));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_str = sgtk_rep_to_string (p_str);
++
++ gtk_label_set_markup (c_label, c_str);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-set-use-markup", Fgtk_label_set_use_markup, Sgtk_label_set_use_markup, (repv p_label, repv p_setting), rep_Subr2)
++{
++ GtkLabel* c_label;
++ int c_setting;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_label_set_use_markup (c_label, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-get-use-markup", Fgtk_label_get_use_markup, Sgtk_label_get_use_markup, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLabel* c_label;
++ int cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++
++ cr_ret = gtk_label_get_use_markup (c_label);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-set-use-underline", Fgtk_label_set_use_underline, Sgtk_label_set_use_underline, (repv p_label, repv p_setting), rep_Subr2)
++{
++ GtkLabel* c_label;
++ int c_setting;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_label_set_use_underline (c_label, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-get-use-underline", Fgtk_label_get_use_underline, Sgtk_label_get_use_underline, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLabel* c_label;
++ int cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++
++ cr_ret = gtk_label_get_use_underline (c_label);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-set-markup-with-mnemonic", Fgtk_label_set_markup_with_mnemonic, Sgtk_label_set_markup_with_mnemonic, (repv p_label, repv p_str), rep_Subr2)
++{
++ GtkLabel* c_label;
++ char* c_str;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++ rep_DECLARE (2, p_str, sgtk_valid_string (p_str));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_str = sgtk_rep_to_string (p_str);
++
++ gtk_label_set_markup_with_mnemonic (c_label, c_str);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-get-mnemonic-keyval", Fgtk_label_get_mnemonic_keyval, Sgtk_label_get_mnemonic_keyval, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLabel* c_label;
++ guint cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++
++ cr_ret = gtk_label_get_mnemonic_keyval (c_label);
++
++ pr_ret = sgtk_uint_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-set-mnemonic-widget", Fgtk_label_set_mnemonic_widget, Sgtk_label_set_mnemonic_widget, (repv p_label, repv p_widget), rep_Subr2)
++{
++ GtkLabel* c_label;
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++ rep_DECLARE (2, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_label_set_mnemonic_widget (c_label, c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-get-mnemonic-widget", Fgtk_label_get_mnemonic_widget, Sgtk_label_get_mnemonic_widget, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLabel* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++
++ cr_ret = gtk_label_get_mnemonic_widget (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-set-text-with-mnemonic", Fgtk_label_set_text_with_mnemonic, Sgtk_label_set_text_with_mnemonic, (repv p_label, repv p_str), rep_Subr2)
++{
++ GtkLabel* c_label;
++ char* c_str;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++ rep_DECLARE (2, p_str, sgtk_valid_string (p_str));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_str = sgtk_rep_to_string (p_str);
++
++ gtk_label_set_text_with_mnemonic (c_label, c_str);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-set-justify", Fgtk_label_set_justify, Sgtk_label_set_justify, (repv p_label, repv p_jtype), rep_Subr2)
++{
++ GtkLabel* c_label;
++ GtkJustification c_jtype;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++ rep_DECLARE (2, p_jtype, sgtk_valid_enum (p_jtype, &sgtk_gtk_justification_info));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_jtype = (GtkJustification) sgtk_rep_to_enum (p_jtype, &sgtk_gtk_justification_info);
++
++ gtk_label_set_justify (c_label, c_jtype);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-get-justify", Fgtk_label_get_justify, Sgtk_label_get_justify, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLabel* c_label;
++ GtkJustification cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++
++ cr_ret = gtk_label_get_justify (c_label);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_justification_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-set-pattern", Fgtk_label_set_pattern, Sgtk_label_set_pattern, (repv p_label, repv p_pattern), rep_Subr2)
++{
++ GtkLabel* c_label;
++ char* c_pattern;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++ rep_DECLARE (2, p_pattern, sgtk_valid_string (p_pattern));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_pattern = sgtk_rep_to_string (p_pattern);
++
++ gtk_label_set_pattern (c_label, c_pattern);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-set-line-wrap", Fgtk_label_set_line_wrap, Sgtk_label_set_line_wrap, (repv p_label, repv p_wrap), rep_Subr2)
++{
++ GtkLabel* c_label;
++ int c_wrap;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_wrap = sgtk_rep_to_bool (p_wrap);
++
++ gtk_label_set_line_wrap (c_label, c_wrap);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-get-line-wrap", Fgtk_label_get_line_wrap, Sgtk_label_get_line_wrap, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLabel* c_label;
++ int cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++
++ cr_ret = gtk_label_get_line_wrap (c_label);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-set-selectable", Fgtk_label_set_selectable, Sgtk_label_set_selectable, (repv p_label, repv p_setting), rep_Subr2)
++{
++ GtkLabel* c_label;
++ int c_setting;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_label_set_selectable (c_label, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-label-get-selectable", Fgtk_label_get_selectable, Sgtk_label_get_selectable, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLabel* c_label;
++ int cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++
++ cr_ret = gtk_label_get_selectable (c_label);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-label-select-region", Fgtk_label_select_region, Sgtk_label_select_region, (repv p_label, repv p_start_offset, repv p_end_offset), rep_Subr3)
++{
++ GtkLabel* c_label;
++ gint c_start_offset;
++ gint c_end_offset;
++
++ rep_DECLARE (1, p_label, sgtk_is_a_gobj (gtk_label_get_type (), p_label));
++ rep_DECLARE (2, p_start_offset, sgtk_valid_int (p_start_offset));
++ rep_DECLARE (3, p_end_offset, sgtk_valid_int (p_end_offset));
++
++ c_label = (GtkLabel*) sgtk_get_gobj (p_label);
++ c_start_offset = sgtk_rep_to_int (p_start_offset);
++ c_end_offset = sgtk_rep_to_int (p_end_offset);
++
++ gtk_label_select_region (c_label, c_start_offset, c_end_offset);
++
++ return Qnil;
++}
++
++DEFUN("gtk-layout-new", Fgtk_layout_new, Sgtk_layout_new, (repv p_hadjustment, repv p_vadjustment), rep_Subr2)
++{
++ repv pr_ret;
++ GtkAdjustment* c_hadjustment;
++ GtkAdjustment* c_vadjustment;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_hadjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_hadjustment));
++ rep_DECLARE (2, p_vadjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_vadjustment));
++
++ c_hadjustment = (GtkAdjustment*) sgtk_get_gobj (p_hadjustment);
++ c_vadjustment = (GtkAdjustment*) sgtk_get_gobj (p_vadjustment);
++
++ cr_ret = gtk_layout_new (c_hadjustment, c_vadjustment);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-layout-put", Fgtk_layout_put, Sgtk_layout_put, (repv p_layout, repv p_child_widget, repv p_x, repv p_y), rep_Subr4)
++{
++ GtkLayout* c_layout;
++ GtkWidget* c_child_widget;
++ gint c_x;
++ gint c_y;
++
++ rep_DECLARE (1, p_layout, sgtk_is_a_gobj (gtk_layout_get_type (), p_layout));
++ rep_DECLARE (2, p_child_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_child_widget));
++ rep_DECLARE (3, p_x, sgtk_valid_int (p_x));
++ rep_DECLARE (4, p_y, sgtk_valid_int (p_y));
++
++ c_layout = (GtkLayout*) sgtk_get_gobj (p_layout);
++ c_child_widget = (GtkWidget*) sgtk_get_gobj (p_child_widget);
++ c_x = sgtk_rep_to_int (p_x);
++ c_y = sgtk_rep_to_int (p_y);
++
++ gtk_layout_put (c_layout, c_child_widget, c_x, c_y);
++
++ return Qnil;
++}
++
++DEFUN("gtk-layout-move", Fgtk_layout_move, Sgtk_layout_move, (repv p_layout, repv p_child_widget, repv p_x, repv p_y), rep_Subr4)
++{
++ GtkLayout* c_layout;
++ GtkWidget* c_child_widget;
++ gint c_x;
++ gint c_y;
++
++ rep_DECLARE (1, p_layout, sgtk_is_a_gobj (gtk_layout_get_type (), p_layout));
++ rep_DECLARE (2, p_child_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_child_widget));
++ rep_DECLARE (3, p_x, sgtk_valid_int (p_x));
++ rep_DECLARE (4, p_y, sgtk_valid_int (p_y));
++
++ c_layout = (GtkLayout*) sgtk_get_gobj (p_layout);
++ c_child_widget = (GtkWidget*) sgtk_get_gobj (p_child_widget);
++ c_x = sgtk_rep_to_int (p_x);
++ c_y = sgtk_rep_to_int (p_y);
++
++ gtk_layout_move (c_layout, c_child_widget, c_x, c_y);
++
++ return Qnil;
++}
++
++DEFUN("gtk-layout-set-size", Fgtk_layout_set_size, Sgtk_layout_set_size, (repv p_layout, repv p_width, repv p_height), rep_Subr3)
++{
++ GtkLayout* c_layout;
++ guint c_width;
++ guint c_height;
++
++ rep_DECLARE (1, p_layout, sgtk_is_a_gobj (gtk_layout_get_type (), p_layout));
++ rep_DECLARE (2, p_width, sgtk_valid_uint (p_width));
++ rep_DECLARE (3, p_height, sgtk_valid_uint (p_height));
++
++ c_layout = (GtkLayout*) sgtk_get_gobj (p_layout);
++ c_width = sgtk_rep_to_uint (p_width);
++ c_height = sgtk_rep_to_uint (p_height);
++
++ gtk_layout_set_size (c_layout, c_width, c_height);
++
++ return Qnil;
++}
++
++DEFUN("gtk-layout-get-hadjustment", Fgtk_layout_get_hadjustment, Sgtk_layout_get_hadjustment, (repv p_layout), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLayout* c_layout;
++ GtkAdjustment* cr_ret;
++
++ rep_DECLARE (1, p_layout, sgtk_is_a_gobj (gtk_layout_get_type (), p_layout));
++
++ c_layout = (GtkLayout*) sgtk_get_gobj (p_layout);
++
++ cr_ret = gtk_layout_get_hadjustment (c_layout);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-layout-get-vadjustment", Fgtk_layout_get_vadjustment, Sgtk_layout_get_vadjustment, (repv p_layout), rep_Subr1)
++{
++ repv pr_ret;
++ GtkLayout* c_layout;
++ GtkAdjustment* cr_ret;
++
++ rep_DECLARE (1, p_layout, sgtk_is_a_gobj (gtk_layout_get_type (), p_layout));
++
++ c_layout = (GtkLayout*) sgtk_get_gobj (p_layout);
++
++ cr_ret = gtk_layout_get_vadjustment (c_layout);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-layout-set-hadjustment", Fgtk_layout_set_hadjustment, Sgtk_layout_set_hadjustment, (repv p_layout, repv p_adjustment), rep_Subr2)
++{
++ GtkLayout* c_layout;
++ GtkAdjustment* c_adjustment;
++
++ rep_DECLARE (1, p_layout, sgtk_is_a_gobj (gtk_layout_get_type (), p_layout));
++ rep_DECLARE (2, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_layout = (GtkLayout*) sgtk_get_gobj (p_layout);
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ gtk_layout_set_hadjustment (c_layout, c_adjustment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-layout-set-vadjustment", Fgtk_layout_set_vadjustment, Sgtk_layout_set_vadjustment, (repv p_layout, repv p_adjustment), rep_Subr2)
++{
++ GtkLayout* c_layout;
++ GtkAdjustment* c_adjustment;
++
++ rep_DECLARE (1, p_layout, sgtk_is_a_gobj (gtk_layout_get_type (), p_layout));
++ rep_DECLARE (2, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_layout = (GtkLayout*) sgtk_get_gobj (p_layout);
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ gtk_layout_set_vadjustment (c_layout, c_adjustment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tips-query-new", Fgtk_tips_query_new, Sgtk_tips_query_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_tips_query_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-tips-query-start-query", Fgtk_tips_query_start_query, Sgtk_tips_query_start_query, (repv p_tips_query), rep_Subr1)
++{
++ GtkTipsQuery* c_tips_query;
++
++ rep_DECLARE (1, p_tips_query, sgtk_is_a_gobj (gtk_tips_query_get_type (), p_tips_query));
++
++ c_tips_query = (GtkTipsQuery*) sgtk_get_gobj (p_tips_query);
++
++ gtk_tips_query_start_query (c_tips_query);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tips-query-stop-query", Fgtk_tips_query_stop_query, Sgtk_tips_query_stop_query, (repv p_tips_query), rep_Subr1)
++{
++ GtkTipsQuery* c_tips_query;
++
++ rep_DECLARE (1, p_tips_query, sgtk_is_a_gobj (gtk_tips_query_get_type (), p_tips_query));
++
++ c_tips_query = (GtkTipsQuery*) sgtk_get_gobj (p_tips_query);
++
++ gtk_tips_query_stop_query (c_tips_query);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tips-query-set-caller", Fgtk_tips_query_set_caller, Sgtk_tips_query_set_caller, (repv p_tips_query, repv p_caller), rep_Subr2)
++{
++ GtkTipsQuery* c_tips_query;
++ GtkWidget* c_caller;
++
++ rep_DECLARE (1, p_tips_query, sgtk_is_a_gobj (gtk_tips_query_get_type (), p_tips_query));
++ rep_DECLARE (2, p_caller, sgtk_is_a_gobj (gtk_widget_get_type (), p_caller));
++
++ c_tips_query = (GtkTipsQuery*) sgtk_get_gobj (p_tips_query);
++ c_caller = (GtkWidget*) sgtk_get_gobj (p_caller);
++
++ gtk_tips_query_set_caller (c_tips_query, c_caller);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tips-query-set-labels", Fgtk_tips_query_set_labels, Sgtk_tips_query_set_labels, (repv p_tips_query, repv p_label_inactive, repv p_label_no_tip), rep_Subr3)
++{
++ GtkTipsQuery* c_tips_query;
++ char* c_label_inactive;
++ char* c_label_no_tip;
++
++ rep_DECLARE (1, p_tips_query, sgtk_is_a_gobj (gtk_tips_query_get_type (), p_tips_query));
++ rep_DECLARE (2, p_label_inactive, sgtk_valid_string (p_label_inactive));
++ rep_DECLARE (3, p_label_no_tip, sgtk_valid_string (p_label_no_tip));
++
++ c_tips_query = (GtkTipsQuery*) sgtk_get_gobj (p_tips_query);
++ c_label_inactive = sgtk_rep_to_string (p_label_inactive);
++ c_label_no_tip = sgtk_rep_to_string (p_label_no_tip);
++
++ gtk_tips_query_set_labels (c_tips_query, c_label_inactive, c_label_no_tip);
++
++ return Qnil;
++}
++
++DEFUN("gtk-vbox-new", Fgtk_vbox_new, Sgtk_vbox_new, (repv p_homogenous, repv p_spacing), rep_Subr2)
++{
++ repv pr_ret;
++ int c_homogenous;
++ gint c_spacing;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (2, p_spacing, sgtk_valid_int (p_spacing));
++
++ c_homogenous = sgtk_rep_to_bool (p_homogenous);
++ c_spacing = sgtk_rep_to_int (p_spacing);
++
++ cr_ret = gtk_vbox_new (c_homogenous, c_spacing);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-hbox-new", Fgtk_hbox_new, Sgtk_hbox_new, (repv p_homogenous, repv p_spacing), rep_Subr2)
++{
++ repv pr_ret;
++ int c_homogenous;
++ gint c_spacing;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (2, p_spacing, sgtk_valid_int (p_spacing));
++
++ c_homogenous = sgtk_rep_to_bool (p_homogenous);
++ c_spacing = sgtk_rep_to_int (p_spacing);
++
++ cr_ret = gtk_hbox_new (c_homogenous, c_spacing);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-item-select", Fgtk_item_select, Sgtk_item_select, (repv p_item), rep_Subr1)
++{
++ GtkItem* c_item;
++
++ rep_DECLARE (1, p_item, sgtk_is_a_gobj (gtk_item_get_type (), p_item));
++
++ c_item = (GtkItem*) sgtk_get_gobj (p_item);
++
++ gtk_item_select (c_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-item-deselect", Fgtk_item_deselect, Sgtk_item_deselect, (repv p_item), rep_Subr1)
++{
++ GtkItem* c_item;
++
++ rep_DECLARE (1, p_item, sgtk_is_a_gobj (gtk_item_get_type (), p_item));
++
++ c_item = (GtkItem*) sgtk_get_gobj (p_item);
++
++ gtk_item_deselect (c_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-item-toggle", Fgtk_item_toggle, Sgtk_item_toggle, (repv p_item), rep_Subr1)
++{
++ GtkItem* c_item;
++
++ rep_DECLARE (1, p_item, sgtk_is_a_gobj (gtk_item_get_type (), p_item));
++
++ c_item = (GtkItem*) sgtk_get_gobj (p_item);
++
++ gtk_item_toggle (c_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-combo-new", Fgtk_combo_new, Sgtk_combo_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_combo_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-combo-set-value-in-list", Fgtk_combo_set_value_in_list, Sgtk_combo_set_value_in_list, (repv p_combo, repv p_val, repv p_ok_if_empty), rep_Subr3)
++{
++ GtkCombo* c_combo;
++ int c_val;
++ int c_ok_if_empty;
++
++ rep_DECLARE (1, p_combo, sgtk_is_a_gobj (gtk_combo_get_type (), p_combo));
++
++ c_combo = (GtkCombo*) sgtk_get_gobj (p_combo);
++ c_val = sgtk_rep_to_bool (p_val);
++ c_ok_if_empty = sgtk_rep_to_bool (p_ok_if_empty);
++
++ gtk_combo_set_value_in_list (c_combo, c_val, c_ok_if_empty);
++
++ return Qnil;
++}
++
++DEFUN("gtk-combo-set-use-arrows", Fgtk_combo_set_use_arrows, Sgtk_combo_set_use_arrows, (repv p_combo, repv p_val), rep_Subr2)
++{
++ GtkCombo* c_combo;
++ int c_val;
++
++ rep_DECLARE (1, p_combo, sgtk_is_a_gobj (gtk_combo_get_type (), p_combo));
++
++ c_combo = (GtkCombo*) sgtk_get_gobj (p_combo);
++ c_val = sgtk_rep_to_bool (p_val);
++
++ gtk_combo_set_use_arrows (c_combo, c_val);
++
++ return Qnil;
++}
++
++DEFUN("gtk-combo-set-use-arrows-always", Fgtk_combo_set_use_arrows_always, Sgtk_combo_set_use_arrows_always, (repv p_combo, repv p_val), rep_Subr2)
++{
++ GtkCombo* c_combo;
++ int c_val;
++
++ rep_DECLARE (1, p_combo, sgtk_is_a_gobj (gtk_combo_get_type (), p_combo));
++
++ c_combo = (GtkCombo*) sgtk_get_gobj (p_combo);
++ c_val = sgtk_rep_to_bool (p_val);
++
++ gtk_combo_set_use_arrows_always (c_combo, c_val);
++
++ return Qnil;
++}
++
++DEFUN("gtk-combo-set-case-sensitive", Fgtk_combo_set_case_sensitive, Sgtk_combo_set_case_sensitive, (repv p_combo, repv p_val), rep_Subr2)
++{
++ GtkCombo* c_combo;
++ int c_val;
++
++ rep_DECLARE (1, p_combo, sgtk_is_a_gobj (gtk_combo_get_type (), p_combo));
++
++ c_combo = (GtkCombo*) sgtk_get_gobj (p_combo);
++ c_val = sgtk_rep_to_bool (p_val);
++
++ gtk_combo_set_case_sensitive (c_combo, c_val);
++
++ return Qnil;
++}
++
++DEFUN("gtk-combo-set-item-string", Fgtk_combo_set_item_string, Sgtk_combo_set_item_string, (repv p_combo, repv p_item, repv p_item_value), rep_Subr3)
++{
++ GtkCombo* c_combo;
++ GtkItem* c_item;
++ char* c_item_value;
++
++ rep_DECLARE (1, p_combo, sgtk_is_a_gobj (gtk_combo_get_type (), p_combo));
++ rep_DECLARE (2, p_item, sgtk_is_a_gobj (gtk_item_get_type (), p_item));
++ rep_DECLARE (3, p_item_value, sgtk_valid_string (p_item_value));
++
++ c_combo = (GtkCombo*) sgtk_get_gobj (p_combo);
++ c_item = (GtkItem*) sgtk_get_gobj (p_item);
++ c_item_value = sgtk_rep_to_string (p_item_value);
++
++ gtk_combo_set_item_string (c_combo, c_item, c_item_value);
++
++ return Qnil;
++}
++
++DEFUN("gtk-combo-disable-activate", Fgtk_combo_disable_activate, Sgtk_combo_disable_activate, (repv p_combo), rep_Subr1)
++{
++ GtkCombo* c_combo;
++
++ rep_DECLARE (1, p_combo, sgtk_is_a_gobj (gtk_combo_get_type (), p_combo));
++
++ c_combo = (GtkCombo*) sgtk_get_gobj (p_combo);
++
++ gtk_combo_disable_activate (c_combo);
++
++ return Qnil;
++}
++
++DEFUN("gtk-combo-set-popdown-strings", Fgtk_combo_set_popdown_strings, Sgtk_combo_set_popdown_strings, (repv p_combo, repv p_strings), rep_Subr2)
++{
++ rep_GC_root gc_strings;
++ GtkCombo* c_combo;
++ GList* c_strings;
++
++ rep_DECLARE (1, p_combo, sgtk_is_a_gobj (gtk_combo_get_type (), p_combo));
++ rep_DECLARE (2, p_strings, sgtk_valid_composite (p_strings, _sgtk_helper_valid_string));
++
++ rep_PUSHGC (gc_strings, p_strings);
++ c_combo = (GtkCombo*) sgtk_get_gobj (p_combo);
++ c_strings = sgtk_rep_to_list (p_strings, _sgtk_helper_fromrep_string);
++
++ gtk_combo_set_popdown_strings (c_combo, c_strings);
++
++ sgtk_list_finish (c_strings, p_strings, 0);
++ rep_POPGC;
++ return Qnil;
++}
++
++DEFUN("gtk-statusbar-new", Fgtk_statusbar_new, Sgtk_statusbar_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_statusbar_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-statusbar-get-context-id", Fgtk_statusbar_get_context_id, Sgtk_statusbar_get_context_id, (repv p_statusbar, repv p_context_description), rep_Subr2)
++{
++ repv pr_ret;
++ GtkStatusbar* c_statusbar;
++ char* c_context_description;
++ guint cr_ret;
++
++ rep_DECLARE (1, p_statusbar, sgtk_is_a_gobj (gtk_statusbar_get_type (), p_statusbar));
++ rep_DECLARE (2, p_context_description, sgtk_valid_string (p_context_description));
++
++ c_statusbar = (GtkStatusbar*) sgtk_get_gobj (p_statusbar);
++ c_context_description = sgtk_rep_to_string (p_context_description);
++
++ cr_ret = gtk_statusbar_get_context_id (c_statusbar, c_context_description);
++
++ pr_ret = sgtk_uint_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-statusbar-push", Fgtk_statusbar_push, Sgtk_statusbar_push, (repv p_statusbar, repv p_context_id, repv p_text), rep_Subr3)
++{
++ repv pr_ret;
++ GtkStatusbar* c_statusbar;
++ guint c_context_id;
++ char* c_text;
++ guint cr_ret;
++
++ rep_DECLARE (1, p_statusbar, sgtk_is_a_gobj (gtk_statusbar_get_type (), p_statusbar));
++ rep_DECLARE (2, p_context_id, sgtk_valid_uint (p_context_id));
++ rep_DECLARE (3, p_text, sgtk_valid_string (p_text));
++
++ c_statusbar = (GtkStatusbar*) sgtk_get_gobj (p_statusbar);
++ c_context_id = sgtk_rep_to_uint (p_context_id);
++ c_text = sgtk_rep_to_string (p_text);
++
++ cr_ret = gtk_statusbar_push (c_statusbar, c_context_id, c_text);
++
++ pr_ret = sgtk_uint_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-statusbar-pop", Fgtk_statusbar_pop, Sgtk_statusbar_pop, (repv p_statusbar, repv p_context_id), rep_Subr2)
++{
++ GtkStatusbar* c_statusbar;
++ guint c_context_id;
++
++ rep_DECLARE (1, p_statusbar, sgtk_is_a_gobj (gtk_statusbar_get_type (), p_statusbar));
++ rep_DECLARE (2, p_context_id, sgtk_valid_uint (p_context_id));
++
++ c_statusbar = (GtkStatusbar*) sgtk_get_gobj (p_statusbar);
++ c_context_id = sgtk_rep_to_uint (p_context_id);
++
++ gtk_statusbar_pop (c_statusbar, c_context_id);
++
++ return Qnil;
++}
++
++DEFUN("gtk-statusbar-remove", Fgtk_statusbar_remove, Sgtk_statusbar_remove, (repv p_statusbar, repv p_context_id, repv p_message_id), rep_Subr3)
++{
++ GtkStatusbar* c_statusbar;
++ guint c_context_id;
++ guint c_message_id;
++
++ rep_DECLARE (1, p_statusbar, sgtk_is_a_gobj (gtk_statusbar_get_type (), p_statusbar));
++ rep_DECLARE (2, p_context_id, sgtk_valid_uint (p_context_id));
++ rep_DECLARE (3, p_message_id, sgtk_valid_uint (p_message_id));
++
++ c_statusbar = (GtkStatusbar*) sgtk_get_gobj (p_statusbar);
++ c_context_id = sgtk_rep_to_uint (p_context_id);
++ c_message_id = sgtk_rep_to_uint (p_message_id);
++
++ gtk_statusbar_remove (c_statusbar, c_context_id, c_message_id);
++
++ return Qnil;
++}
++
++DEFUN("gtk-gamma-curve-new", Fgtk_gamma_curve_new, Sgtk_gamma_curve_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_gamma_curve_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-hseparator-new", Fgtk_hseparator_new, Sgtk_hseparator_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_hseparator_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-vseparator-new", Fgtk_vseparator_new, Sgtk_vseparator_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_vseparator_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-frame-new", Fgtk_frame_new, Sgtk_frame_new, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ if (p_label != Qnil)
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ if (p_label == Qnil)
++ c_label = 0;
++ else
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_frame_new (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-frame-set-label", Fgtk_frame_set_label, Sgtk_frame_set_label, (repv p_frame, repv p_label), rep_Subr2)
++{
++ GtkFrame* c_frame;
++ char* c_label;
++
++ rep_DECLARE (1, p_frame, sgtk_is_a_gobj (gtk_frame_get_type (), p_frame));
++ rep_DECLARE (2, p_label, sgtk_valid_string (p_label));
++
++ c_frame = (GtkFrame*) sgtk_get_gobj (p_frame);
++ c_label = sgtk_rep_to_string (p_label);
++
++ gtk_frame_set_label (c_frame, c_label);
++
++ return Qnil;
++}
++
++DEFUN("gtk-frame-get-label", Fgtk_frame_get_label, Sgtk_frame_get_label, (repv p_frame), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFrame* c_frame;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_frame, sgtk_is_a_gobj (gtk_frame_get_type (), p_frame));
++
++ c_frame = (GtkFrame*) sgtk_get_gobj (p_frame);
++
++ cr_ret = gtk_frame_get_label (c_frame);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-frame-set-label-widget", Fgtk_frame_set_label_widget, Sgtk_frame_set_label_widget, (repv p_frame, repv p_widget), rep_Subr2)
++{
++ GtkFrame* c_frame;
++ GtkWidget* c_widget;
++
++ rep_DECLARE (1, p_frame, sgtk_is_a_gobj (gtk_frame_get_type (), p_frame));
++ rep_DECLARE (2, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++
++ c_frame = (GtkFrame*) sgtk_get_gobj (p_frame);
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++
++ gtk_frame_set_label_widget (c_frame, c_widget);
++
++ return Qnil;
++}
++
++DEFUN("gtk-frame-get-label-widget", Fgtk_frame_get_label_widget, Sgtk_frame_get_label_widget, (repv p_frame), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFrame* c_frame;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_frame, sgtk_is_a_gobj (gtk_frame_get_type (), p_frame));
++
++ c_frame = (GtkFrame*) sgtk_get_gobj (p_frame);
++
++ cr_ret = gtk_frame_get_label_widget (c_frame);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-frame-set-label-align", Fgtk_frame_set_label_align, Sgtk_frame_set_label_align, (repv p_frame, repv p_xalign, repv p_yalign), rep_Subr3)
++{
++ GtkFrame* c_frame;
++ gfloat c_xalign;
++ gfloat c_yalign;
++
++ rep_DECLARE (1, p_frame, sgtk_is_a_gobj (gtk_frame_get_type (), p_frame));
++ rep_DECLARE (2, p_xalign, sgtk_valid_float (p_xalign));
++ rep_DECLARE (3, p_yalign, sgtk_valid_float (p_yalign));
++
++ c_frame = (GtkFrame*) sgtk_get_gobj (p_frame);
++ c_xalign = sgtk_rep_to_float (p_xalign);
++ c_yalign = sgtk_rep_to_float (p_yalign);
++
++ gtk_frame_set_label_align (c_frame, c_xalign, c_yalign);
++
++ return Qnil;
++}
++
++DEFUN("gtk-frame-set-shadow-type", Fgtk_frame_set_shadow_type, Sgtk_frame_set_shadow_type, (repv p_frame, repv p_type), rep_Subr2)
++{
++ GtkFrame* c_frame;
++ GtkShadowType c_type;
++
++ rep_DECLARE (1, p_frame, sgtk_is_a_gobj (gtk_frame_get_type (), p_frame));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_shadow_type_info));
++
++ c_frame = (GtkFrame*) sgtk_get_gobj (p_frame);
++ c_type = (GtkShadowType) sgtk_rep_to_enum (p_type, &sgtk_gtk_shadow_type_info);
++
++ gtk_frame_set_shadow_type (c_frame, c_type);
++
++ return Qnil;
++}
++
++DEFUN("gtk-frame-get-shadow-type", Fgtk_frame_get_shadow_type, Sgtk_frame_get_shadow_type, (repv p_frame), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFrame* c_frame;
++ GtkShadowType cr_ret;
++
++ rep_DECLARE (1, p_frame, sgtk_is_a_gobj (gtk_frame_get_type (), p_frame));
++
++ c_frame = (GtkFrame*) sgtk_get_gobj (p_frame);
++
++ cr_ret = gtk_frame_get_shadow_type (c_frame);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_shadow_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-aspect-frame-new", Fgtk_aspect_frame_new, Sgtk_aspect_frame_new, (repv p_label, repv p_xalign, repv p_yalign, repv p_ratio, repv p_obey_child), rep_Subr5)
++{
++ repv pr_ret;
++ char* c_label;
++ gfloat c_xalign;
++ gfloat c_yalign;
++ gfloat c_ratio;
++ int c_obey_child;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++ rep_DECLARE (2, p_xalign, sgtk_valid_float (p_xalign));
++ rep_DECLARE (3, p_yalign, sgtk_valid_float (p_yalign));
++ rep_DECLARE (4, p_ratio, sgtk_valid_float (p_ratio));
++
++ c_label = sgtk_rep_to_string (p_label);
++ c_xalign = sgtk_rep_to_float (p_xalign);
++ c_yalign = sgtk_rep_to_float (p_yalign);
++ c_ratio = sgtk_rep_to_float (p_ratio);
++ c_obey_child = sgtk_rep_to_bool (p_obey_child);
++
++ cr_ret = gtk_aspect_frame_new (c_label, c_xalign, c_yalign, c_ratio, c_obey_child);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-aspect-frame-set", Fgtk_aspect_frame_set, Sgtk_aspect_frame_set, (repv p_aspect_frame, repv p_xalign, repv p_yalign, repv p_ratio, repv p_obey_child), rep_Subr5)
++{
++ GtkAspectFrame* c_aspect_frame;
++ gfloat c_xalign;
++ gfloat c_yalign;
++ gfloat c_ratio;
++ int c_obey_child;
++
++ rep_DECLARE (1, p_aspect_frame, sgtk_is_a_gobj (gtk_aspect_frame_get_type (), p_aspect_frame));
++ rep_DECLARE (2, p_xalign, sgtk_valid_float (p_xalign));
++ rep_DECLARE (3, p_yalign, sgtk_valid_float (p_yalign));
++ rep_DECLARE (4, p_ratio, sgtk_valid_float (p_ratio));
++
++ c_aspect_frame = (GtkAspectFrame*) sgtk_get_gobj (p_aspect_frame);
++ c_xalign = sgtk_rep_to_float (p_xalign);
++ c_yalign = sgtk_rep_to_float (p_yalign);
++ c_ratio = sgtk_rep_to_float (p_ratio);
++ c_obey_child = sgtk_rep_to_bool (p_obey_child);
++
++ gtk_aspect_frame_set (c_aspect_frame, c_xalign, c_yalign, c_ratio, c_obey_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-progress-bar-new", Fgtk_progress_bar_new, Sgtk_progress_bar_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_progress_bar_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-progress-bar-pulse", Fgtk_progress_bar_pulse, Sgtk_progress_bar_pulse, (repv p_pbar), rep_Subr1)
++{
++ GtkProgressBar* c_pbar;
++
++ rep_DECLARE (1, p_pbar, sgtk_is_a_gobj (gtk_progress_bar_get_type (), p_pbar));
++
++ c_pbar = (GtkProgressBar*) sgtk_get_gobj (p_pbar);
++
++ gtk_progress_bar_pulse (c_pbar);
++
++ return Qnil;
++}
++
++DEFUN("gtk-progress-bar-set-text", Fgtk_progress_bar_set_text, Sgtk_progress_bar_set_text, (repv p_pbar, repv p_text), rep_Subr2)
++{
++ GtkProgressBar* c_pbar;
++ char* c_text;
++
++ rep_DECLARE (1, p_pbar, sgtk_is_a_gobj (gtk_progress_bar_get_type (), p_pbar));
++ rep_DECLARE (2, p_text, sgtk_valid_string (p_text));
++
++ c_pbar = (GtkProgressBar*) sgtk_get_gobj (p_pbar);
++ c_text = sgtk_rep_to_string (p_text);
++
++ gtk_progress_bar_set_text (c_pbar, c_text);
++
++ return Qnil;
++}
++
++DEFUN("gtk-progress-bar-set-fraction", Fgtk_progress_bar_set_fraction, Sgtk_progress_bar_set_fraction, (repv p_pbar, repv p_fraction), rep_Subr2)
++{
++ GtkProgressBar* c_pbar;
++ gdouble c_fraction;
++
++ rep_DECLARE (1, p_pbar, sgtk_is_a_gobj (gtk_progress_bar_get_type (), p_pbar));
++ rep_DECLARE (2, p_fraction, sgtk_valid_double (p_fraction));
++
++ c_pbar = (GtkProgressBar*) sgtk_get_gobj (p_pbar);
++ c_fraction = sgtk_rep_to_double (p_fraction);
++
++ gtk_progress_bar_set_fraction (c_pbar, c_fraction);
++
++ return Qnil;
++}
++
++DEFUN("gtk-progress-bar-set-pulse-step", Fgtk_progress_bar_set_pulse_step, Sgtk_progress_bar_set_pulse_step, (repv p_pbar, repv p_fraction), rep_Subr2)
++{
++ GtkProgressBar* c_pbar;
++ gdouble c_fraction;
++
++ rep_DECLARE (1, p_pbar, sgtk_is_a_gobj (gtk_progress_bar_get_type (), p_pbar));
++ rep_DECLARE (2, p_fraction, sgtk_valid_double (p_fraction));
++
++ c_pbar = (GtkProgressBar*) sgtk_get_gobj (p_pbar);
++ c_fraction = sgtk_rep_to_double (p_fraction);
++
++ gtk_progress_bar_set_pulse_step (c_pbar, c_fraction);
++
++ return Qnil;
++}
++
++DEFUN("gtk-progress-bar-set-orientation", Fgtk_progress_bar_set_orientation, Sgtk_progress_bar_set_orientation, (repv p_pbar, repv p_orientation), rep_Subr2)
++{
++ GtkProgressBar* c_pbar;
++ GtkProgressBarOrientation c_orientation;
++
++ rep_DECLARE (1, p_pbar, sgtk_is_a_gobj (gtk_progress_bar_get_type (), p_pbar));
++ rep_DECLARE (2, p_orientation, sgtk_valid_enum (p_orientation, &sgtk_gtk_progress_bar_orientation_info));
++
++ c_pbar = (GtkProgressBar*) sgtk_get_gobj (p_pbar);
++ c_orientation = (GtkProgressBarOrientation) sgtk_rep_to_enum (p_orientation, &sgtk_gtk_progress_bar_orientation_info);
++
++ gtk_progress_bar_set_orientation (c_pbar, c_orientation);
++
++ return Qnil;
++}
++
++DEFUN("gtk-progress-bar-get-text", Fgtk_progress_bar_get_text, Sgtk_progress_bar_get_text, (repv p_pbar), rep_Subr1)
++{
++ repv pr_ret;
++ GtkProgressBar* c_pbar;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_pbar, sgtk_is_a_gobj (gtk_progress_bar_get_type (), p_pbar));
++
++ c_pbar = (GtkProgressBar*) sgtk_get_gobj (p_pbar);
++
++ cr_ret = gtk_progress_bar_get_text (c_pbar);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-progress-bar-get-fraction", Fgtk_progress_bar_get_fraction, Sgtk_progress_bar_get_fraction, (repv p_pbar), rep_Subr1)
++{
++ repv pr_ret;
++ GtkProgressBar* c_pbar;
++ gdouble cr_ret;
++
++ rep_DECLARE (1, p_pbar, sgtk_is_a_gobj (gtk_progress_bar_get_type (), p_pbar));
++
++ c_pbar = (GtkProgressBar*) sgtk_get_gobj (p_pbar);
++
++ cr_ret = gtk_progress_bar_get_fraction (c_pbar);
++
++ pr_ret = sgtk_double_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-progress-bar-get-pulse-step", Fgtk_progress_bar_get_pulse_step, Sgtk_progress_bar_get_pulse_step, (repv p_pbar), rep_Subr1)
++{
++ repv pr_ret;
++ GtkProgressBar* c_pbar;
++ gdouble cr_ret;
++
++ rep_DECLARE (1, p_pbar, sgtk_is_a_gobj (gtk_progress_bar_get_type (), p_pbar));
++
++ c_pbar = (GtkProgressBar*) sgtk_get_gobj (p_pbar);
++
++ cr_ret = gtk_progress_bar_get_pulse_step (c_pbar);
++
++ pr_ret = sgtk_double_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-progress-bar-get-orientation", Fgtk_progress_bar_get_orientation, Sgtk_progress_bar_get_orientation, (repv p_pbar), rep_Subr1)
++{
++ repv pr_ret;
++ GtkProgressBar* c_pbar;
++ GtkProgressBarOrientation cr_ret;
++
++ rep_DECLARE (1, p_pbar, sgtk_is_a_gobj (gtk_progress_bar_get_type (), p_pbar));
++
++ c_pbar = (GtkProgressBar*) sgtk_get_gobj (p_pbar);
++
++ cr_ret = gtk_progress_bar_get_orientation (c_pbar);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_progress_bar_orientation_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-tooltips-new", Fgtk_tooltips_new, Sgtk_tooltips_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkTooltips* cr_ret;
++
++ cr_ret = gtk_tooltips_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-tooltips-enable", Fgtk_tooltips_enable, Sgtk_tooltips_enable, (repv p_tooltips), rep_Subr1)
++{
++ GtkTooltips* c_tooltips;
++
++ rep_DECLARE (1, p_tooltips, sgtk_is_a_gobj (gtk_tooltips_get_type (), p_tooltips));
++
++ c_tooltips = (GtkTooltips*) sgtk_get_gobj (p_tooltips);
++
++ gtk_tooltips_enable (c_tooltips);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tooltips-disable", Fgtk_tooltips_disable, Sgtk_tooltips_disable, (repv p_tooltips), rep_Subr1)
++{
++ GtkTooltips* c_tooltips;
++
++ rep_DECLARE (1, p_tooltips, sgtk_is_a_gobj (gtk_tooltips_get_type (), p_tooltips));
++
++ c_tooltips = (GtkTooltips*) sgtk_get_gobj (p_tooltips);
++
++ gtk_tooltips_disable (c_tooltips);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tooltips-set-tip", Fgtk_tooltips_set_tip, Sgtk_tooltips_set_tip, (repv p_tooltips, repv p_widget, repv p_tip_text, repv p_tip_private), rep_Subr4)
++{
++ GtkTooltips* c_tooltips;
++ GtkWidget* c_widget;
++ char* c_tip_text;
++ char* c_tip_private;
++
++ rep_DECLARE (1, p_tooltips, sgtk_is_a_gobj (gtk_tooltips_get_type (), p_tooltips));
++ rep_DECLARE (2, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ if (p_tip_text != Qnil)
++ rep_DECLARE (3, p_tip_text, sgtk_valid_string (p_tip_text));
++ rep_DECLARE (4, p_tip_private, sgtk_valid_string (p_tip_private));
++
++ c_tooltips = (GtkTooltips*) sgtk_get_gobj (p_tooltips);
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ if (p_tip_text == Qnil)
++ c_tip_text = 0;
++ else
++ c_tip_text = sgtk_rep_to_string (p_tip_text);
++ c_tip_private = sgtk_rep_to_string (p_tip_private);
++
++ gtk_tooltips_set_tip (c_tooltips, c_widget, c_tip_text, c_tip_private);
++
++ return Qnil;
++}
++
++DEFUN("gtk-tooltips-force-window", Fgtk_tooltips_force_window, Sgtk_tooltips_force_window, (repv p_tooltips), rep_Subr1)
++{
++ GtkTooltips* c_tooltips;
++
++ rep_DECLARE (1, p_tooltips, sgtk_is_a_gobj (gtk_tooltips_get_type (), p_tooltips));
++
++ c_tooltips = (GtkTooltips*) sgtk_get_gobj (p_tooltips);
++
++ gtk_tooltips_force_window (c_tooltips);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-shell-append", Fgtk_menu_shell_append, Sgtk_menu_shell_append, (repv p_menu_shell, repv p_child), rep_Subr2)
++{
++ GtkMenuShell* c_menu_shell;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_menu_shell, sgtk_is_a_gobj (gtk_menu_shell_get_type (), p_menu_shell));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_menu_shell = (GtkMenuShell*) sgtk_get_gobj (p_menu_shell);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_menu_shell_append (c_menu_shell, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-shell-prepend", Fgtk_menu_shell_prepend, Sgtk_menu_shell_prepend, (repv p_menu_shell, repv p_child), rep_Subr2)
++{
++ GtkMenuShell* c_menu_shell;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_menu_shell, sgtk_is_a_gobj (gtk_menu_shell_get_type (), p_menu_shell));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_menu_shell = (GtkMenuShell*) sgtk_get_gobj (p_menu_shell);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_menu_shell_prepend (c_menu_shell, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-shell-insert", Fgtk_menu_shell_insert, Sgtk_menu_shell_insert, (repv p_menu_shell, repv p_child, repv p_position), rep_Subr3)
++{
++ GtkMenuShell* c_menu_shell;
++ GtkWidget* c_child;
++ gint c_position;
++
++ rep_DECLARE (1, p_menu_shell, sgtk_is_a_gobj (gtk_menu_shell_get_type (), p_menu_shell));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_position, sgtk_valid_int (p_position));
++
++ c_menu_shell = (GtkMenuShell*) sgtk_get_gobj (p_menu_shell);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_menu_shell_insert (c_menu_shell, c_child, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-shell-deactivate", Fgtk_menu_shell_deactivate, Sgtk_menu_shell_deactivate, (repv p_menu_shell), rep_Subr1)
++{
++ GtkMenuShell* c_menu_shell;
++
++ rep_DECLARE (1, p_menu_shell, sgtk_is_a_gobj (gtk_menu_shell_get_type (), p_menu_shell));
++
++ c_menu_shell = (GtkMenuShell*) sgtk_get_gobj (p_menu_shell);
++
++ gtk_menu_shell_deactivate (c_menu_shell);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-shell-select-item", Fgtk_menu_shell_select_item, Sgtk_menu_shell_select_item, (repv p_menu_shell, repv p_menu_item), rep_Subr2)
++{
++ GtkMenuShell* c_menu_shell;
++ GtkWidget* c_menu_item;
++
++ rep_DECLARE (1, p_menu_shell, sgtk_is_a_gobj (gtk_menu_shell_get_type (), p_menu_shell));
++ rep_DECLARE (2, p_menu_item, sgtk_is_a_gobj (gtk_widget_get_type (), p_menu_item));
++
++ c_menu_shell = (GtkMenuShell*) sgtk_get_gobj (p_menu_shell);
++ c_menu_item = (GtkWidget*) sgtk_get_gobj (p_menu_item);
++
++ gtk_menu_shell_select_item (c_menu_shell, c_menu_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-shell-deselect", Fgtk_menu_shell_deselect, Sgtk_menu_shell_deselect, (repv p_menu_shell), rep_Subr1)
++{
++ GtkMenuShell* c_menu_shell;
++
++ rep_DECLARE (1, p_menu_shell, sgtk_is_a_gobj (gtk_menu_shell_get_type (), p_menu_shell));
++
++ c_menu_shell = (GtkMenuShell*) sgtk_get_gobj (p_menu_shell);
++
++ gtk_menu_shell_deselect (c_menu_shell);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-shell-activate-item", Fgtk_menu_shell_activate_item, Sgtk_menu_shell_activate_item, (repv p_menu_shell, repv p_menu_item, repv p_force_deactivate), rep_Subr3)
++{
++ GtkMenuShell* c_menu_shell;
++ GtkWidget* c_menu_item;
++ int c_force_deactivate;
++
++ rep_DECLARE (1, p_menu_shell, sgtk_is_a_gobj (gtk_menu_shell_get_type (), p_menu_shell));
++ rep_DECLARE (2, p_menu_item, sgtk_is_a_gobj (gtk_widget_get_type (), p_menu_item));
++
++ c_menu_shell = (GtkMenuShell*) sgtk_get_gobj (p_menu_shell);
++ c_menu_item = (GtkWidget*) sgtk_get_gobj (p_menu_item);
++ c_force_deactivate = sgtk_rep_to_bool (p_force_deactivate);
++
++ gtk_menu_shell_activate_item (c_menu_shell, c_menu_item, c_force_deactivate);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-bar-new", Fgtk_menu_bar_new, Sgtk_menu_bar_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_menu_bar_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-new", Fgtk_menu_new, Sgtk_menu_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_menu_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-popup-interp", Fgtk_menu_popup_interp, Sgtk_menu_popup_interp, (repv args), rep_SubrN)
++{
++ repv p_menu, p_parent_menu_shell, p_parent_menu_item, p_button, p_activate_time, p_position;
++
++ GtkMenu* c_menu;
++ GtkWidget* c_parent_menu_shell;
++ GtkWidget* c_parent_menu_item;
++ guint c_button;
++ guint c_activate_time;
++ repv c_position;
++
++ if (!rep_CONSP(args))
++ p_menu = Qnil;
++ else {
++ p_menu = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_parent_menu_shell = Qnil;
++ else {
++ p_parent_menu_shell = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_parent_menu_item = Qnil;
++ else {
++ p_parent_menu_item = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_button = Qnil;
++ else {
++ p_button = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_activate_time = Qnil;
++ else {
++ p_activate_time = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_position = Qnil;
++ else {
++ p_position = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++ if (p_parent_menu_shell != Qnil)
++ rep_DECLARE (2, p_parent_menu_shell, sgtk_is_a_gobj (gtk_widget_get_type (), p_parent_menu_shell));
++ if (p_parent_menu_item != Qnil)
++ rep_DECLARE (3, p_parent_menu_item, sgtk_is_a_gobj (gtk_widget_get_type (), p_parent_menu_item));
++ rep_DECLARE (4, p_button, sgtk_valid_uint (p_button));
++ rep_DECLARE (5, p_activate_time, sgtk_valid_uint (p_activate_time));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++ if (p_parent_menu_shell == Qnil)
++ c_parent_menu_shell = 0;
++ else
++ c_parent_menu_shell = (GtkWidget*) sgtk_get_gobj (p_parent_menu_shell);
++ if (p_parent_menu_item == Qnil)
++ c_parent_menu_item = 0;
++ else
++ c_parent_menu_item = (GtkWidget*) sgtk_get_gobj (p_parent_menu_item);
++ c_button = sgtk_rep_to_uint (p_button);
++ c_activate_time = sgtk_rep_to_uint (p_activate_time);
++ c_position = (p_position);
++
++ gtk_menu_popup_interp (c_menu, c_parent_menu_shell, c_parent_menu_item, c_button, c_activate_time, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-reposition", Fgtk_menu_reposition, Sgtk_menu_reposition, (repv p_menu), rep_Subr1)
++{
++ GtkMenu* c_menu;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++
++ gtk_menu_reposition (c_menu);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-popdown", Fgtk_menu_popdown, Sgtk_menu_popdown, (repv p_menu), rep_Subr1)
++{
++ GtkMenu* c_menu;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++
++ gtk_menu_popdown (c_menu);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-get-active", Fgtk_menu_get_active, Sgtk_menu_get_active, (repv p_menu), rep_Subr1)
++{
++ repv pr_ret;
++ GtkMenu* c_menu;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++
++ cr_ret = gtk_menu_get_active (c_menu);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-set-active", Fgtk_menu_set_active, Sgtk_menu_set_active, (repv p_menu, repv p_index), rep_Subr2)
++{
++ GtkMenu* c_menu;
++ guint c_index;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++ rep_DECLARE (2, p_index, sgtk_valid_uint (p_index));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++ c_index = sgtk_rep_to_uint (p_index);
++
++ gtk_menu_set_active (c_menu, c_index);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-set-accel-group", Fgtk_menu_set_accel_group, Sgtk_menu_set_accel_group, (repv p_menu, repv p_accel_group), rep_Subr2)
++{
++ GtkMenu* c_menu;
++ GtkAccelGroup* c_accel_group;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++ rep_DECLARE (2, p_accel_group, sgtk_is_a_gobj (gtk_accel_group_get_type (), p_accel_group));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++ c_accel_group = (GtkAccelGroup*) sgtk_get_gobj (p_accel_group);
++
++ gtk_menu_set_accel_group (c_menu, c_accel_group);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-get-accel-group", Fgtk_menu_get_accel_group, Sgtk_menu_get_accel_group, (repv p_menu), rep_Subr1)
++{
++ repv pr_ret;
++ GtkMenu* c_menu;
++ GtkAccelGroup* cr_ret;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++
++ cr_ret = gtk_menu_get_accel_group (c_menu);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-set-accel-path", Fgtk_menu_set_accel_path, Sgtk_menu_set_accel_path, (repv p_menu, repv p_accel_path), rep_Subr2)
++{
++ GtkMenu* c_menu;
++ char* c_accel_path;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++ rep_DECLARE (2, p_accel_path, sgtk_valid_string (p_accel_path));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++ c_accel_path = sgtk_rep_to_string (p_accel_path);
++
++ gtk_menu_set_accel_path (c_menu, c_accel_path);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-detach", Fgtk_menu_detach, Sgtk_menu_detach, (repv p_menu), rep_Subr1)
++{
++ GtkMenu* c_menu;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++
++ gtk_menu_detach (c_menu);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-get-attach-widget", Fgtk_menu_get_attach_widget, Sgtk_menu_get_attach_widget, (repv p_menu), rep_Subr1)
++{
++ repv pr_ret;
++ GtkMenu* c_menu;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++
++ cr_ret = gtk_menu_get_attach_widget (c_menu);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-set-tearoff-state", Fgtk_menu_set_tearoff_state, Sgtk_menu_set_tearoff_state, (repv p_menu, repv p_torn_off), rep_Subr2)
++{
++ GtkMenu* c_menu;
++ int c_torn_off;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++ c_torn_off = sgtk_rep_to_bool (p_torn_off);
++
++ gtk_menu_set_tearoff_state (c_menu, c_torn_off);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-get-tearoff-state", Fgtk_menu_get_tearoff_state, Sgtk_menu_get_tearoff_state, (repv p_menu), rep_Subr1)
++{
++ repv pr_ret;
++ GtkMenu* c_menu;
++ int cr_ret;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++
++ cr_ret = gtk_menu_get_tearoff_state (c_menu);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-set-title", Fgtk_menu_set_title, Sgtk_menu_set_title, (repv p_menu, repv p_title), rep_Subr2)
++{
++ GtkMenu* c_menu;
++ char* c_title;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++ rep_DECLARE (2, p_title, sgtk_valid_string (p_title));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++ c_title = sgtk_rep_to_string (p_title);
++
++ gtk_menu_set_title (c_menu, c_title);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-get-title", Fgtk_menu_get_title, Sgtk_menu_get_title, (repv p_menu), rep_Subr1)
++{
++ repv pr_ret;
++ GtkMenu* c_menu;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++
++ cr_ret = gtk_menu_get_title (c_menu);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-reorder-child", Fgtk_menu_reorder_child, Sgtk_menu_reorder_child, (repv p_menu, repv p_child, repv p_position), rep_Subr3)
++{
++ GtkMenu* c_menu;
++ GtkWidget* c_child;
++ gint c_position;
++
++ rep_DECLARE (1, p_menu, sgtk_is_a_gobj (gtk_menu_get_type (), p_menu));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_position, sgtk_valid_int (p_position));
++
++ c_menu = (GtkMenu*) sgtk_get_gobj (p_menu);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_menu_reorder_child (c_menu, c_child, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-item-new", Fgtk_menu_item_new, Sgtk_menu_item_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_menu_item_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-item-new-with-label", Fgtk_menu_item_new_with_label, Sgtk_menu_item_new_with_label, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_menu_item_new_with_label (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-item-new-with-mnemonic", Fgtk_menu_item_new_with_mnemonic, Sgtk_menu_item_new_with_mnemonic, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_menu_item_new_with_mnemonic (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-item-set-submenu", Fgtk_menu_item_set_submenu, Sgtk_menu_item_set_submenu, (repv p_menu_item, repv p_submenu), rep_Subr2)
++{
++ GtkMenuItem* c_menu_item;
++ GtkWidget* c_submenu;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_menu_item_get_type (), p_menu_item));
++ rep_DECLARE (2, p_submenu, sgtk_is_a_gobj (gtk_widget_get_type (), p_submenu));
++
++ c_menu_item = (GtkMenuItem*) sgtk_get_gobj (p_menu_item);
++ c_submenu = (GtkWidget*) sgtk_get_gobj (p_submenu);
++
++ gtk_menu_item_set_submenu (c_menu_item, c_submenu);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-item-get-submenu", Fgtk_menu_item_get_submenu, Sgtk_menu_item_get_submenu, (repv p_menu_item), rep_Subr1)
++{
++ repv pr_ret;
++ GtkMenuItem* c_menu_item;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_menu_item_get_type (), p_menu_item));
++
++ c_menu_item = (GtkMenuItem*) sgtk_get_gobj (p_menu_item);
++
++ cr_ret = gtk_menu_item_get_submenu (c_menu_item);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-item-remove-submenu", Fgtk_menu_item_remove_submenu, Sgtk_menu_item_remove_submenu, (repv p_menu_item), rep_Subr1)
++{
++ GtkMenuItem* c_menu_item;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_menu_item_get_type (), p_menu_item));
++
++ c_menu_item = (GtkMenuItem*) sgtk_get_gobj (p_menu_item);
++
++ gtk_menu_item_remove_submenu (c_menu_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-item-select", Fgtk_menu_item_select, Sgtk_menu_item_select, (repv p_menu_item), rep_Subr1)
++{
++ GtkMenuItem* c_menu_item;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_menu_item_get_type (), p_menu_item));
++
++ c_menu_item = (GtkMenuItem*) sgtk_get_gobj (p_menu_item);
++
++ gtk_menu_item_select (c_menu_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-item-deselect", Fgtk_menu_item_deselect, Sgtk_menu_item_deselect, (repv p_menu_item), rep_Subr1)
++{
++ GtkMenuItem* c_menu_item;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_menu_item_get_type (), p_menu_item));
++
++ c_menu_item = (GtkMenuItem*) sgtk_get_gobj (p_menu_item);
++
++ gtk_menu_item_deselect (c_menu_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-item-activate", Fgtk_menu_item_activate, Sgtk_menu_item_activate, (repv p_menu_item), rep_Subr1)
++{
++ GtkMenuItem* c_menu_item;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_menu_item_get_type (), p_menu_item));
++
++ c_menu_item = (GtkMenuItem*) sgtk_get_gobj (p_menu_item);
++
++ gtk_menu_item_activate (c_menu_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-item-set-right-justified", Fgtk_menu_item_set_right_justified, Sgtk_menu_item_set_right_justified, (repv p_menu_item, repv p_setting), rep_Subr2)
++{
++ GtkMenuItem* c_menu_item;
++ int c_setting;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_menu_item_get_type (), p_menu_item));
++
++ c_menu_item = (GtkMenuItem*) sgtk_get_gobj (p_menu_item);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_menu_item_set_right_justified (c_menu_item, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-menu-item-get-right-justified", Fgtk_menu_item_get_right_justified, Sgtk_menu_item_get_right_justified, (repv p_menu_item), rep_Subr1)
++{
++ repv pr_ret;
++ GtkMenuItem* c_menu_item;
++ int cr_ret;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_menu_item_get_type (), p_menu_item));
++
++ c_menu_item = (GtkMenuItem*) sgtk_get_gobj (p_menu_item);
++
++ cr_ret = gtk_menu_item_get_right_justified (c_menu_item);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-menu-item-set-accel-path", Fgtk_menu_item_set_accel_path, Sgtk_menu_item_set_accel_path, (repv p_menu_item, repv p_accel_path), rep_Subr2)
++{
++ GtkMenuItem* c_menu_item;
++ char* c_accel_path;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_menu_item_get_type (), p_menu_item));
++ rep_DECLARE (2, p_accel_path, sgtk_valid_string (p_accel_path));
++
++ c_menu_item = (GtkMenuItem*) sgtk_get_gobj (p_menu_item);
++ c_accel_path = sgtk_rep_to_string (p_accel_path);
++
++ gtk_menu_item_set_accel_path (c_menu_item, c_accel_path);
++
++ return Qnil;
++}
++
++DEFUN("gtk-check-menu-item-new", Fgtk_check_menu_item_new, Sgtk_check_menu_item_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_check_menu_item_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-check-menu-item-new-with-label", Fgtk_check_menu_item_new_with_label, Sgtk_check_menu_item_new_with_label, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_check_menu_item_new_with_label (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-check-menu-item-new-with-mnemonic", Fgtk_check_menu_item_new_with_mnemonic, Sgtk_check_menu_item_new_with_mnemonic, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_check_menu_item_new_with_mnemonic (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-check-menu-item-set-active", Fgtk_check_menu_item_set_active, Sgtk_check_menu_item_set_active, (repv p_check_menu_item, repv p_is_active), rep_Subr2)
++{
++ GtkCheckMenuItem* c_check_menu_item;
++ int c_is_active;
++
++ rep_DECLARE (1, p_check_menu_item, sgtk_is_a_gobj (gtk_check_menu_item_get_type (), p_check_menu_item));
++
++ c_check_menu_item = (GtkCheckMenuItem*) sgtk_get_gobj (p_check_menu_item);
++ c_is_active = sgtk_rep_to_bool (p_is_active);
++
++ gtk_check_menu_item_set_active (c_check_menu_item, c_is_active);
++
++ return Qnil;
++}
++
++DEFUN("gtk-check-menu-item-get-active", Fgtk_check_menu_item_get_active, Sgtk_check_menu_item_get_active, (repv p_check_menu_item), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCheckMenuItem* c_check_menu_item;
++ int cr_ret;
++
++ rep_DECLARE (1, p_check_menu_item, sgtk_is_a_gobj (gtk_check_menu_item_get_type (), p_check_menu_item));
++
++ c_check_menu_item = (GtkCheckMenuItem*) sgtk_get_gobj (p_check_menu_item);
++
++ cr_ret = gtk_check_menu_item_get_active (c_check_menu_item);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-check-menu-item-toggled", Fgtk_check_menu_item_toggled, Sgtk_check_menu_item_toggled, (repv p_check_menu_item), rep_Subr1)
++{
++ GtkCheckMenuItem* c_check_menu_item;
++
++ rep_DECLARE (1, p_check_menu_item, sgtk_is_a_gobj (gtk_check_menu_item_get_type (), p_check_menu_item));
++
++ c_check_menu_item = (GtkCheckMenuItem*) sgtk_get_gobj (p_check_menu_item);
++
++ gtk_check_menu_item_toggled (c_check_menu_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-check-menu-item-set-inconsistent", Fgtk_check_menu_item_set_inconsistent, Sgtk_check_menu_item_set_inconsistent, (repv p_menu_item, repv p_setting), rep_Subr2)
++{
++ GtkCheckMenuItem* c_menu_item;
++ int c_setting;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_check_menu_item_get_type (), p_menu_item));
++
++ c_menu_item = (GtkCheckMenuItem*) sgtk_get_gobj (p_menu_item);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_check_menu_item_set_inconsistent (c_menu_item, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-check-menu-item-get-inconsistent", Fgtk_check_menu_item_get_inconsistent, Sgtk_check_menu_item_get_inconsistent, (repv p_menu_item), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCheckMenuItem* c_menu_item;
++ int cr_ret;
++
++ rep_DECLARE (1, p_menu_item, sgtk_is_a_gobj (gtk_check_menu_item_get_type (), p_menu_item));
++
++ c_menu_item = (GtkCheckMenuItem*) sgtk_get_gobj (p_menu_item);
++
++ cr_ret = gtk_check_menu_item_get_inconsistent (c_menu_item);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-radio-menu-item-new-from-widget", Fgtk_radio_menu_item_new_from_widget, Sgtk_radio_menu_item_new_from_widget, (repv p_group), rep_Subr1)
++{
++ repv pr_ret;
++ GtkRadioMenuItem* c_group;
++ GtkWidget* cr_ret;
++
++ if (p_group != Qnil)
++ rep_DECLARE (1, p_group, sgtk_is_a_gobj (gtk_radio_menu_item_get_type (), p_group));
++
++ if (p_group == Qnil)
++ c_group = 0;
++ else
++ c_group = (GtkRadioMenuItem*) sgtk_get_gobj (p_group);
++
++ cr_ret = wrapper_gtk_radio_menu_item_new_from_widget (c_group);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-radio-menu-item-new-with-label-from-widget", Fgtk_radio_menu_item_new_with_label_from_widget, Sgtk_radio_menu_item_new_with_label_from_widget, (repv p_group, repv p_label), rep_Subr2)
++{
++ repv pr_ret;
++ GtkRadioMenuItem* c_group;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ if (p_group != Qnil)
++ rep_DECLARE (1, p_group, sgtk_is_a_gobj (gtk_radio_menu_item_get_type (), p_group));
++ rep_DECLARE (2, p_label, sgtk_valid_string (p_label));
++
++ if (p_group == Qnil)
++ c_group = 0;
++ else
++ c_group = (GtkRadioMenuItem*) sgtk_get_gobj (p_group);
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = wrapper_gtk_radio_menu_item_new_with_label_from_widget (c_group, c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-radio-menu-item-new-with-mnemonic-from-widget", Fgtk_radio_menu_item_new_with_mnemonic_from_widget, Sgtk_radio_menu_item_new_with_mnemonic_from_widget, (repv p_group, repv p_label), rep_Subr2)
++{
++ repv pr_ret;
++ GtkRadioMenuItem* c_group;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ if (p_group != Qnil)
++ rep_DECLARE (1, p_group, sgtk_is_a_gobj (gtk_radio_menu_item_get_type (), p_group));
++ rep_DECLARE (2, p_label, sgtk_valid_string (p_label));
++
++ if (p_group == Qnil)
++ c_group = 0;
++ else
++ c_group = (GtkRadioMenuItem*) sgtk_get_gobj (p_group);
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = wrapper_gtk_radio_menu_item_new_with_mnemonic_from_widget (c_group, c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-option-menu-new", Fgtk_option_menu_new, Sgtk_option_menu_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_option_menu_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-option-menu-get-menu", Fgtk_option_menu_get_menu, Sgtk_option_menu_get_menu, (repv p_option_menu), rep_Subr1)
++{
++ repv pr_ret;
++ GtkOptionMenu* c_option_menu;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_option_menu, sgtk_is_a_gobj (gtk_option_menu_get_type (), p_option_menu));
++
++ c_option_menu = (GtkOptionMenu*) sgtk_get_gobj (p_option_menu);
++
++ cr_ret = gtk_option_menu_get_menu (c_option_menu);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-option-menu-set-menu", Fgtk_option_menu_set_menu, Sgtk_option_menu_set_menu, (repv p_option_menu, repv p_menu), rep_Subr2)
++{
++ GtkOptionMenu* c_option_menu;
++ GtkWidget* c_menu;
++
++ rep_DECLARE (1, p_option_menu, sgtk_is_a_gobj (gtk_option_menu_get_type (), p_option_menu));
++ rep_DECLARE (2, p_menu, sgtk_is_a_gobj (gtk_widget_get_type (), p_menu));
++
++ c_option_menu = (GtkOptionMenu*) sgtk_get_gobj (p_option_menu);
++ c_menu = (GtkWidget*) sgtk_get_gobj (p_menu);
++
++ gtk_option_menu_set_menu (c_option_menu, c_menu);
++
++ return Qnil;
++}
++
++DEFUN("gtk-option-menu-remove-menu", Fgtk_option_menu_remove_menu, Sgtk_option_menu_remove_menu, (repv p_option_menu), rep_Subr1)
++{
++ GtkOptionMenu* c_option_menu;
++
++ rep_DECLARE (1, p_option_menu, sgtk_is_a_gobj (gtk_option_menu_get_type (), p_option_menu));
++
++ c_option_menu = (GtkOptionMenu*) sgtk_get_gobj (p_option_menu);
++
++ gtk_option_menu_remove_menu (c_option_menu);
++
++ return Qnil;
++}
++
++DEFUN("gtk-option-menu-get-history", Fgtk_option_menu_get_history, Sgtk_option_menu_get_history, (repv p_option_menu), rep_Subr1)
++{
++ repv pr_ret;
++ GtkOptionMenu* c_option_menu;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_option_menu, sgtk_is_a_gobj (gtk_option_menu_get_type (), p_option_menu));
++
++ c_option_menu = (GtkOptionMenu*) sgtk_get_gobj (p_option_menu);
++
++ cr_ret = gtk_option_menu_get_history (c_option_menu);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-option-menu-set-history", Fgtk_option_menu_set_history, Sgtk_option_menu_set_history, (repv p_option_menu, repv p_index), rep_Subr2)
++{
++ GtkOptionMenu* c_option_menu;
++ gint c_index;
++
++ rep_DECLARE (1, p_option_menu, sgtk_is_a_gobj (gtk_option_menu_get_type (), p_option_menu));
++ rep_DECLARE (2, p_index, sgtk_valid_int (p_index));
++
++ c_option_menu = (GtkOptionMenu*) sgtk_get_gobj (p_option_menu);
++ c_index = sgtk_rep_to_int (p_index);
++
++ gtk_option_menu_set_history (c_option_menu, c_index);
++
++ return Qnil;
++}
++
++DEFUN("gtk-pixmap-new-interp", Fgtk_pixmap_new_interp, Sgtk_pixmap_new_interp, (repv p_xpm_file, repv p_intended_parent), rep_Subr2)
++{
++ repv pr_ret;
++ char* c_xpm_file;
++ GtkWidget* c_intended_parent;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_xpm_file, sgtk_valid_string (p_xpm_file));
++ rep_DECLARE (2, p_intended_parent, sgtk_is_a_gobj (gtk_widget_get_type (), p_intended_parent));
++
++ c_xpm_file = sgtk_rep_to_string (p_xpm_file);
++ c_intended_parent = (GtkWidget*) sgtk_get_gobj (p_intended_parent);
++
++ cr_ret = gtk_pixmap_new_interp (c_xpm_file, c_intended_parent);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-viewport-new", Fgtk_viewport_new, Sgtk_viewport_new, (repv p_hadjustment, repv p_vadjustment), rep_Subr2)
++{
++ repv pr_ret;
++ GtkAdjustment* c_hadjustment;
++ GtkAdjustment* c_vadjustment;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_hadjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_hadjustment));
++ rep_DECLARE (2, p_vadjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_vadjustment));
++
++ c_hadjustment = (GtkAdjustment*) sgtk_get_gobj (p_hadjustment);
++ c_vadjustment = (GtkAdjustment*) sgtk_get_gobj (p_vadjustment);
++
++ cr_ret = gtk_viewport_new (c_hadjustment, c_vadjustment);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-viewport-get-hadjustment", Fgtk_viewport_get_hadjustment, Sgtk_viewport_get_hadjustment, (repv p_viewport), rep_Subr1)
++{
++ repv pr_ret;
++ GtkViewport* c_viewport;
++ GtkAdjustment* cr_ret;
++
++ rep_DECLARE (1, p_viewport, sgtk_is_a_gobj (gtk_viewport_get_type (), p_viewport));
++
++ c_viewport = (GtkViewport*) sgtk_get_gobj (p_viewport);
++
++ cr_ret = gtk_viewport_get_hadjustment (c_viewport);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-viewport-get-vadjustment", Fgtk_viewport_get_vadjustment, Sgtk_viewport_get_vadjustment, (repv p_viewport), rep_Subr1)
++{
++ repv pr_ret;
++ GtkViewport* c_viewport;
++ GtkAdjustment* cr_ret;
++
++ rep_DECLARE (1, p_viewport, sgtk_is_a_gobj (gtk_viewport_get_type (), p_viewport));
++
++ c_viewport = (GtkViewport*) sgtk_get_gobj (p_viewport);
++
++ cr_ret = gtk_viewport_get_vadjustment (c_viewport);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-viewport-set-hadjustment", Fgtk_viewport_set_hadjustment, Sgtk_viewport_set_hadjustment, (repv p_viewport, repv p_adjustment), rep_Subr2)
++{
++ GtkViewport* c_viewport;
++ GtkAdjustment* c_adjustment;
++
++ rep_DECLARE (1, p_viewport, sgtk_is_a_gobj (gtk_viewport_get_type (), p_viewport));
++ rep_DECLARE (2, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_viewport = (GtkViewport*) sgtk_get_gobj (p_viewport);
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ gtk_viewport_set_hadjustment (c_viewport, c_adjustment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-viewport-set-vadjustment", Fgtk_viewport_set_vadjustment, Sgtk_viewport_set_vadjustment, (repv p_viewport, repv p_adjustment), rep_Subr2)
++{
++ GtkViewport* c_viewport;
++ GtkAdjustment* c_adjustment;
++
++ rep_DECLARE (1, p_viewport, sgtk_is_a_gobj (gtk_viewport_get_type (), p_viewport));
++ rep_DECLARE (2, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_viewport = (GtkViewport*) sgtk_get_gobj (p_viewport);
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ gtk_viewport_set_vadjustment (c_viewport, c_adjustment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-viewport-set-shadow-type", Fgtk_viewport_set_shadow_type, Sgtk_viewport_set_shadow_type, (repv p_viewport, repv p_type), rep_Subr2)
++{
++ GtkViewport* c_viewport;
++ GtkShadowType c_type;
++
++ rep_DECLARE (1, p_viewport, sgtk_is_a_gobj (gtk_viewport_get_type (), p_viewport));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_shadow_type_info));
++
++ c_viewport = (GtkViewport*) sgtk_get_gobj (p_viewport);
++ c_type = (GtkShadowType) sgtk_rep_to_enum (p_type, &sgtk_gtk_shadow_type_info);
++
++ gtk_viewport_set_shadow_type (c_viewport, c_type);
++
++ return Qnil;
++}
++
++DEFUN("gtk-viewport-get-shadow-type", Fgtk_viewport_get_shadow_type, Sgtk_viewport_get_shadow_type, (repv p_viewport), rep_Subr1)
++{
++ repv pr_ret;
++ GtkViewport* c_viewport;
++ GtkShadowType cr_ret;
++
++ rep_DECLARE (1, p_viewport, sgtk_is_a_gobj (gtk_viewport_get_type (), p_viewport));
++
++ c_viewport = (GtkViewport*) sgtk_get_gobj (p_viewport);
++
++ cr_ret = gtk_viewport_get_shadow_type (c_viewport);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_shadow_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-scrolled-window-new", Fgtk_scrolled_window_new, Sgtk_scrolled_window_new, (repv p_hadjustment, repv p_vadjustment), rep_Subr2)
++{
++ repv pr_ret;
++ GtkAdjustment* c_hadjustment;
++ GtkAdjustment* c_vadjustment;
++ GtkWidget* cr_ret;
++
++
++ if (p_hadjustment == Qnil)
++ c_hadjustment = 0;
++ else
++ if (p_hadjustment == Qnil)
++ c_hadjustment = NULL;
++ else
++ c_hadjustment = (GtkAdjustment*) sgtk_get_gobj (p_hadjustment);
++ if (p_vadjustment == Qnil)
++ c_vadjustment = 0;
++ else
++ if (p_vadjustment == Qnil)
++ c_vadjustment = NULL;
++ else
++ c_vadjustment = (GtkAdjustment*) sgtk_get_gobj (p_vadjustment);
++
++ cr_ret = gtk_scrolled_window_new (c_hadjustment, c_vadjustment);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-scrolled-window-set-hadjustment", Fgtk_scrolled_window_set_hadjustment, Sgtk_scrolled_window_set_hadjustment, (repv p_scrolled_window, repv p_hadjustment), rep_Subr2)
++{
++ GtkScrolledWindow* c_scrolled_window;
++ GtkAdjustment* c_hadjustment;
++
++ rep_DECLARE (1, p_scrolled_window, sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_scrolled_window));
++ rep_DECLARE (2, p_hadjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_hadjustment));
++
++ c_scrolled_window = (GtkScrolledWindow*) sgtk_get_gobj (p_scrolled_window);
++ c_hadjustment = (GtkAdjustment*) sgtk_get_gobj (p_hadjustment);
++
++ gtk_scrolled_window_set_hadjustment (c_scrolled_window, c_hadjustment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-scrolled-window-set-vadjustment", Fgtk_scrolled_window_set_vadjustment, Sgtk_scrolled_window_set_vadjustment, (repv p_scrolled_window, repv p_vadjustment), rep_Subr2)
++{
++ GtkScrolledWindow* c_scrolled_window;
++ GtkAdjustment* c_vadjustment;
++
++ rep_DECLARE (1, p_scrolled_window, sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_scrolled_window));
++ rep_DECLARE (2, p_vadjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_vadjustment));
++
++ c_scrolled_window = (GtkScrolledWindow*) sgtk_get_gobj (p_scrolled_window);
++ c_vadjustment = (GtkAdjustment*) sgtk_get_gobj (p_vadjustment);
++
++ gtk_scrolled_window_set_vadjustment (c_scrolled_window, c_vadjustment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-scrolled-window-get-hadjustment", Fgtk_scrolled_window_get_hadjustment, Sgtk_scrolled_window_get_hadjustment, (repv p_scrolled_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkScrolledWindow* c_scrolled_window;
++ GtkAdjustment* cr_ret;
++
++ rep_DECLARE (1, p_scrolled_window, sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_scrolled_window));
++
++ c_scrolled_window = (GtkScrolledWindow*) sgtk_get_gobj (p_scrolled_window);
++
++ cr_ret = gtk_scrolled_window_get_hadjustment (c_scrolled_window);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-scrolled-window-get-vadjustment", Fgtk_scrolled_window_get_vadjustment, Sgtk_scrolled_window_get_vadjustment, (repv p_scrolled_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkScrolledWindow* c_scrolled_window;
++ GtkAdjustment* cr_ret;
++
++ rep_DECLARE (1, p_scrolled_window, sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_scrolled_window));
++
++ c_scrolled_window = (GtkScrolledWindow*) sgtk_get_gobj (p_scrolled_window);
++
++ cr_ret = gtk_scrolled_window_get_vadjustment (c_scrolled_window);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-scrolled-window-set-policy", Fgtk_scrolled_window_set_policy, Sgtk_scrolled_window_set_policy, (repv p_scrolled_window, repv p_hscrollbar_policy, repv p_vscrollbar_policy), rep_Subr3)
++{
++ GtkScrolledWindow* c_scrolled_window;
++ GtkPolicyType c_hscrollbar_policy;
++ GtkPolicyType c_vscrollbar_policy;
++
++ rep_DECLARE (1, p_scrolled_window, sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_scrolled_window));
++ rep_DECLARE (2, p_hscrollbar_policy, sgtk_valid_enum (p_hscrollbar_policy, &sgtk_gtk_policy_type_info));
++ rep_DECLARE (3, p_vscrollbar_policy, sgtk_valid_enum (p_vscrollbar_policy, &sgtk_gtk_policy_type_info));
++
++ c_scrolled_window = (GtkScrolledWindow*) sgtk_get_gobj (p_scrolled_window);
++ c_hscrollbar_policy = (GtkPolicyType) sgtk_rep_to_enum (p_hscrollbar_policy, &sgtk_gtk_policy_type_info);
++ c_vscrollbar_policy = (GtkPolicyType) sgtk_rep_to_enum (p_vscrollbar_policy, &sgtk_gtk_policy_type_info);
++
++ gtk_scrolled_window_set_policy (c_scrolled_window, c_hscrollbar_policy, c_vscrollbar_policy);
++
++ return Qnil;
++}
++
++DEFUN("gtk-scrolled-window-set-placement", Fgtk_scrolled_window_set_placement, Sgtk_scrolled_window_set_placement, (repv p_scrolled_window, repv p_window_placement), rep_Subr2)
++{
++ GtkScrolledWindow* c_scrolled_window;
++ GtkCornerType c_window_placement;
++
++ rep_DECLARE (1, p_scrolled_window, sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_scrolled_window));
++ rep_DECLARE (2, p_window_placement, sgtk_valid_enum (p_window_placement, &sgtk_gtk_corner_type_info));
++
++ c_scrolled_window = (GtkScrolledWindow*) sgtk_get_gobj (p_scrolled_window);
++ c_window_placement = (GtkCornerType) sgtk_rep_to_enum (p_window_placement, &sgtk_gtk_corner_type_info);
++
++ gtk_scrolled_window_set_placement (c_scrolled_window, c_window_placement);
++
++ return Qnil;
++}
++
++DEFUN("gtk-scrolled-window-get-placement", Fgtk_scrolled_window_get_placement, Sgtk_scrolled_window_get_placement, (repv p_scrolled_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkScrolledWindow* c_scrolled_window;
++ GtkCornerType cr_ret;
++
++ rep_DECLARE (1, p_scrolled_window, sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_scrolled_window));
++
++ c_scrolled_window = (GtkScrolledWindow*) sgtk_get_gobj (p_scrolled_window);
++
++ cr_ret = gtk_scrolled_window_get_placement (c_scrolled_window);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_corner_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-scrolled-window-set-shadow-type", Fgtk_scrolled_window_set_shadow_type, Sgtk_scrolled_window_set_shadow_type, (repv p_scrolled_window, repv p_type), rep_Subr2)
++{
++ GtkScrolledWindow* c_scrolled_window;
++ GtkShadowType c_type;
++
++ rep_DECLARE (1, p_scrolled_window, sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_scrolled_window));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_shadow_type_info));
++
++ c_scrolled_window = (GtkScrolledWindow*) sgtk_get_gobj (p_scrolled_window);
++ c_type = (GtkShadowType) sgtk_rep_to_enum (p_type, &sgtk_gtk_shadow_type_info);
++
++ gtk_scrolled_window_set_shadow_type (c_scrolled_window, c_type);
++
++ return Qnil;
++}
++
++DEFUN("gtk-scrolled-window-get-shadow-type", Fgtk_scrolled_window_get_shadow_type, Sgtk_scrolled_window_get_shadow_type, (repv p_scrolled_window), rep_Subr1)
++{
++ repv pr_ret;
++ GtkScrolledWindow* c_scrolled_window;
++ GtkShadowType cr_ret;
++
++ rep_DECLARE (1, p_scrolled_window, sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_scrolled_window));
++
++ c_scrolled_window = (GtkScrolledWindow*) sgtk_get_gobj (p_scrolled_window);
++
++ cr_ret = gtk_scrolled_window_get_shadow_type (c_scrolled_window);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_shadow_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-scrolled-window-add-with-viewport", Fgtk_scrolled_window_add_with_viewport, Sgtk_scrolled_window_add_with_viewport, (repv p_scrolled_window, repv p_child), rep_Subr2)
++{
++ GtkScrolledWindow* c_scrolled_window;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_scrolled_window, sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_scrolled_window));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_scrolled_window = (GtkScrolledWindow*) sgtk_get_gobj (p_scrolled_window);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_scrolled_window_add_with_viewport (c_scrolled_window, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-item-new", Fgtk_list_item_new, Sgtk_list_item_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_list_item_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-list-item-new-with-label", Fgtk_list_item_new_with_label, Sgtk_list_item_new_with_label, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_list_item_new_with_label (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-list-item-select", Fgtk_list_item_select, Sgtk_list_item_select, (repv p_list_item), rep_Subr1)
++{
++ GtkListItem* c_list_item;
++
++ rep_DECLARE (1, p_list_item, sgtk_is_a_gobj (gtk_list_item_get_type (), p_list_item));
++
++ c_list_item = (GtkListItem*) sgtk_get_gobj (p_list_item);
++
++ gtk_list_item_select (c_list_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-item-deselect", Fgtk_list_item_deselect, Sgtk_list_item_deselect, (repv p_list_item), rep_Subr1)
++{
++ GtkListItem* c_list_item;
++
++ rep_DECLARE (1, p_list_item, sgtk_is_a_gobj (gtk_list_item_get_type (), p_list_item));
++
++ c_list_item = (GtkListItem*) sgtk_get_gobj (p_list_item);
++
++ gtk_list_item_deselect (c_list_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-new", Fgtk_list_new, Sgtk_list_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_list_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++/* helpers for GtkListItem */
++static int
++_sgtk_helper_valid_GtkListItem (repv obj)
++{
++ return obj == Qnil || (sgtk_is_a_gobj (gtk_list_item_get_type (), obj));
++}
++static void
++_sgtk_helper_fromrep_GtkListItem (repv obj, void *mem)
++{
++ *(GtkListItem**)mem = (GtkListItem*) sgtk_get_gobj (obj);
++}
++static repv
++_sgtk_helper_torep_copy_GtkListItem (void *mem)
++{
++ return sgtk_wrap_gobj ((GObject*) (*(GtkListItem**)mem));
++}
++static repv
++_sgtk_helper_torep_nocopy_GtkListItem (void *mem)
++{
++ return sgtk_wrap_gobj ((GObject*) (*(GtkListItem**)mem));
++}
++
++DEFUN("gtk-list-insert-items", Fgtk_list_insert_items, Sgtk_list_insert_items, (repv p_list, repv p_items, repv p_position), rep_Subr3)
++{
++ rep_GC_root gc_items;
++ GtkList* c_list;
++ GList* c_items;
++ gint c_position;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_items, sgtk_valid_composite (p_items, _sgtk_helper_valid_GtkListItem));
++ rep_DECLARE (3, p_position, sgtk_valid_int (p_position));
++
++ rep_PUSHGC (gc_items, p_items);
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_items = sgtk_rep_to_list (p_items, _sgtk_helper_fromrep_GtkListItem);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_list_insert_items (c_list, c_items, c_position);
++
++ sgtk_list_finish (c_items, p_items, 0);
++ rep_POPGC;
++ return Qnil;
++}
++
++DEFUN("gtk-list-append-items", Fgtk_list_append_items, Sgtk_list_append_items, (repv p_list, repv p_items), rep_Subr2)
++{
++ rep_GC_root gc_items;
++ GtkList* c_list;
++ GList* c_items;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_items, sgtk_valid_composite (p_items, _sgtk_helper_valid_GtkListItem));
++
++ rep_PUSHGC (gc_items, p_items);
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_items = sgtk_rep_to_list (p_items, _sgtk_helper_fromrep_GtkListItem);
++
++ gtk_list_append_items (c_list, c_items);
++
++ sgtk_list_finish (c_items, p_items, 0);
++ rep_POPGC;
++ return Qnil;
++}
++
++DEFUN("gtk-list-prepend-items", Fgtk_list_prepend_items, Sgtk_list_prepend_items, (repv p_list, repv p_items), rep_Subr2)
++{
++ rep_GC_root gc_items;
++ GtkList* c_list;
++ GList* c_items;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_items, sgtk_valid_composite (p_items, _sgtk_helper_valid_GtkListItem));
++
++ rep_PUSHGC (gc_items, p_items);
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_items = sgtk_rep_to_list (p_items, _sgtk_helper_fromrep_GtkListItem);
++
++ gtk_list_prepend_items (c_list, c_items);
++
++ sgtk_list_finish (c_items, p_items, 0);
++ rep_POPGC;
++ return Qnil;
++}
++
++DEFUN("gtk-list-remove-items", Fgtk_list_remove_items, Sgtk_list_remove_items, (repv p_list, repv p_items), rep_Subr2)
++{
++ rep_GC_root gc_items;
++ GtkList* c_list;
++ GList* c_items;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_items, sgtk_valid_composite (p_items, _sgtk_helper_valid_GtkListItem));
++
++ rep_PUSHGC (gc_items, p_items);
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_items = sgtk_rep_to_list (p_items, _sgtk_helper_fromrep_GtkListItem);
++
++ gtk_list_remove_items (c_list, c_items);
++
++ sgtk_list_finish (c_items, p_items, 0);
++ rep_POPGC;
++ return Qnil;
++}
++
++DEFUN("gtk-list-append-item", Fgtk_list_append_item, Sgtk_list_append_item, (repv p_list, repv p_item), rep_Subr2)
++{
++ GtkList* c_list;
++ GtkListItem* c_item;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_item, sgtk_is_a_gobj (gtk_list_item_get_type (), p_item));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_item = (GtkListItem*) sgtk_get_gobj (p_item);
++
++ gtk_list_append_item (c_list, c_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-prepend-item", Fgtk_list_prepend_item, Sgtk_list_prepend_item, (repv p_list, repv p_item), rep_Subr2)
++{
++ GtkList* c_list;
++ GtkListItem* c_item;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_item, sgtk_is_a_gobj (gtk_list_item_get_type (), p_item));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_item = (GtkListItem*) sgtk_get_gobj (p_item);
++
++ gtk_list_prepend_item (c_list, c_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-clear-items", Fgtk_list_clear_items, Sgtk_list_clear_items, (repv p_list, repv p_start, repv p_end), rep_Subr3)
++{
++ GtkList* c_list;
++ gint c_start;
++ gint c_end;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_start, sgtk_valid_int (p_start));
++ rep_DECLARE (3, p_end, sgtk_valid_int (p_end));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_start = sgtk_rep_to_int (p_start);
++ c_end = sgtk_rep_to_int (p_end);
++
++ gtk_list_clear_items (c_list, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-select-item", Fgtk_list_select_item, Sgtk_list_select_item, (repv p_list, repv p_item), rep_Subr2)
++{
++ GtkList* c_list;
++ gint c_item;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_item, sgtk_valid_int (p_item));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_item = sgtk_rep_to_int (p_item);
++
++ gtk_list_select_item (c_list, c_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-unselect-item", Fgtk_list_unselect_item, Sgtk_list_unselect_item, (repv p_list, repv p_item), rep_Subr2)
++{
++ GtkList* c_list;
++ gint c_item;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_item, sgtk_valid_int (p_item));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_item = sgtk_rep_to_int (p_item);
++
++ gtk_list_unselect_item (c_list, c_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-select-child", Fgtk_list_select_child, Sgtk_list_select_child, (repv p_list, repv p_child), rep_Subr2)
++{
++ GtkList* c_list;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_list_select_child (c_list, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-unselect-child", Fgtk_list_unselect_child, Sgtk_list_unselect_child, (repv p_list, repv p_child), rep_Subr2)
++{
++ GtkList* c_list;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_list_unselect_child (c_list, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-child-position", Fgtk_list_child_position, Sgtk_list_child_position, (repv p_list, repv p_child), rep_Subr2)
++{
++ repv pr_ret;
++ GtkList* c_list;
++ GtkWidget* c_child;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ cr_ret = gtk_list_child_position (c_list, c_child);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-list-set-selection-mode", Fgtk_list_set_selection_mode, Sgtk_list_set_selection_mode, (repv p_list, repv p_mode), rep_Subr2)
++{
++ GtkList* c_list;
++ GtkSelectionMode c_mode;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_mode, sgtk_valid_enum (p_mode, &sgtk_gtk_selection_mode_info));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_mode = (GtkSelectionMode) sgtk_rep_to_enum (p_mode, &sgtk_gtk_selection_mode_info);
++
++ gtk_list_set_selection_mode (c_list, c_mode);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-extend-selection", Fgtk_list_extend_selection, Sgtk_list_extend_selection, (repv p_list, repv p_scroll_type, repv p_position, repv p_auto_start_selection), rep_Subr4)
++{
++ GtkList* c_list;
++ GtkScrollType c_scroll_type;
++ gfloat c_position;
++ int c_auto_start_selection;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_scroll_type, sgtk_valid_enum (p_scroll_type, &sgtk_gtk_scroll_type_info));
++ rep_DECLARE (3, p_position, sgtk_valid_float (p_position));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_scroll_type = (GtkScrollType) sgtk_rep_to_enum (p_scroll_type, &sgtk_gtk_scroll_type_info);
++ c_position = sgtk_rep_to_float (p_position);
++ c_auto_start_selection = sgtk_rep_to_bool (p_auto_start_selection);
++
++ gtk_list_extend_selection (c_list, c_scroll_type, c_position, c_auto_start_selection);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-start-selection", Fgtk_list_start_selection, Sgtk_list_start_selection, (repv p_list), rep_Subr1)
++{
++ GtkList* c_list;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++
++ gtk_list_start_selection (c_list);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-end-selection", Fgtk_list_end_selection, Sgtk_list_end_selection, (repv p_list), rep_Subr1)
++{
++ GtkList* c_list;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++
++ gtk_list_end_selection (c_list);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-select-all", Fgtk_list_select_all, Sgtk_list_select_all, (repv p_list), rep_Subr1)
++{
++ GtkList* c_list;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++
++ gtk_list_select_all (c_list);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-unselect-all", Fgtk_list_unselect_all, Sgtk_list_unselect_all, (repv p_list), rep_Subr1)
++{
++ GtkList* c_list;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++
++ gtk_list_unselect_all (c_list);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-scroll-horizontal", Fgtk_list_scroll_horizontal, Sgtk_list_scroll_horizontal, (repv p_list, repv p_type, repv p_position), rep_Subr3)
++{
++ GtkList* c_list;
++ GtkScrollType c_type;
++ gfloat c_position;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_scroll_type_info));
++ rep_DECLARE (3, p_position, sgtk_valid_float (p_position));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_type = (GtkScrollType) sgtk_rep_to_enum (p_type, &sgtk_gtk_scroll_type_info);
++ c_position = sgtk_rep_to_float (p_position);
++
++ gtk_list_scroll_horizontal (c_list, c_type, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-scroll-vertical", Fgtk_list_scroll_vertical, Sgtk_list_scroll_vertical, (repv p_list, repv p_type, repv p_position), rep_Subr3)
++{
++ GtkList* c_list;
++ GtkScrollType c_type;
++ gfloat c_position;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_scroll_type_info));
++ rep_DECLARE (3, p_position, sgtk_valid_float (p_position));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_type = (GtkScrollType) sgtk_rep_to_enum (p_type, &sgtk_gtk_scroll_type_info);
++ c_position = sgtk_rep_to_float (p_position);
++
++ gtk_list_scroll_vertical (c_list, c_type, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-toggle-add-mode", Fgtk_list_toggle_add_mode, Sgtk_list_toggle_add_mode, (repv p_list), rep_Subr1)
++{
++ GtkList* c_list;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++
++ gtk_list_toggle_add_mode (c_list);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-toggle-focus-row", Fgtk_list_toggle_focus_row, Sgtk_list_toggle_focus_row, (repv p_list), rep_Subr1)
++{
++ GtkList* c_list;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++
++ gtk_list_toggle_focus_row (c_list);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-toggle-row", Fgtk_list_toggle_row, Sgtk_list_toggle_row, (repv p_list, repv p_item), rep_Subr2)
++{
++ GtkList* c_list;
++ GtkWidget* c_item;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++ rep_DECLARE (2, p_item, sgtk_is_a_gobj (gtk_widget_get_type (), p_item));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++ c_item = (GtkWidget*) sgtk_get_gobj (p_item);
++
++ gtk_list_toggle_row (c_list, c_item);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-undo-selection", Fgtk_list_undo_selection, Sgtk_list_undo_selection, (repv p_list), rep_Subr1)
++{
++ GtkList* c_list;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++
++ gtk_list_undo_selection (c_list);
++
++ return Qnil;
++}
++
++DEFUN("gtk-list-end-drag-selection", Fgtk_list_end_drag_selection, Sgtk_list_end_drag_selection, (repv p_list), rep_Subr1)
++{
++ GtkList* c_list;
++
++ rep_DECLARE (1, p_list, sgtk_is_a_gobj (gtk_list_get_type (), p_list));
++
++ c_list = (GtkList*) sgtk_get_gobj (p_list);
++
++ gtk_list_end_drag_selection (c_list);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-new", Fgtk_notebook_new, Sgtk_notebook_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_notebook_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-append-page", Fgtk_notebook_append_page, Sgtk_notebook_append_page, (repv p_notebook, repv p_child, repv p_tab_label), rep_Subr3)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ GtkWidget* c_tab_label;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_tab_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_tab_label));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_tab_label = (GtkWidget*) sgtk_get_gobj (p_tab_label);
++
++ gtk_notebook_append_page (c_notebook, c_child, c_tab_label);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-append-page-menu", Fgtk_notebook_append_page_menu, Sgtk_notebook_append_page_menu, (repv p_notebook, repv p_child, repv p_tab_label, repv p_menu_label), rep_Subr4)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ GtkWidget* c_tab_label;
++ GtkWidget* c_menu_label;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_tab_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_tab_label));
++ rep_DECLARE (4, p_menu_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_menu_label));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_tab_label = (GtkWidget*) sgtk_get_gobj (p_tab_label);
++ c_menu_label = (GtkWidget*) sgtk_get_gobj (p_menu_label);
++
++ gtk_notebook_append_page_menu (c_notebook, c_child, c_tab_label, c_menu_label);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-prepend-page", Fgtk_notebook_prepend_page, Sgtk_notebook_prepend_page, (repv p_notebook, repv p_child, repv p_tab_label), rep_Subr3)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ GtkWidget* c_tab_label;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_tab_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_tab_label));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_tab_label = (GtkWidget*) sgtk_get_gobj (p_tab_label);
++
++ gtk_notebook_prepend_page (c_notebook, c_child, c_tab_label);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-prepend-page-menu", Fgtk_notebook_prepend_page_menu, Sgtk_notebook_prepend_page_menu, (repv p_notebook, repv p_child, repv p_tab_label, repv p_menu_label), rep_Subr4)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ GtkWidget* c_tab_label;
++ GtkWidget* c_menu_label;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_tab_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_tab_label));
++ rep_DECLARE (4, p_menu_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_menu_label));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_tab_label = (GtkWidget*) sgtk_get_gobj (p_tab_label);
++ c_menu_label = (GtkWidget*) sgtk_get_gobj (p_menu_label);
++
++ gtk_notebook_prepend_page_menu (c_notebook, c_child, c_tab_label, c_menu_label);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-insert-page", Fgtk_notebook_insert_page, Sgtk_notebook_insert_page, (repv p_notebook, repv p_child, repv p_tab_label, repv p_position), rep_Subr4)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ GtkWidget* c_tab_label;
++ gint c_position;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_tab_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_tab_label));
++ rep_DECLARE (4, p_position, sgtk_valid_int (p_position));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_tab_label = (GtkWidget*) sgtk_get_gobj (p_tab_label);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_notebook_insert_page (c_notebook, c_child, c_tab_label, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-insert-page-menu", Fgtk_notebook_insert_page_menu, Sgtk_notebook_insert_page_menu, (repv p_notebook, repv p_child, repv p_tab_label, repv p_menu_label, repv p_position), rep_Subr5)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ GtkWidget* c_tab_label;
++ GtkWidget* c_menu_label;
++ gint c_position;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_tab_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_tab_label));
++ rep_DECLARE (4, p_menu_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_menu_label));
++ rep_DECLARE (5, p_position, sgtk_valid_int (p_position));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_tab_label = (GtkWidget*) sgtk_get_gobj (p_tab_label);
++ c_menu_label = (GtkWidget*) sgtk_get_gobj (p_menu_label);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_notebook_insert_page_menu (c_notebook, c_child, c_tab_label, c_menu_label, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-remove-page", Fgtk_notebook_remove_page, Sgtk_notebook_remove_page, (repv p_notebook, repv p_page_num), rep_Subr2)
++{
++ GtkNotebook* c_notebook;
++ gint c_page_num;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_page_num, sgtk_valid_int (p_page_num));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_page_num = sgtk_rep_to_int (p_page_num);
++
++ gtk_notebook_remove_page (c_notebook, c_page_num);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-get-current-page", Fgtk_notebook_get_current_page, Sgtk_notebook_get_current_page, (repv p_notebook), rep_Subr1)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++
++ cr_ret = gtk_notebook_get_current_page (c_notebook);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-get-nth-page", Fgtk_notebook_get_nth_page, Sgtk_notebook_get_nth_page, (repv p_notebook, repv p_page_num), rep_Subr2)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ gint c_page_num;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_page_num, sgtk_valid_int (p_page_num));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_page_num = sgtk_rep_to_int (p_page_num);
++
++ cr_ret = gtk_notebook_get_nth_page (c_notebook, c_page_num);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-page-num", Fgtk_notebook_page_num, Sgtk_notebook_page_num, (repv p_notebook, repv p_child), rep_Subr2)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ cr_ret = gtk_notebook_page_num (c_notebook, c_child);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-set-current-page", Fgtk_notebook_set_current_page, Sgtk_notebook_set_current_page, (repv p_notebook, repv p_page_num), rep_Subr2)
++{
++ GtkNotebook* c_notebook;
++ gint c_page_num;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_page_num, sgtk_valid_int (p_page_num));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_page_num = sgtk_rep_to_int (p_page_num);
++
++ gtk_notebook_set_current_page (c_notebook, c_page_num);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-next-page", Fgtk_notebook_next_page, Sgtk_notebook_next_page, (repv p_notebook), rep_Subr1)
++{
++ GtkNotebook* c_notebook;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++
++ gtk_notebook_next_page (c_notebook);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-prev-page", Fgtk_notebook_prev_page, Sgtk_notebook_prev_page, (repv p_notebook), rep_Subr1)
++{
++ GtkNotebook* c_notebook;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++
++ gtk_notebook_prev_page (c_notebook);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-set-show-border", Fgtk_notebook_set_show_border, Sgtk_notebook_set_show_border, (repv p_notebook, repv p_show_border), rep_Subr2)
++{
++ GtkNotebook* c_notebook;
++ int c_show_border;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_show_border = sgtk_rep_to_bool (p_show_border);
++
++ gtk_notebook_set_show_border (c_notebook, c_show_border);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-get-show-border", Fgtk_notebook_get_show_border, Sgtk_notebook_get_show_border, (repv p_notebook), rep_Subr1)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ int cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++
++ cr_ret = gtk_notebook_get_show_border (c_notebook);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-set-show-tabs", Fgtk_notebook_set_show_tabs, Sgtk_notebook_set_show_tabs, (repv p_notebook, repv p_show_tabs), rep_Subr2)
++{
++ GtkNotebook* c_notebook;
++ int c_show_tabs;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_show_tabs = sgtk_rep_to_bool (p_show_tabs);
++
++ gtk_notebook_set_show_tabs (c_notebook, c_show_tabs);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-get-show-tabs", Fgtk_notebook_get_show_tabs, Sgtk_notebook_get_show_tabs, (repv p_notebook), rep_Subr1)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ int cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++
++ cr_ret = gtk_notebook_get_show_tabs (c_notebook);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-set-tab-pos", Fgtk_notebook_set_tab_pos, Sgtk_notebook_set_tab_pos, (repv p_notebook, repv p_pos), rep_Subr2)
++{
++ GtkNotebook* c_notebook;
++ GtkPositionType c_pos;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_pos, sgtk_valid_enum (p_pos, &sgtk_gtk_position_type_info));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_pos = (GtkPositionType) sgtk_rep_to_enum (p_pos, &sgtk_gtk_position_type_info);
++
++ gtk_notebook_set_tab_pos (c_notebook, c_pos);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-get-tab-pos", Fgtk_notebook_get_tab_pos, Sgtk_notebook_get_tab_pos, (repv p_notebook), rep_Subr1)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ GtkPositionType cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++
++ cr_ret = gtk_notebook_get_tab_pos (c_notebook);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_position_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-set-scrollable", Fgtk_notebook_set_scrollable, Sgtk_notebook_set_scrollable, (repv p_notebook, repv p_scrollable), rep_Subr2)
++{
++ GtkNotebook* c_notebook;
++ int c_scrollable;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_scrollable = sgtk_rep_to_bool (p_scrollable);
++
++ gtk_notebook_set_scrollable (c_notebook, c_scrollable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-get-scrollable", Fgtk_notebook_get_scrollable, Sgtk_notebook_get_scrollable, (repv p_notebook), rep_Subr1)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ int cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++
++ cr_ret = gtk_notebook_get_scrollable (c_notebook);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-popup-enable", Fgtk_notebook_popup_enable, Sgtk_notebook_popup_enable, (repv p_notebook), rep_Subr1)
++{
++ GtkNotebook* c_notebook;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++
++ gtk_notebook_popup_enable (c_notebook);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-popup-disable", Fgtk_notebook_popup_disable, Sgtk_notebook_popup_disable, (repv p_notebook), rep_Subr1)
++{
++ GtkNotebook* c_notebook;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++
++ gtk_notebook_popup_disable (c_notebook);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-get-tab-label", Fgtk_notebook_get_tab_label, Sgtk_notebook_get_tab_label, (repv p_notebook, repv p_child), rep_Subr2)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ cr_ret = gtk_notebook_get_tab_label (c_notebook, c_child);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-set-tab-label", Fgtk_notebook_set_tab_label, Sgtk_notebook_set_tab_label, (repv p_notebook, repv p_child, repv p_tab_label), rep_Subr3)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ GtkWidget* c_tab_label;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_tab_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_tab_label));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_tab_label = (GtkWidget*) sgtk_get_gobj (p_tab_label);
++
++ gtk_notebook_set_tab_label (c_notebook, c_child, c_tab_label);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-set-tab-label-text", Fgtk_notebook_set_tab_label_text, Sgtk_notebook_set_tab_label_text, (repv p_notebook, repv p_child, repv p_text), rep_Subr3)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ char* c_text;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_text, sgtk_valid_string (p_text));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_text = sgtk_rep_to_string (p_text);
++
++ gtk_notebook_set_tab_label_text (c_notebook, c_child, c_text);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-get-tab-label-text", Fgtk_notebook_get_tab_label_text, Sgtk_notebook_get_tab_label_text, (repv p_notebook, repv p_child), rep_Subr2)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ cr_ret = gtk_notebook_get_tab_label_text (c_notebook, c_child);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-get-menu-label", Fgtk_notebook_get_menu_label, Sgtk_notebook_get_menu_label, (repv p_notebook, repv p_child), rep_Subr2)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ cr_ret = gtk_notebook_get_menu_label (c_notebook, c_child);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-set-menu-label", Fgtk_notebook_set_menu_label, Sgtk_notebook_set_menu_label, (repv p_notebook, repv p_child, repv p_menu_label), rep_Subr3)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ GtkWidget* c_menu_label;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_menu_label, sgtk_is_a_gobj (gtk_widget_get_type (), p_menu_label));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_menu_label = (GtkWidget*) sgtk_get_gobj (p_menu_label);
++
++ gtk_notebook_set_menu_label (c_notebook, c_child, c_menu_label);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-set-menu-label-text", Fgtk_notebook_set_menu_label_text, Sgtk_notebook_set_menu_label_text, (repv p_notebook, repv p_child, repv p_text), rep_Subr3)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ char* c_text;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_text, sgtk_valid_string (p_text));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_text = sgtk_rep_to_string (p_text);
++
++ gtk_notebook_set_menu_label_text (c_notebook, c_child, c_text);
++
++ return Qnil;
++}
++
++DEFUN("gtk-notebook-get-menu-label-text", Fgtk_notebook_get_menu_label_text, Sgtk_notebook_get_menu_label_text, (repv p_notebook, repv p_child), rep_Subr2)
++{
++ repv pr_ret;
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ cr_ret = gtk_notebook_get_menu_label_text (c_notebook, c_child);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-reorder-child", Fgtk_notebook_reorder_child, Sgtk_notebook_reorder_child, (repv p_notebook, repv p_child, repv p_position), rep_Subr3)
++{
++ GtkNotebook* c_notebook;
++ GtkWidget* c_child;
++ gint c_position;
++
++ rep_DECLARE (1, p_notebook, sgtk_is_a_gobj (gtk_notebook_get_type (), p_notebook));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_position, sgtk_valid_int (p_position));
++
++ c_notebook = (GtkNotebook*) sgtk_get_gobj (p_notebook);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_notebook_reorder_child (c_notebook, c_child, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-editable-select-region", Fgtk_editable_select_region, Sgtk_editable_select_region, (repv p_editable, repv p_start, repv p_end), rep_Subr3)
++{
++ GtkEditable* c_editable;
++ gint c_start;
++ gint c_end;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++ rep_DECLARE (2, p_start, sgtk_valid_int (p_start));
++ rep_DECLARE (3, p_end, sgtk_valid_int (p_end));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++ c_start = sgtk_rep_to_int (p_start);
++ c_end = sgtk_rep_to_int (p_end);
++
++ gtk_editable_select_region (c_editable, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-editable-insert-text", Fgtk_editable_insert_text, Sgtk_editable_insert_text, (repv p_editable, repv p_new_text, repv p_new_text_length, repv p_position), rep_Subr4)
++{
++ rep_GC_root gc_position;
++ GtkEditable* c_editable;
++ char* c_new_text;
++ gint c_new_text_length;
++ sgtk_cvec c_position;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++ rep_DECLARE (2, p_new_text, sgtk_valid_string (p_new_text));
++ rep_DECLARE (3, p_new_text_length, sgtk_valid_int (p_new_text_length));
++ rep_DECLARE (4, p_position, sgtk_valid_complen (p_position, _sgtk_helper_valid_int, 1));
++
++ rep_PUSHGC (gc_position, p_position);
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++ c_new_text = sgtk_rep_to_string (p_new_text);
++ c_new_text_length = sgtk_rep_to_int (p_new_text_length);
++ c_position = sgtk_rep_to_cvec (p_position, _sgtk_helper_fromrep_int, sizeof (gint));
++
++ gtk_editable_insert_text (c_editable, c_new_text, c_new_text_length, (gint*) c_position.vec);
++
++ sgtk_cvec_finish (&c_position, p_position, _sgtk_helper_torep_nocopy_int, sizeof (gint));
++ rep_POPGC;
++ return Qnil;
++}
++
++DEFUN("gtk-editable-delete-text", Fgtk_editable_delete_text, Sgtk_editable_delete_text, (repv p_editable, repv p_start_pos, repv p_end_pos), rep_Subr3)
++{
++ GtkEditable* c_editable;
++ gint c_start_pos;
++ gint c_end_pos;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++ rep_DECLARE (2, p_start_pos, sgtk_valid_int (p_start_pos));
++ rep_DECLARE (3, p_end_pos, sgtk_valid_int (p_end_pos));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++ c_start_pos = sgtk_rep_to_int (p_start_pos);
++ c_end_pos = sgtk_rep_to_int (p_end_pos);
++
++ gtk_editable_delete_text (c_editable, c_start_pos, c_end_pos);
++
++ return Qnil;
++}
++
++DEFUN("gtk-editable-get-chars", Fgtk_editable_get_chars, Sgtk_editable_get_chars, (repv p_editable, repv p_start_pos, repv p_end_pos), rep_Subr3)
++{
++ repv pr_ret;
++ GtkEditable* c_editable;
++ gint c_start_pos;
++ gint c_end_pos;
++ char* cr_ret;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++ rep_DECLARE (2, p_start_pos, sgtk_valid_int (p_start_pos));
++ rep_DECLARE (3, p_end_pos, sgtk_valid_int (p_end_pos));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++ c_start_pos = sgtk_rep_to_int (p_start_pos);
++ c_end_pos = sgtk_rep_to_int (p_end_pos);
++
++ cr_ret = gtk_editable_get_chars (c_editable, c_start_pos, c_end_pos);
++
++ pr_ret = sgtk_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-editable-cut-clipboard", Fgtk_editable_cut_clipboard, Sgtk_editable_cut_clipboard, (repv p_editable), rep_Subr1)
++{
++ GtkEditable* c_editable;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++
++ gtk_editable_cut_clipboard (c_editable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-editable-copy-clipboard", Fgtk_editable_copy_clipboard, Sgtk_editable_copy_clipboard, (repv p_editable), rep_Subr1)
++{
++ GtkEditable* c_editable;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++
++ gtk_editable_copy_clipboard (c_editable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-editable-paste-clipboard", Fgtk_editable_paste_clipboard, Sgtk_editable_paste_clipboard, (repv p_editable), rep_Subr1)
++{
++ GtkEditable* c_editable;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++
++ gtk_editable_paste_clipboard (c_editable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-editable-delete-selection", Fgtk_editable_delete_selection, Sgtk_editable_delete_selection, (repv p_editable), rep_Subr1)
++{
++ GtkEditable* c_editable;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++
++ gtk_editable_delete_selection (c_editable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-editable-set-position", Fgtk_editable_set_position, Sgtk_editable_set_position, (repv p_editable, repv p_position), rep_Subr2)
++{
++ GtkEditable* c_editable;
++ gint c_position;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++ rep_DECLARE (2, p_position, sgtk_valid_int (p_position));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_editable_set_position (c_editable, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-editable-get-position", Fgtk_editable_get_position, Sgtk_editable_get_position, (repv p_editable), rep_Subr1)
++{
++ repv pr_ret;
++ GtkEditable* c_editable;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++
++ cr_ret = gtk_editable_get_position (c_editable);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-editable-set-editable", Fgtk_editable_set_editable, Sgtk_editable_set_editable, (repv p_editable, repv p_is_editable), rep_Subr2)
++{
++ GtkEditable* c_editable;
++ int c_is_editable;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++ c_is_editable = sgtk_rep_to_bool (p_is_editable);
++
++ gtk_editable_set_editable (c_editable, c_is_editable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-editable-get-editable", Fgtk_editable_get_editable, Sgtk_editable_get_editable, (repv p_editable), rep_Subr1)
++{
++ repv pr_ret;
++ GtkEditable* c_editable;
++ int cr_ret;
++
++ rep_DECLARE (1, p_editable, sgtk_is_a_gobj (gtk_editable_get_type (), p_editable));
++
++ c_editable = (GtkEditable*) sgtk_get_gobj (p_editable);
++
++ cr_ret = gtk_editable_get_editable (c_editable);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-entry-new", Fgtk_entry_new, Sgtk_entry_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_entry_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-entry-set-visibility", Fgtk_entry_set_visibility, Sgtk_entry_set_visibility, (repv p_entry, repv p_visible), rep_Subr2)
++{
++ GtkEntry* c_entry;
++ int c_visible;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++ c_visible = sgtk_rep_to_bool (p_visible);
++
++ gtk_entry_set_visibility (c_entry, c_visible);
++
++ return Qnil;
++}
++
++DEFUN("gtk-entry-get-visibility", Fgtk_entry_get_visibility, Sgtk_entry_get_visibility, (repv p_entry), rep_Subr1)
++{
++ repv pr_ret;
++ GtkEntry* c_entry;
++ int cr_ret;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++
++ cr_ret = gtk_entry_get_visibility (c_entry);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-entry-set-has-frame", Fgtk_entry_set_has_frame, Sgtk_entry_set_has_frame, (repv p_entry, repv p_setting), rep_Subr2)
++{
++ GtkEntry* c_entry;
++ int c_setting;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_entry_set_has_frame (c_entry, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-entry-get-has-frame", Fgtk_entry_get_has_frame, Sgtk_entry_get_has_frame, (repv p_entry), rep_Subr1)
++{
++ repv pr_ret;
++ GtkEntry* c_entry;
++ int cr_ret;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++
++ cr_ret = gtk_entry_get_has_frame (c_entry);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-entry-set-max-length", Fgtk_entry_set_max_length, Sgtk_entry_set_max_length, (repv p_entry, repv p_max), rep_Subr2)
++{
++ GtkEntry* c_entry;
++ gint c_max;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++ rep_DECLARE (2, p_max, sgtk_valid_int (p_max));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++ c_max = sgtk_rep_to_int (p_max);
++
++ gtk_entry_set_max_length (c_entry, c_max);
++
++ return Qnil;
++}
++
++DEFUN("gtk-entry-get-max-length", Fgtk_entry_get_max_length, Sgtk_entry_get_max_length, (repv p_entry), rep_Subr1)
++{
++ repv pr_ret;
++ GtkEntry* c_entry;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++
++ cr_ret = gtk_entry_get_max_length (c_entry);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-entry-set-activates-default", Fgtk_entry_set_activates_default, Sgtk_entry_set_activates_default, (repv p_entry, repv p_setting), rep_Subr2)
++{
++ GtkEntry* c_entry;
++ int c_setting;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_entry_set_activates_default (c_entry, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-entry-get-activates-default", Fgtk_entry_get_activates_default, Sgtk_entry_get_activates_default, (repv p_entry), rep_Subr1)
++{
++ repv pr_ret;
++ GtkEntry* c_entry;
++ int cr_ret;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++
++ cr_ret = gtk_entry_get_activates_default (c_entry);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-entry-set-width-chars", Fgtk_entry_set_width_chars, Sgtk_entry_set_width_chars, (repv p_entry, repv p_n_chars), rep_Subr2)
++{
++ GtkEntry* c_entry;
++ gint c_n_chars;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++ rep_DECLARE (2, p_n_chars, sgtk_valid_int (p_n_chars));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++ c_n_chars = sgtk_rep_to_int (p_n_chars);
++
++ gtk_entry_set_width_chars (c_entry, c_n_chars);
++
++ return Qnil;
++}
++
++DEFUN("gtk-entry-get-width-chars", Fgtk_entry_get_width_chars, Sgtk_entry_get_width_chars, (repv p_entry), rep_Subr1)
++{
++ repv pr_ret;
++ GtkEntry* c_entry;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++
++ cr_ret = gtk_entry_get_width_chars (c_entry);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-entry-set-text", Fgtk_entry_set_text, Sgtk_entry_set_text, (repv p_entry, repv p_text), rep_Subr2)
++{
++ GtkEntry* c_entry;
++ char* c_text;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++ rep_DECLARE (2, p_text, sgtk_valid_string (p_text));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++ c_text = sgtk_rep_to_string (p_text);
++
++ gtk_entry_set_text (c_entry, c_text);
++
++ return Qnil;
++}
++
++DEFUN("gtk-entry-get-text", Fgtk_entry_get_text, Sgtk_entry_get_text, (repv p_entry), rep_Subr1)
++{
++ repv pr_ret;
++ GtkEntry* c_entry;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_entry, sgtk_is_a_gobj (gtk_entry_get_type (), p_entry));
++
++ c_entry = (GtkEntry*) sgtk_get_gobj (p_entry);
++
++ cr_ret = gtk_entry_get_text (c_entry);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-new", Fgtk_spin_button_new, Sgtk_spin_button_new, (repv p_adjustment, repv p_climb_rate, repv p_digits), rep_Subr3)
++{
++ repv pr_ret;
++ GtkAdjustment* c_adjustment;
++ gdouble c_climb_rate;
++ gint c_digits;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++ rep_DECLARE (2, p_climb_rate, sgtk_valid_double (p_climb_rate));
++ rep_DECLARE (3, p_digits, sgtk_valid_int (p_digits));
++
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++ c_climb_rate = sgtk_rep_to_double (p_climb_rate);
++ c_digits = sgtk_rep_to_int (p_digits);
++
++ cr_ret = gtk_spin_button_new (c_adjustment, c_climb_rate, c_digits);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-new-with-range", Fgtk_spin_button_new_with_range, Sgtk_spin_button_new_with_range, (repv p_min, repv p_max, repv p_step), rep_Subr3)
++{
++ repv pr_ret;
++ gdouble c_min;
++ gdouble c_max;
++ gdouble c_step;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_min, sgtk_valid_double (p_min));
++ rep_DECLARE (2, p_max, sgtk_valid_double (p_max));
++ rep_DECLARE (3, p_step, sgtk_valid_double (p_step));
++
++ c_min = sgtk_rep_to_double (p_min);
++ c_max = sgtk_rep_to_double (p_max);
++ c_step = sgtk_rep_to_double (p_step);
++
++ cr_ret = gtk_spin_button_new_with_range (c_min, c_max, c_step);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-set-adjustment", Fgtk_spin_button_set_adjustment, Sgtk_spin_button_set_adjustment, (repv p_spin_button, repv p_adjustment), rep_Subr2)
++{
++ GtkSpinButton* c_spin_button;
++ GtkAdjustment* c_adjustment;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++ rep_DECLARE (2, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ gtk_spin_button_set_adjustment (c_spin_button, c_adjustment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-spin-button-get-adjustment", Fgtk_spin_button_get_adjustment, Sgtk_spin_button_get_adjustment, (repv p_spin_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkSpinButton* c_spin_button;
++ GtkAdjustment* cr_ret;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++
++ cr_ret = gtk_spin_button_get_adjustment (c_spin_button);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-set-digits", Fgtk_spin_button_set_digits, Sgtk_spin_button_set_digits, (repv p_spin_button, repv p_digits), rep_Subr2)
++{
++ GtkSpinButton* c_spin_button;
++ gint c_digits;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++ rep_DECLARE (2, p_digits, sgtk_valid_int (p_digits));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++ c_digits = sgtk_rep_to_int (p_digits);
++
++ gtk_spin_button_set_digits (c_spin_button, c_digits);
++
++ return Qnil;
++}
++
++DEFUN("gtk-spin-button-get-digits", Fgtk_spin_button_get_digits, Sgtk_spin_button_get_digits, (repv p_spin_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkSpinButton* c_spin_button;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++
++ cr_ret = gtk_spin_button_get_digits (c_spin_button);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-set-increments", Fgtk_spin_button_set_increments, Sgtk_spin_button_set_increments, (repv p_spin_button, repv p_step, repv p_page), rep_Subr3)
++{
++ GtkSpinButton* c_spin_button;
++ gdouble c_step;
++ gdouble c_page;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++ rep_DECLARE (2, p_step, sgtk_valid_double (p_step));
++ rep_DECLARE (3, p_page, sgtk_valid_double (p_page));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++ c_step = sgtk_rep_to_double (p_step);
++ c_page = sgtk_rep_to_double (p_page);
++
++ gtk_spin_button_set_increments (c_spin_button, c_step, c_page);
++
++ return Qnil;
++}
++
++DEFUN("gtk-spin-button-set-range", Fgtk_spin_button_set_range, Sgtk_spin_button_set_range, (repv p_spin_button, repv p_min, repv p_max), rep_Subr3)
++{
++ GtkSpinButton* c_spin_button;
++ gdouble c_min;
++ gdouble c_max;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++ rep_DECLARE (2, p_min, sgtk_valid_double (p_min));
++ rep_DECLARE (3, p_max, sgtk_valid_double (p_max));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++ c_min = sgtk_rep_to_double (p_min);
++ c_max = sgtk_rep_to_double (p_max);
++
++ gtk_spin_button_set_range (c_spin_button, c_min, c_max);
++
++ return Qnil;
++}
++
++DEFUN("gtk-spin-button-get-value", Fgtk_spin_button_get_value, Sgtk_spin_button_get_value, (repv p_spin_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkSpinButton* c_spin_button;
++ gdouble cr_ret;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++
++ cr_ret = gtk_spin_button_get_value (c_spin_button);
++
++ pr_ret = sgtk_double_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-get-value-as-int", Fgtk_spin_button_get_value_as_int, Sgtk_spin_button_get_value_as_int, (repv p_spin_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkSpinButton* c_spin_button;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++
++ cr_ret = gtk_spin_button_get_value_as_int (c_spin_button);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-set-value", Fgtk_spin_button_set_value, Sgtk_spin_button_set_value, (repv p_spin_button, repv p_value), rep_Subr2)
++{
++ GtkSpinButton* c_spin_button;
++ gdouble c_value;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++ rep_DECLARE (2, p_value, sgtk_valid_double (p_value));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++ c_value = sgtk_rep_to_double (p_value);
++
++ gtk_spin_button_set_value (c_spin_button, c_value);
++
++ return Qnil;
++}
++
++DEFUN("gtk-spin-button-set-update-policy", Fgtk_spin_button_set_update_policy, Sgtk_spin_button_set_update_policy, (repv p_spin_button, repv p_policy), rep_Subr2)
++{
++ GtkSpinButton* c_spin_button;
++ GtkSpinButtonUpdatePolicy c_policy;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++ rep_DECLARE (2, p_policy, sgtk_valid_enum (p_policy, &sgtk_gtk_spin_button_update_policy_info));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++ c_policy = (GtkSpinButtonUpdatePolicy) sgtk_rep_to_enum (p_policy, &sgtk_gtk_spin_button_update_policy_info);
++
++ gtk_spin_button_set_update_policy (c_spin_button, c_policy);
++
++ return Qnil;
++}
++
++DEFUN("gtk-spin-button-get-update-policy", Fgtk_spin_button_get_update_policy, Sgtk_spin_button_get_update_policy, (repv p_spin_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkSpinButton* c_spin_button;
++ GtkSpinButtonUpdatePolicy cr_ret;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++
++ cr_ret = gtk_spin_button_get_update_policy (c_spin_button);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_spin_button_update_policy_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-set-numeric", Fgtk_spin_button_set_numeric, Sgtk_spin_button_set_numeric, (repv p_spin_button, repv p_numeric), rep_Subr2)
++{
++ GtkSpinButton* c_spin_button;
++ int c_numeric;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++ c_numeric = sgtk_rep_to_bool (p_numeric);
++
++ gtk_spin_button_set_numeric (c_spin_button, c_numeric);
++
++ return Qnil;
++}
++
++DEFUN("gtk-spin-button-get-numeric", Fgtk_spin_button_get_numeric, Sgtk_spin_button_get_numeric, (repv p_spin_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkSpinButton* c_spin_button;
++ int cr_ret;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++
++ cr_ret = gtk_spin_button_get_numeric (c_spin_button);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-spin", Fgtk_spin_button_spin, Sgtk_spin_button_spin, (repv p_spin_button, repv p_direction, repv p_increment), rep_Subr3)
++{
++ GtkSpinButton* c_spin_button;
++ GtkSpinType c_direction;
++ gdouble c_increment;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++ rep_DECLARE (2, p_direction, sgtk_valid_enum (p_direction, &sgtk_gtk_spin_type_info));
++ rep_DECLARE (3, p_increment, sgtk_valid_double (p_increment));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++ c_direction = (GtkSpinType) sgtk_rep_to_enum (p_direction, &sgtk_gtk_spin_type_info);
++ c_increment = sgtk_rep_to_double (p_increment);
++
++ gtk_spin_button_spin (c_spin_button, c_direction, c_increment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-spin-button-set-wrap", Fgtk_spin_button_set_wrap, Sgtk_spin_button_set_wrap, (repv p_spin_button, repv p_wrap), rep_Subr2)
++{
++ GtkSpinButton* c_spin_button;
++ int c_wrap;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++ c_wrap = sgtk_rep_to_bool (p_wrap);
++
++ gtk_spin_button_set_wrap (c_spin_button, c_wrap);
++
++ return Qnil;
++}
++
++DEFUN("gtk-spin-button-get-wrap", Fgtk_spin_button_get_wrap, Sgtk_spin_button_get_wrap, (repv p_spin_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkSpinButton* c_spin_button;
++ int cr_ret;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++
++ cr_ret = gtk_spin_button_get_wrap (c_spin_button);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-set-snap-to-ticks", Fgtk_spin_button_set_snap_to_ticks, Sgtk_spin_button_set_snap_to_ticks, (repv p_spin_button, repv p_snap_to_ticks), rep_Subr2)
++{
++ GtkSpinButton* c_spin_button;
++ int c_snap_to_ticks;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++ c_snap_to_ticks = sgtk_rep_to_bool (p_snap_to_ticks);
++
++ gtk_spin_button_set_snap_to_ticks (c_spin_button, c_snap_to_ticks);
++
++ return Qnil;
++}
++
++DEFUN("gtk-spin-button-get-snap-to-ticks", Fgtk_spin_button_get_snap_to_ticks, Sgtk_spin_button_get_snap_to_ticks, (repv p_spin_button), rep_Subr1)
++{
++ repv pr_ret;
++ GtkSpinButton* c_spin_button;
++ int cr_ret;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++
++ cr_ret = gtk_spin_button_get_snap_to_ticks (c_spin_button);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-spin-button-update", Fgtk_spin_button_update, Sgtk_spin_button_update, (repv p_spin_button), rep_Subr1)
++{
++ GtkSpinButton* c_spin_button;
++
++ rep_DECLARE (1, p_spin_button, sgtk_is_a_gobj (gtk_spin_button_get_type (), p_spin_button));
++
++ c_spin_button = (GtkSpinButton*) sgtk_get_gobj (p_spin_button);
++
++ gtk_spin_button_update (c_spin_button);
++
++ return Qnil;
++}
++
++DEFUN("gtk-alignment-new", Fgtk_alignment_new, Sgtk_alignment_new, (repv p_xalign, repv p_yalign, repv p_xscale, repv p_yscale), rep_Subr4)
++{
++ repv pr_ret;
++ gfloat c_xalign;
++ gfloat c_yalign;
++ gfloat c_xscale;
++ gfloat c_yscale;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_xalign, sgtk_valid_float (p_xalign));
++ rep_DECLARE (2, p_yalign, sgtk_valid_float (p_yalign));
++ rep_DECLARE (3, p_xscale, sgtk_valid_float (p_xscale));
++ rep_DECLARE (4, p_yscale, sgtk_valid_float (p_yscale));
++
++ c_xalign = sgtk_rep_to_float (p_xalign);
++ c_yalign = sgtk_rep_to_float (p_yalign);
++ c_xscale = sgtk_rep_to_float (p_xscale);
++ c_yscale = sgtk_rep_to_float (p_yscale);
++
++ cr_ret = gtk_alignment_new (c_xalign, c_yalign, c_xscale, c_yscale);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-alignment-set", Fgtk_alignment_set, Sgtk_alignment_set, (repv p_alignment, repv p_xalign, repv p_yalign, repv p_xscale, repv p_yscale), rep_Subr5)
++{
++ GtkAlignment* c_alignment;
++ gfloat c_xalign;
++ gfloat c_yalign;
++ gfloat c_xscale;
++ gfloat c_yscale;
++
++ rep_DECLARE (1, p_alignment, sgtk_is_a_gobj (gtk_alignment_get_type (), p_alignment));
++ rep_DECLARE (2, p_xalign, sgtk_valid_float (p_xalign));
++ rep_DECLARE (3, p_yalign, sgtk_valid_float (p_yalign));
++ rep_DECLARE (4, p_xscale, sgtk_valid_float (p_xscale));
++ rep_DECLARE (5, p_yscale, sgtk_valid_float (p_yscale));
++
++ c_alignment = (GtkAlignment*) sgtk_get_gobj (p_alignment);
++ c_xalign = sgtk_rep_to_float (p_xalign);
++ c_yalign = sgtk_rep_to_float (p_yalign);
++ c_xscale = sgtk_rep_to_float (p_xscale);
++ c_yscale = sgtk_rep_to_float (p_yscale);
++
++ gtk_alignment_set (c_alignment, c_xalign, c_yalign, c_xscale, c_yscale);
++
++ return Qnil;
++}
++
++DEFUN("gtk-drawing-area-new", Fgtk_drawing_area_new, Sgtk_drawing_area_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_drawing_area_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-curve-new", Fgtk_curve_new, Sgtk_curve_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_curve_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-curve-reset", Fgtk_curve_reset, Sgtk_curve_reset, (repv p_curve), rep_Subr1)
++{
++ GtkCurve* c_curve;
++
++ rep_DECLARE (1, p_curve, sgtk_is_a_gobj (gtk_curve_get_type (), p_curve));
++
++ c_curve = (GtkCurve*) sgtk_get_gobj (p_curve);
++
++ gtk_curve_reset (c_curve);
++
++ return Qnil;
++}
++
++DEFUN("gtk-curve-set-gamma", Fgtk_curve_set_gamma, Sgtk_curve_set_gamma, (repv p_curve, repv p_gamma), rep_Subr2)
++{
++ GtkCurve* c_curve;
++ gfloat c_gamma;
++
++ rep_DECLARE (1, p_curve, sgtk_is_a_gobj (gtk_curve_get_type (), p_curve));
++ rep_DECLARE (2, p_gamma, sgtk_valid_float (p_gamma));
++
++ c_curve = (GtkCurve*) sgtk_get_gobj (p_curve);
++ c_gamma = sgtk_rep_to_float (p_gamma);
++
++ gtk_curve_set_gamma (c_curve, c_gamma);
++
++ return Qnil;
++}
++
++DEFUN("gtk-curve-set-range", Fgtk_curve_set_range, Sgtk_curve_set_range, (repv p_curve, repv p_min_x, repv p_max_x, repv p_min_y, repv p_max_y), rep_Subr5)
++{
++ GtkCurve* c_curve;
++ gfloat c_min_x;
++ gfloat c_max_x;
++ gfloat c_min_y;
++ gfloat c_max_y;
++
++ rep_DECLARE (1, p_curve, sgtk_is_a_gobj (gtk_curve_get_type (), p_curve));
++ rep_DECLARE (2, p_min_x, sgtk_valid_float (p_min_x));
++ rep_DECLARE (3, p_max_x, sgtk_valid_float (p_max_x));
++ rep_DECLARE (4, p_min_y, sgtk_valid_float (p_min_y));
++ rep_DECLARE (5, p_max_y, sgtk_valid_float (p_max_y));
++
++ c_curve = (GtkCurve*) sgtk_get_gobj (p_curve);
++ c_min_x = sgtk_rep_to_float (p_min_x);
++ c_max_x = sgtk_rep_to_float (p_max_x);
++ c_min_y = sgtk_rep_to_float (p_min_y);
++ c_max_y = sgtk_rep_to_float (p_max_y);
++
++ gtk_curve_set_range (c_curve, c_min_x, c_max_x, c_min_y, c_max_y);
++
++ return Qnil;
++}
++
++DEFUN("gtk-curve-set-curve-type", Fgtk_curve_set_curve_type, Sgtk_curve_set_curve_type, (repv p_curve, repv p_type), rep_Subr2)
++{
++ GtkCurve* c_curve;
++ GtkCurveType c_type;
++
++ rep_DECLARE (1, p_curve, sgtk_is_a_gobj (gtk_curve_get_type (), p_curve));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_curve_type_info));
++
++ c_curve = (GtkCurve*) sgtk_get_gobj (p_curve);
++ c_type = (GtkCurveType) sgtk_rep_to_enum (p_type, &sgtk_gtk_curve_type_info);
++
++ gtk_curve_set_curve_type (c_curve, c_type);
++
++ return Qnil;
++}
++
++DEFUN("gtk-preview-new", Fgtk_preview_new, Sgtk_preview_new, (repv p_type), rep_Subr1)
++{
++ repv pr_ret;
++ GtkPreviewType c_type;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_preview_type_info));
++
++ c_type = (GtkPreviewType) sgtk_rep_to_enum (p_type, &sgtk_gtk_preview_type_info);
++
++ cr_ret = gtk_preview_new (c_type);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-preview-size", Fgtk_preview_size, Sgtk_preview_size, (repv p_preview, repv p_width, repv p_height), rep_Subr3)
++{
++ GtkPreview* c_preview;
++ gint c_width;
++ gint c_height;
++
++ rep_DECLARE (1, p_preview, sgtk_is_a_gobj (gtk_preview_get_type (), p_preview));
++ rep_DECLARE (2, p_width, sgtk_valid_int (p_width));
++ rep_DECLARE (3, p_height, sgtk_valid_int (p_height));
++
++ c_preview = (GtkPreview*) sgtk_get_gobj (p_preview);
++ c_width = sgtk_rep_to_int (p_width);
++ c_height = sgtk_rep_to_int (p_height);
++
++ gtk_preview_size (c_preview, c_width, c_height);
++
++ return Qnil;
++}
++
++DEFUN("gtk-preview-put", Fgtk_preview_put, Sgtk_preview_put, (repv args), rep_SubrN)
++{
++ repv p_preview, p_window, p_gc, p_srcx, p_srcy, p_destx, p_desty, p_width, p_height;
++
++ GtkPreview* c_preview;
++ GdkWindow* c_window;
++ GdkGC* c_gc;
++ gint c_srcx;
++ gint c_srcy;
++ gint c_destx;
++ gint c_desty;
++ gint c_width;
++ gint c_height;
++
++ if (!rep_CONSP(args))
++ p_preview = Qnil;
++ else {
++ p_preview = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_window = Qnil;
++ else {
++ p_window = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_gc = Qnil;
++ else {
++ p_gc = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_srcx = Qnil;
++ else {
++ p_srcx = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_srcy = Qnil;
++ else {
++ p_srcy = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_destx = Qnil;
++ else {
++ p_destx = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_desty = Qnil;
++ else {
++ p_desty = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_width = Qnil;
++ else {
++ p_width = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_height = Qnil;
++ else {
++ p_height = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_preview, sgtk_is_a_gobj (gtk_preview_get_type (), p_preview));
++ rep_DECLARE (2, p_window, sgtk_valid_boxed (p_window, &sgtk_gdk_window_info));
++ rep_DECLARE (3, p_gc, sgtk_valid_boxed (p_gc, &sgtk_gdk_gc_info));
++ rep_DECLARE (4, p_srcx, sgtk_valid_int (p_srcx));
++ rep_DECLARE (5, p_srcy, sgtk_valid_int (p_srcy));
++ rep_DECLARE (6, p_destx, sgtk_valid_int (p_destx));
++ rep_DECLARE (7, p_desty, sgtk_valid_int (p_desty));
++ rep_DECLARE (8, p_width, sgtk_valid_int (p_width));
++ rep_DECLARE (9, p_height, sgtk_valid_int (p_height));
++
++ c_preview = (GtkPreview*) sgtk_get_gobj (p_preview);
++ c_window = (GdkWindow*) sgtk_rep_to_boxed (p_window);
++ c_gc = (GdkGC*) sgtk_rep_to_boxed (p_gc);
++ c_srcx = sgtk_rep_to_int (p_srcx);
++ c_srcy = sgtk_rep_to_int (p_srcy);
++ c_destx = sgtk_rep_to_int (p_destx);
++ c_desty = sgtk_rep_to_int (p_desty);
++ c_width = sgtk_rep_to_int (p_width);
++ c_height = sgtk_rep_to_int (p_height);
++
++ gtk_preview_put (c_preview, c_window, c_gc, c_srcx, c_srcy, c_destx, c_desty, c_width, c_height);
++
++ return Qnil;
++}
++
++DEFUN("gtk-preview-draw-row", Fgtk_preview_draw_row, Sgtk_preview_draw_row, (repv p_preview, repv p_data, repv p_x, repv p_y, repv p_w), rep_Subr5)
++{
++ GtkPreview* c_preview;
++ char* c_data;
++ gint c_x;
++ gint c_y;
++ gint c_w;
++
++ rep_DECLARE (1, p_preview, sgtk_is_a_gobj (gtk_preview_get_type (), p_preview));
++ rep_DECLARE (2, p_data, sgtk_valid_string (p_data));
++ rep_DECLARE (3, p_x, sgtk_valid_int (p_x));
++ rep_DECLARE (4, p_y, sgtk_valid_int (p_y));
++ rep_DECLARE (5, p_w, sgtk_valid_int (p_w));
++
++ c_preview = (GtkPreview*) sgtk_get_gobj (p_preview);
++ c_data = sgtk_rep_to_string (p_data);
++ c_x = sgtk_rep_to_int (p_x);
++ c_y = sgtk_rep_to_int (p_y);
++ c_w = sgtk_rep_to_int (p_w);
++
++ gtk_preview_draw_row (c_preview, c_data, c_x, c_y, c_w);
++
++ return Qnil;
++}
++
++DEFUN("gtk-preview-set-expand", Fgtk_preview_set_expand, Sgtk_preview_set_expand, (repv p_preview, repv p_expand), rep_Subr2)
++{
++ GtkPreview* c_preview;
++ int c_expand;
++
++ rep_DECLARE (1, p_preview, sgtk_is_a_gobj (gtk_preview_get_type (), p_preview));
++
++ c_preview = (GtkPreview*) sgtk_get_gobj (p_preview);
++ c_expand = sgtk_rep_to_bool (p_expand);
++
++ gtk_preview_set_expand (c_preview, c_expand);
++
++ return Qnil;
++}
++
++DEFUN("gtk-preview-set-gamma", Fgtk_preview_set_gamma, Sgtk_preview_set_gamma, (repv p_gamma), rep_Subr1)
++{
++ gdouble c_gamma;
++
++ rep_DECLARE (1, p_gamma, sgtk_valid_double (p_gamma));
++
++ c_gamma = sgtk_rep_to_double (p_gamma);
++
++ gtk_preview_set_gamma (c_gamma);
++
++ return Qnil;
++}
++
++DEFUN("gtk-preview-set-color-cube", Fgtk_preview_set_color_cube, Sgtk_preview_set_color_cube, (repv p_nred_shades, repv p_ngreen_shades, repv p_nblue_shades, repv p_ngray_shades), rep_Subr4)
++{
++ guint c_nred_shades;
++ guint c_ngreen_shades;
++ guint c_nblue_shades;
++ guint c_ngray_shades;
++
++ rep_DECLARE (1, p_nred_shades, sgtk_valid_uint (p_nred_shades));
++ rep_DECLARE (2, p_ngreen_shades, sgtk_valid_uint (p_ngreen_shades));
++ rep_DECLARE (3, p_nblue_shades, sgtk_valid_uint (p_nblue_shades));
++ rep_DECLARE (4, p_ngray_shades, sgtk_valid_uint (p_ngray_shades));
++
++ c_nred_shades = sgtk_rep_to_uint (p_nred_shades);
++ c_ngreen_shades = sgtk_rep_to_uint (p_ngreen_shades);
++ c_nblue_shades = sgtk_rep_to_uint (p_nblue_shades);
++ c_ngray_shades = sgtk_rep_to_uint (p_ngray_shades);
++
++ gtk_preview_set_color_cube (c_nred_shades, c_ngreen_shades, c_nblue_shades, c_ngray_shades);
++
++ return Qnil;
++}
++
++DEFUN("gtk-preview-set-install-cmap", Fgtk_preview_set_install_cmap, Sgtk_preview_set_install_cmap, (repv p_install_cmap), rep_Subr1)
++{
++ int c_install_cmap;
++
++
++ c_install_cmap = sgtk_rep_to_bool (p_install_cmap);
++
++ gtk_preview_set_install_cmap (c_install_cmap);
++
++ return Qnil;
++}
++
++DEFUN("gtk-preview-set-reserved", Fgtk_preview_set_reserved, Sgtk_preview_set_reserved, (repv p_nreserved), rep_Subr1)
++{
++ gint c_nreserved;
++
++ rep_DECLARE (1, p_nreserved, sgtk_valid_int (p_nreserved));
++
++ c_nreserved = sgtk_rep_to_int (p_nreserved);
++
++ gtk_preview_set_reserved (c_nreserved);
++
++ return Qnil;
++}
++
++DEFUN("gtk-file-selection-new", Fgtk_file_selection_new, Sgtk_file_selection_new, (repv p_title), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_title;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_title, sgtk_valid_string (p_title));
++
++ c_title = sgtk_rep_to_string (p_title);
++
++ cr_ret = gtk_file_selection_new (c_title);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-set-filename", Fgtk_file_selection_set_filename, Sgtk_file_selection_set_filename, (repv p_filesel, repv p_filename), rep_Subr2)
++{
++ GtkFileSelection* c_filesel;
++ char* c_filename;
++
++ rep_DECLARE (1, p_filesel, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_filesel));
++ rep_DECLARE (2, p_filename, sgtk_valid_string (p_filename));
++
++ c_filesel = (GtkFileSelection*) sgtk_get_gobj (p_filesel);
++ c_filename = sgtk_rep_to_string (p_filename);
++
++ gtk_file_selection_set_filename (c_filesel, c_filename);
++
++ return Qnil;
++}
++
++DEFUN("gtk-file-selection-get-filename", Fgtk_file_selection_get_filename, Sgtk_file_selection_get_filename, (repv p_filesel), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFileSelection* c_filesel;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_filesel, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_filesel));
++
++ c_filesel = (GtkFileSelection*) sgtk_get_gobj (p_filesel);
++
++ cr_ret = gtk_file_selection_get_filename (c_filesel);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-complete", Fgtk_file_selection_complete, Sgtk_file_selection_complete, (repv p_filesel, repv p_pattern), rep_Subr2)
++{
++ GtkFileSelection* c_filesel;
++ char* c_pattern;
++
++ rep_DECLARE (1, p_filesel, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_filesel));
++ rep_DECLARE (2, p_pattern, sgtk_valid_string (p_pattern));
++
++ c_filesel = (GtkFileSelection*) sgtk_get_gobj (p_filesel);
++ c_pattern = sgtk_rep_to_string (p_pattern);
++
++ gtk_file_selection_complete (c_filesel, c_pattern);
++
++ return Qnil;
++}
++
++DEFUN("gtk-file-selection-show-fileop-buttons", Fgtk_file_selection_show_fileop_buttons, Sgtk_file_selection_show_fileop_buttons, (repv p_filesel), rep_Subr1)
++{
++ GtkFileSelection* c_filesel;
++
++ rep_DECLARE (1, p_filesel, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_filesel));
++
++ c_filesel = (GtkFileSelection*) sgtk_get_gobj (p_filesel);
++
++ gtk_file_selection_show_fileop_buttons (c_filesel);
++
++ return Qnil;
++}
++
++DEFUN("gtk-file-selection-hide-fileop-buttons", Fgtk_file_selection_hide_fileop_buttons, Sgtk_file_selection_hide_fileop_buttons, (repv p_filesel), rep_Subr1)
++{
++ GtkFileSelection* c_filesel;
++
++ rep_DECLARE (1, p_filesel, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_filesel));
++
++ c_filesel = (GtkFileSelection*) sgtk_get_gobj (p_filesel);
++
++ gtk_file_selection_hide_fileop_buttons (c_filesel);
++
++ return Qnil;
++}
++
++DEFUN("gtk-font-selection-dialog-new", Fgtk_font_selection_dialog_new, Sgtk_font_selection_dialog_new, (repv p_title), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_title;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_title, sgtk_valid_string (p_title));
++
++ c_title = sgtk_rep_to_string (p_title);
++
++ cr_ret = gtk_font_selection_dialog_new (c_title);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-font-selection-dialog-get-font-name", Fgtk_font_selection_dialog_get_font_name, Sgtk_font_selection_dialog_get_font_name, (repv p_fontsel), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFontSelectionDialog* c_fontsel;
++ char* cr_ret;
++
++ rep_DECLARE (1, p_fontsel, sgtk_is_a_gobj (gtk_font_selection_dialog_get_type (), p_fontsel));
++
++ c_fontsel = (GtkFontSelectionDialog*) sgtk_get_gobj (p_fontsel);
++
++ cr_ret = gtk_font_selection_dialog_get_font_name (c_fontsel);
++
++ pr_ret = sgtk_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-font-selection-dialog-set-font-name", Fgtk_font_selection_dialog_set_font_name, Sgtk_font_selection_dialog_set_font_name, (repv p_fontsel, repv p_fontname), rep_Subr2)
++{
++ repv pr_ret;
++ GtkFontSelectionDialog* c_fontsel;
++ char* c_fontname;
++ int cr_ret;
++
++ rep_DECLARE (1, p_fontsel, sgtk_is_a_gobj (gtk_font_selection_dialog_get_type (), p_fontsel));
++ rep_DECLARE (2, p_fontname, sgtk_valid_string (p_fontname));
++
++ c_fontsel = (GtkFontSelectionDialog*) sgtk_get_gobj (p_fontsel);
++ c_fontname = sgtk_rep_to_string (p_fontname);
++
++ cr_ret = gtk_font_selection_dialog_set_font_name (c_fontsel, c_fontname);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-font-selection-dialog-get-preview-text", Fgtk_font_selection_dialog_get_preview_text, Sgtk_font_selection_dialog_get_preview_text, (repv p_fontsel), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFontSelectionDialog* c_fontsel;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_fontsel, sgtk_is_a_gobj (gtk_font_selection_dialog_get_type (), p_fontsel));
++
++ c_fontsel = (GtkFontSelectionDialog*) sgtk_get_gobj (p_fontsel);
++
++ cr_ret = gtk_font_selection_dialog_get_preview_text (c_fontsel);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-font-selection-dialog-set-preview-text", Fgtk_font_selection_dialog_set_preview_text, Sgtk_font_selection_dialog_set_preview_text, (repv p_fontsel, repv p_text), rep_Subr2)
++{
++ GtkFontSelectionDialog* c_fontsel;
++ char* c_text;
++
++ rep_DECLARE (1, p_fontsel, sgtk_is_a_gobj (gtk_font_selection_dialog_get_type (), p_fontsel));
++ rep_DECLARE (2, p_text, sgtk_valid_string (p_text));
++
++ c_fontsel = (GtkFontSelectionDialog*) sgtk_get_gobj (p_fontsel);
++ c_text = sgtk_rep_to_string (p_text);
++
++ gtk_font_selection_dialog_set_preview_text (c_fontsel, c_text);
++
++ return Qnil;
++}
++
++DEFUN("gtk-color-selection-dialog-new", Fgtk_color_selection_dialog_new, Sgtk_color_selection_dialog_new, (repv p_title), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_title;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_title, sgtk_valid_string (p_title));
++
++ c_title = sgtk_rep_to_string (p_title);
++
++ cr_ret = gtk_color_selection_dialog_new (c_title);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-color-selection-new", Fgtk_color_selection_new, Sgtk_color_selection_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_color_selection_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-color-selection-set-has-opacity-control", Fgtk_color_selection_set_has_opacity_control, Sgtk_color_selection_set_has_opacity_control, (repv p_colorsel, repv p_has_opacity), rep_Subr2)
++{
++ GtkColorSelection* c_colorsel;
++ int c_has_opacity;
++
++ rep_DECLARE (1, p_colorsel, sgtk_is_a_gobj (gtk_color_selection_get_type (), p_colorsel));
++
++ c_colorsel = (GtkColorSelection*) sgtk_get_gobj (p_colorsel);
++ c_has_opacity = sgtk_rep_to_bool (p_has_opacity);
++
++ gtk_color_selection_set_has_opacity_control (c_colorsel, c_has_opacity);
++
++ return Qnil;
++}
++
++DEFUN("gtk-color-selection-get-has-opacity-control", Fgtk_color_selection_get_has_opacity_control, Sgtk_color_selection_get_has_opacity_control, (repv p_colorsel), rep_Subr1)
++{
++ repv pr_ret;
++ GtkColorSelection* c_colorsel;
++ int cr_ret;
++
++ rep_DECLARE (1, p_colorsel, sgtk_is_a_gobj (gtk_color_selection_get_type (), p_colorsel));
++
++ c_colorsel = (GtkColorSelection*) sgtk_get_gobj (p_colorsel);
++
++ cr_ret = gtk_color_selection_get_has_opacity_control (c_colorsel);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-color-selection-get-has-palette", Fgtk_color_selection_get_has_palette, Sgtk_color_selection_get_has_palette, (repv p_colorsel), rep_Subr1)
++{
++ repv pr_ret;
++ GtkColorSelection* c_colorsel;
++ int cr_ret;
++
++ rep_DECLARE (1, p_colorsel, sgtk_is_a_gobj (gtk_color_selection_get_type (), p_colorsel));
++
++ c_colorsel = (GtkColorSelection*) sgtk_get_gobj (p_colorsel);
++
++ cr_ret = gtk_color_selection_get_has_palette (c_colorsel);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-color-selection-set-has-palette", Fgtk_color_selection_set_has_palette, Sgtk_color_selection_set_has_palette, (repv p_colorsel, repv p_setting), rep_Subr2)
++{
++ GtkColorSelection* c_colorsel;
++ int c_setting;
++
++ rep_DECLARE (1, p_colorsel, sgtk_is_a_gobj (gtk_color_selection_get_type (), p_colorsel));
++
++ c_colorsel = (GtkColorSelection*) sgtk_get_gobj (p_colorsel);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_color_selection_set_has_palette (c_colorsel, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-color-selection-set-current-color", Fgtk_color_selection_set_current_color, Sgtk_color_selection_set_current_color, (repv p_colorsel, repv p_color), rep_Subr2)
++{
++ GtkColorSelection* c_colorsel;
++ GdkColor* c_color;
++
++ rep_DECLARE (1, p_colorsel, sgtk_is_a_gobj (gtk_color_selection_get_type (), p_colorsel));
++ rep_DECLARE (2, p_color, sgtk_valid_boxed (p_color, &sgtk_gdk_color_info));
++
++ c_colorsel = (GtkColorSelection*) sgtk_get_gobj (p_colorsel);
++ c_color = (GdkColor*) sgtk_rep_to_boxed (p_color);
++
++ gtk_color_selection_set_current_color (c_colorsel, c_color);
++
++ return Qnil;
++}
++
++DEFUN("gtk-color-selection-set-current-alpha", Fgtk_color_selection_set_current_alpha, Sgtk_color_selection_set_current_alpha, (repv p_colorsel, repv p_alpha), rep_Subr2)
++{
++ GtkColorSelection* c_colorsel;
++ gushort c_alpha;
++
++ rep_DECLARE (1, p_colorsel, sgtk_is_a_gobj (gtk_color_selection_get_type (), p_colorsel));
++ rep_DECLARE (2, p_alpha, sgtk_valid_uint (p_alpha));
++
++ c_colorsel = (GtkColorSelection*) sgtk_get_gobj (p_colorsel);
++ c_alpha = sgtk_rep_to_uint (p_alpha);
++
++ gtk_color_selection_set_current_alpha (c_colorsel, c_alpha);
++
++ return Qnil;
++}
++
++DEFUN("gtk-color-selection-get-current-alpha", Fgtk_color_selection_get_current_alpha, Sgtk_color_selection_get_current_alpha, (repv p_colorsel), rep_Subr1)
++{
++ repv pr_ret;
++ GtkColorSelection* c_colorsel;
++ gushort cr_ret;
++
++ rep_DECLARE (1, p_colorsel, sgtk_is_a_gobj (gtk_color_selection_get_type (), p_colorsel));
++
++ c_colorsel = (GtkColorSelection*) sgtk_get_gobj (p_colorsel);
++
++ cr_ret = gtk_color_selection_get_current_alpha (c_colorsel);
++
++ pr_ret = sgtk_uint_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-color-selection-is-adjusting", Fgtk_color_selection_is_adjusting, Sgtk_color_selection_is_adjusting, (repv p_colorsel), rep_Subr1)
++{
++ repv pr_ret;
++ GtkColorSelection* c_colorsel;
++ int cr_ret;
++
++ rep_DECLARE (1, p_colorsel, sgtk_is_a_gobj (gtk_color_selection_get_type (), p_colorsel));
++
++ c_colorsel = (GtkColorSelection*) sgtk_get_gobj (p_colorsel);
++
++ cr_ret = gtk_color_selection_is_adjusting (c_colorsel);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-color-selection-set-color-interp", Fgtk_color_selection_set_color_interp, Sgtk_color_selection_set_color_interp, (repv p_colorsel, repv p_color), rep_Subr2)
++{
++ GtkColorSelection* c_colorsel;
++ GdkColor* c_color;
++
++ rep_DECLARE (1, p_colorsel, sgtk_is_a_gobj (gtk_color_selection_get_type (), p_colorsel));
++ rep_DECLARE (2, p_color, sgtk_valid_boxed (p_color, &sgtk_gdk_color_info));
++
++ c_colorsel = (GtkColorSelection*) sgtk_get_gobj (p_colorsel);
++ c_color = (GdkColor*) sgtk_rep_to_boxed (p_color);
++
++ gtk_color_selection_set_color_interp (c_colorsel, c_color);
++
++ return Qnil;
++}
++
++DEFUN("gtk-color-selection-get-color-interp", Fgtk_color_selection_get_color_interp, Sgtk_color_selection_get_color_interp, (repv p_colorsel), rep_Subr1)
++{
++ repv pr_ret;
++ GtkColorSelection* c_colorsel;
++ GdkColor* cr_ret;
++
++ rep_DECLARE (1, p_colorsel, sgtk_is_a_gobj (gtk_color_selection_get_type (), p_colorsel));
++
++ c_colorsel = (GtkColorSelection*) sgtk_get_gobj (p_colorsel);
++
++ cr_ret = gtk_color_selection_get_color_interp (c_colorsel);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_color_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-range-set-update-policy", Fgtk_range_set_update_policy, Sgtk_range_set_update_policy, (repv p_range, repv p_policy), rep_Subr2)
++{
++ GtkRange* c_range;
++ GtkUpdateType c_policy;
++
++ rep_DECLARE (1, p_range, sgtk_is_a_gobj (gtk_range_get_type (), p_range));
++ rep_DECLARE (2, p_policy, sgtk_valid_enum (p_policy, &sgtk_gtk_update_type_info));
++
++ c_range = (GtkRange*) sgtk_get_gobj (p_range);
++ c_policy = (GtkUpdateType) sgtk_rep_to_enum (p_policy, &sgtk_gtk_update_type_info);
++
++ gtk_range_set_update_policy (c_range, c_policy);
++
++ return Qnil;
++}
++
++DEFUN("gtk-range-get-update-policy", Fgtk_range_get_update_policy, Sgtk_range_get_update_policy, (repv p_range), rep_Subr1)
++{
++ repv pr_ret;
++ GtkRange* c_range;
++ GtkUpdateType cr_ret;
++
++ rep_DECLARE (1, p_range, sgtk_is_a_gobj (gtk_range_get_type (), p_range));
++
++ c_range = (GtkRange*) sgtk_get_gobj (p_range);
++
++ cr_ret = gtk_range_get_update_policy (c_range);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_update_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-range-set-adjustment", Fgtk_range_set_adjustment, Sgtk_range_set_adjustment, (repv p_range, repv p_adjustment), rep_Subr2)
++{
++ GtkRange* c_range;
++ GtkAdjustment* c_adjustment;
++
++ rep_DECLARE (1, p_range, sgtk_is_a_gobj (gtk_range_get_type (), p_range));
++ rep_DECLARE (2, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_range = (GtkRange*) sgtk_get_gobj (p_range);
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ gtk_range_set_adjustment (c_range, c_adjustment);
++
++ return Qnil;
++}
++
++DEFUN("gtk-range-get-adjustment", Fgtk_range_get_adjustment, Sgtk_range_get_adjustment, (repv p_range), rep_Subr1)
++{
++ repv pr_ret;
++ GtkRange* c_range;
++ GtkAdjustment* cr_ret;
++
++ rep_DECLARE (1, p_range, sgtk_is_a_gobj (gtk_range_get_type (), p_range));
++
++ c_range = (GtkRange*) sgtk_get_gobj (p_range);
++
++ cr_ret = gtk_range_get_adjustment (c_range);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-range-set-inverted", Fgtk_range_set_inverted, Sgtk_range_set_inverted, (repv p_range, repv p_setting), rep_Subr2)
++{
++ GtkRange* c_range;
++ int c_setting;
++
++ rep_DECLARE (1, p_range, sgtk_is_a_gobj (gtk_range_get_type (), p_range));
++
++ c_range = (GtkRange*) sgtk_get_gobj (p_range);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_range_set_inverted (c_range, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-range-get-inverted", Fgtk_range_get_inverted, Sgtk_range_get_inverted, (repv p_range), rep_Subr1)
++{
++ repv pr_ret;
++ GtkRange* c_range;
++ int cr_ret;
++
++ rep_DECLARE (1, p_range, sgtk_is_a_gobj (gtk_range_get_type (), p_range));
++
++ c_range = (GtkRange*) sgtk_get_gobj (p_range);
++
++ cr_ret = gtk_range_get_inverted (c_range);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-range-set-increments", Fgtk_range_set_increments, Sgtk_range_set_increments, (repv p_range, repv p_step, repv p_page), rep_Subr3)
++{
++ GtkRange* c_range;
++ gdouble c_step;
++ gdouble c_page;
++
++ rep_DECLARE (1, p_range, sgtk_is_a_gobj (gtk_range_get_type (), p_range));
++ rep_DECLARE (2, p_step, sgtk_valid_double (p_step));
++ rep_DECLARE (3, p_page, sgtk_valid_double (p_page));
++
++ c_range = (GtkRange*) sgtk_get_gobj (p_range);
++ c_step = sgtk_rep_to_double (p_step);
++ c_page = sgtk_rep_to_double (p_page);
++
++ gtk_range_set_increments (c_range, c_step, c_page);
++
++ return Qnil;
++}
++
++DEFUN("gtk-range-set-range", Fgtk_range_set_range, Sgtk_range_set_range, (repv p_range, repv p_min, repv p_max), rep_Subr3)
++{
++ GtkRange* c_range;
++ gdouble c_min;
++ gdouble c_max;
++
++ rep_DECLARE (1, p_range, sgtk_is_a_gobj (gtk_range_get_type (), p_range));
++ rep_DECLARE (2, p_min, sgtk_valid_double (p_min));
++ rep_DECLARE (3, p_max, sgtk_valid_double (p_max));
++
++ c_range = (GtkRange*) sgtk_get_gobj (p_range);
++ c_min = sgtk_rep_to_double (p_min);
++ c_max = sgtk_rep_to_double (p_max);
++
++ gtk_range_set_range (c_range, c_min, c_max);
++
++ return Qnil;
++}
++
++DEFUN("gtk-range-set-value", Fgtk_range_set_value, Sgtk_range_set_value, (repv p_range, repv p_value), rep_Subr2)
++{
++ GtkRange* c_range;
++ gdouble c_value;
++
++ rep_DECLARE (1, p_range, sgtk_is_a_gobj (gtk_range_get_type (), p_range));
++ rep_DECLARE (2, p_value, sgtk_valid_double (p_value));
++
++ c_range = (GtkRange*) sgtk_get_gobj (p_range);
++ c_value = sgtk_rep_to_double (p_value);
++
++ gtk_range_set_value (c_range, c_value);
++
++ return Qnil;
++}
++
++DEFUN("gtk-range-get-value", Fgtk_range_get_value, Sgtk_range_get_value, (repv p_range), rep_Subr1)
++{
++ repv pr_ret;
++ GtkRange* c_range;
++ gdouble cr_ret;
++
++ rep_DECLARE (1, p_range, sgtk_is_a_gobj (gtk_range_get_type (), p_range));
++
++ c_range = (GtkRange*) sgtk_get_gobj (p_range);
++
++ cr_ret = gtk_range_get_value (c_range);
++
++ pr_ret = sgtk_double_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-scale-set-digits", Fgtk_scale_set_digits, Sgtk_scale_set_digits, (repv p_scale, repv p_digits), rep_Subr2)
++{
++ GtkScale* c_scale;
++ gint c_digits;
++
++ rep_DECLARE (1, p_scale, sgtk_is_a_gobj (gtk_scale_get_type (), p_scale));
++ rep_DECLARE (2, p_digits, sgtk_valid_int (p_digits));
++
++ c_scale = (GtkScale*) sgtk_get_gobj (p_scale);
++ c_digits = sgtk_rep_to_int (p_digits);
++
++ gtk_scale_set_digits (c_scale, c_digits);
++
++ return Qnil;
++}
++
++DEFUN("gtk-scale-get-digits", Fgtk_scale_get_digits, Sgtk_scale_get_digits, (repv p_scale), rep_Subr1)
++{
++ repv pr_ret;
++ GtkScale* c_scale;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_scale, sgtk_is_a_gobj (gtk_scale_get_type (), p_scale));
++
++ c_scale = (GtkScale*) sgtk_get_gobj (p_scale);
++
++ cr_ret = gtk_scale_get_digits (c_scale);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-scale-set-draw-value", Fgtk_scale_set_draw_value, Sgtk_scale_set_draw_value, (repv p_scale, repv p_draw_value), rep_Subr2)
++{
++ GtkScale* c_scale;
++ int c_draw_value;
++
++ rep_DECLARE (1, p_scale, sgtk_is_a_gobj (gtk_scale_get_type (), p_scale));
++
++ c_scale = (GtkScale*) sgtk_get_gobj (p_scale);
++ c_draw_value = sgtk_rep_to_bool (p_draw_value);
++
++ gtk_scale_set_draw_value (c_scale, c_draw_value);
++
++ return Qnil;
++}
++
++DEFUN("gtk-scale-get-draw-value", Fgtk_scale_get_draw_value, Sgtk_scale_get_draw_value, (repv p_scale), rep_Subr1)
++{
++ repv pr_ret;
++ GtkScale* c_scale;
++ int cr_ret;
++
++ rep_DECLARE (1, p_scale, sgtk_is_a_gobj (gtk_scale_get_type (), p_scale));
++
++ c_scale = (GtkScale*) sgtk_get_gobj (p_scale);
++
++ cr_ret = gtk_scale_get_draw_value (c_scale);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-scale-set-value-pos", Fgtk_scale_set_value_pos, Sgtk_scale_set_value_pos, (repv p_scale, repv p_pos), rep_Subr2)
++{
++ GtkScale* c_scale;
++ GtkPositionType c_pos;
++
++ rep_DECLARE (1, p_scale, sgtk_is_a_gobj (gtk_scale_get_type (), p_scale));
++ rep_DECLARE (2, p_pos, sgtk_valid_enum (p_pos, &sgtk_gtk_position_type_info));
++
++ c_scale = (GtkScale*) sgtk_get_gobj (p_scale);
++ c_pos = (GtkPositionType) sgtk_rep_to_enum (p_pos, &sgtk_gtk_position_type_info);
++
++ gtk_scale_set_value_pos (c_scale, c_pos);
++
++ return Qnil;
++}
++
++DEFUN("gtk-scale-get-value-pos", Fgtk_scale_get_value_pos, Sgtk_scale_get_value_pos, (repv p_scale), rep_Subr1)
++{
++ repv pr_ret;
++ GtkScale* c_scale;
++ GtkPositionType cr_ret;
++
++ rep_DECLARE (1, p_scale, sgtk_is_a_gobj (gtk_scale_get_type (), p_scale));
++
++ c_scale = (GtkScale*) sgtk_get_gobj (p_scale);
++
++ cr_ret = gtk_scale_get_value_pos (c_scale);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_position_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-hscale-new", Fgtk_hscale_new, Sgtk_hscale_new, (repv p_adjustment), rep_Subr1)
++{
++ repv pr_ret;
++ GtkAdjustment* c_adjustment;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ cr_ret = gtk_hscale_new (c_adjustment);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-hscale-new-with-range", Fgtk_hscale_new_with_range, Sgtk_hscale_new_with_range, (repv p_min, repv p_max, repv p_step), rep_Subr3)
++{
++ repv pr_ret;
++ gdouble c_min;
++ gdouble c_max;
++ gdouble c_step;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_min, sgtk_valid_double (p_min));
++ rep_DECLARE (2, p_max, sgtk_valid_double (p_max));
++ rep_DECLARE (3, p_step, sgtk_valid_double (p_step));
++
++ c_min = sgtk_rep_to_double (p_min);
++ c_max = sgtk_rep_to_double (p_max);
++ c_step = sgtk_rep_to_double (p_step);
++
++ cr_ret = gtk_hscale_new_with_range (c_min, c_max, c_step);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-vscale-new", Fgtk_vscale_new, Sgtk_vscale_new, (repv p_adjustment), rep_Subr1)
++{
++ repv pr_ret;
++ GtkAdjustment* c_adjustment;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ cr_ret = gtk_vscale_new (c_adjustment);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-vscale-new-with-range", Fgtk_vscale_new_with_range, Sgtk_vscale_new_with_range, (repv p_min, repv p_max, repv p_step), rep_Subr3)
++{
++ repv pr_ret;
++ gdouble c_min;
++ gdouble c_max;
++ gdouble c_step;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_min, sgtk_valid_double (p_min));
++ rep_DECLARE (2, p_max, sgtk_valid_double (p_max));
++ rep_DECLARE (3, p_step, sgtk_valid_double (p_step));
++
++ c_min = sgtk_rep_to_double (p_min);
++ c_max = sgtk_rep_to_double (p_max);
++ c_step = sgtk_rep_to_double (p_step);
++
++ cr_ret = gtk_vscale_new_with_range (c_min, c_max, c_step);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-hscrollbar-new", Fgtk_hscrollbar_new, Sgtk_hscrollbar_new, (repv p_adjustment), rep_Subr1)
++{
++ repv pr_ret;
++ GtkAdjustment* c_adjustment;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ cr_ret = gtk_hscrollbar_new (c_adjustment);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-vscrollbar-new", Fgtk_vscrollbar_new, Sgtk_vscrollbar_new, (repv p_adjustment), rep_Subr1)
++{
++ repv pr_ret;
++ GtkAdjustment* c_adjustment;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_adjustment, sgtk_is_a_gobj (gtk_adjustment_get_type (), p_adjustment));
++
++ c_adjustment = (GtkAdjustment*) sgtk_get_gobj (p_adjustment);
++
++ cr_ret = gtk_vscrollbar_new (c_adjustment);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-ruler-set-metric", Fgtk_ruler_set_metric, Sgtk_ruler_set_metric, (repv p_ruler, repv p_metric), rep_Subr2)
++{
++ GtkRuler* c_ruler;
++ GtkMetricType c_metric;
++
++ rep_DECLARE (1, p_ruler, sgtk_is_a_gobj (gtk_ruler_get_type (), p_ruler));
++ rep_DECLARE (2, p_metric, sgtk_valid_enum (p_metric, &sgtk_gtk_metric_type_info));
++
++ c_ruler = (GtkRuler*) sgtk_get_gobj (p_ruler);
++ c_metric = (GtkMetricType) sgtk_rep_to_enum (p_metric, &sgtk_gtk_metric_type_info);
++
++ gtk_ruler_set_metric (c_ruler, c_metric);
++
++ return Qnil;
++}
++
++DEFUN("gtk-ruler-set-range", Fgtk_ruler_set_range, Sgtk_ruler_set_range, (repv p_ruler, repv p_lower, repv p_upper, repv p_position, repv p_max_size), rep_Subr5)
++{
++ GtkRuler* c_ruler;
++ gfloat c_lower;
++ gfloat c_upper;
++ gfloat c_position;
++ gfloat c_max_size;
++
++ rep_DECLARE (1, p_ruler, sgtk_is_a_gobj (gtk_ruler_get_type (), p_ruler));
++ rep_DECLARE (2, p_lower, sgtk_valid_float (p_lower));
++ rep_DECLARE (3, p_upper, sgtk_valid_float (p_upper));
++ rep_DECLARE (4, p_position, sgtk_valid_float (p_position));
++ rep_DECLARE (5, p_max_size, sgtk_valid_float (p_max_size));
++
++ c_ruler = (GtkRuler*) sgtk_get_gobj (p_ruler);
++ c_lower = sgtk_rep_to_float (p_lower);
++ c_upper = sgtk_rep_to_float (p_upper);
++ c_position = sgtk_rep_to_float (p_position);
++ c_max_size = sgtk_rep_to_float (p_max_size);
++
++ gtk_ruler_set_range (c_ruler, c_lower, c_upper, c_position, c_max_size);
++
++ return Qnil;
++}
++
++DEFUN("gtk-ruler-draw-ticks", Fgtk_ruler_draw_ticks, Sgtk_ruler_draw_ticks, (repv p_ruler), rep_Subr1)
++{
++ GtkRuler* c_ruler;
++
++ rep_DECLARE (1, p_ruler, sgtk_is_a_gobj (gtk_ruler_get_type (), p_ruler));
++
++ c_ruler = (GtkRuler*) sgtk_get_gobj (p_ruler);
++
++ gtk_ruler_draw_ticks (c_ruler);
++
++ return Qnil;
++}
++
++DEFUN("gtk-ruler-draw-pos", Fgtk_ruler_draw_pos, Sgtk_ruler_draw_pos, (repv p_ruler), rep_Subr1)
++{
++ GtkRuler* c_ruler;
++
++ rep_DECLARE (1, p_ruler, sgtk_is_a_gobj (gtk_ruler_get_type (), p_ruler));
++
++ c_ruler = (GtkRuler*) sgtk_get_gobj (p_ruler);
++
++ gtk_ruler_draw_pos (c_ruler);
++
++ return Qnil;
++}
++
++DEFUN("gtk-ruler-get-metric", Fgtk_ruler_get_metric, Sgtk_ruler_get_metric, (repv p_ruler), rep_Subr1)
++{
++ repv pr_ret;
++ GtkRuler* c_ruler;
++ GtkMetricType cr_ret;
++
++ rep_DECLARE (1, p_ruler, sgtk_is_a_gobj (gtk_ruler_get_type (), p_ruler));
++
++ c_ruler = (GtkRuler*) sgtk_get_gobj (p_ruler);
++
++ cr_ret = gtk_ruler_get_metric (c_ruler);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_metric_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-hruler-new", Fgtk_hruler_new, Sgtk_hruler_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_hruler_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-vruler-new", Fgtk_vruler_new, Sgtk_vruler_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_vruler_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-dialog-new", Fgtk_dialog_new, Sgtk_dialog_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_dialog_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-dialog-add-button", Fgtk_dialog_add_button, Sgtk_dialog_add_button, (repv p_dialog, repv p_button_text, repv p_response_id), rep_Subr3)
++{
++ repv pr_ret;
++ GtkDialog* c_dialog;
++ char* c_button_text;
++ gint c_response_id;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_dialog, sgtk_is_a_gobj (gtk_dialog_get_type (), p_dialog));
++ rep_DECLARE (2, p_button_text, sgtk_valid_string (p_button_text));
++ rep_DECLARE (3, p_response_id, sgtk_valid_int (p_response_id));
++
++ c_dialog = (GtkDialog*) sgtk_get_gobj (p_dialog);
++ c_button_text = sgtk_rep_to_string (p_button_text);
++ c_response_id = sgtk_rep_to_int (p_response_id);
++
++ cr_ret = gtk_dialog_add_button (c_dialog, c_button_text, c_response_id);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-dialog-set-response-sensitive", Fgtk_dialog_set_response_sensitive, Sgtk_dialog_set_response_sensitive, (repv p_dialog, repv p_response_id, repv p_setting), rep_Subr3)
++{
++ GtkDialog* c_dialog;
++ gint c_response_id;
++ int c_setting;
++
++ rep_DECLARE (1, p_dialog, sgtk_is_a_gobj (gtk_dialog_get_type (), p_dialog));
++ rep_DECLARE (2, p_response_id, sgtk_valid_int (p_response_id));
++
++ c_dialog = (GtkDialog*) sgtk_get_gobj (p_dialog);
++ c_response_id = sgtk_rep_to_int (p_response_id);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_dialog_set_response_sensitive (c_dialog, c_response_id, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-dialog-set-default-response", Fgtk_dialog_set_default_response, Sgtk_dialog_set_default_response, (repv p_dialog, repv p_response_id), rep_Subr2)
++{
++ GtkDialog* c_dialog;
++ gint c_response_id;
++
++ rep_DECLARE (1, p_dialog, sgtk_is_a_gobj (gtk_dialog_get_type (), p_dialog));
++ rep_DECLARE (2, p_response_id, sgtk_valid_int (p_response_id));
++
++ c_dialog = (GtkDialog*) sgtk_get_gobj (p_dialog);
++ c_response_id = sgtk_rep_to_int (p_response_id);
++
++ gtk_dialog_set_default_response (c_dialog, c_response_id);
++
++ return Qnil;
++}
++
++DEFUN("gtk-dialog-set-has-separator", Fgtk_dialog_set_has_separator, Sgtk_dialog_set_has_separator, (repv p_dialog, repv p_setting), rep_Subr2)
++{
++ GtkDialog* c_dialog;
++ int c_setting;
++
++ rep_DECLARE (1, p_dialog, sgtk_is_a_gobj (gtk_dialog_get_type (), p_dialog));
++
++ c_dialog = (GtkDialog*) sgtk_get_gobj (p_dialog);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_dialog_set_has_separator (c_dialog, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-dialog-get-has-separator", Fgtk_dialog_get_has_separator, Sgtk_dialog_get_has_separator, (repv p_dialog), rep_Subr1)
++{
++ repv pr_ret;
++ GtkDialog* c_dialog;
++ int cr_ret;
++
++ rep_DECLARE (1, p_dialog, sgtk_is_a_gobj (gtk_dialog_get_type (), p_dialog));
++
++ c_dialog = (GtkDialog*) sgtk_get_gobj (p_dialog);
++
++ cr_ret = gtk_dialog_get_has_separator (c_dialog);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-dialog-response", Fgtk_dialog_response, Sgtk_dialog_response, (repv p_dialog, repv p_response_id), rep_Subr2)
++{
++ GtkDialog* c_dialog;
++ gint c_response_id;
++
++ rep_DECLARE (1, p_dialog, sgtk_is_a_gobj (gtk_dialog_get_type (), p_dialog));
++ rep_DECLARE (2, p_response_id, sgtk_valid_int (p_response_id));
++
++ c_dialog = (GtkDialog*) sgtk_get_gobj (p_dialog);
++ c_response_id = sgtk_rep_to_int (p_response_id);
++
++ gtk_dialog_response (c_dialog, c_response_id);
++
++ return Qnil;
++}
++
++DEFUN("gtk-dialog-run", Fgtk_dialog_run, Sgtk_dialog_run, (repv p_dialog), rep_Subr1)
++{
++ repv pr_ret;
++ GtkDialog* c_dialog;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_dialog, sgtk_is_a_gobj (gtk_dialog_get_type (), p_dialog));
++
++ c_dialog = (GtkDialog*) sgtk_get_gobj (p_dialog);
++
++ cr_ret = gtk_dialog_run (c_dialog);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-input-dialog-new", Fgtk_input_dialog_new, Sgtk_input_dialog_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_input_dialog_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-paned-add1", Fgtk_paned_add1, Sgtk_paned_add1, (repv p_paned, repv p_child), rep_Subr2)
++{
++ GtkPaned* c_paned;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_paned, sgtk_is_a_gobj (gtk_paned_get_type (), p_paned));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_paned = (GtkPaned*) sgtk_get_gobj (p_paned);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_paned_add1 (c_paned, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-paned-add2", Fgtk_paned_add2, Sgtk_paned_add2, (repv p_paned, repv p_child), rep_Subr2)
++{
++ GtkPaned* c_paned;
++ GtkWidget* c_child;
++
++ rep_DECLARE (1, p_paned, sgtk_is_a_gobj (gtk_paned_get_type (), p_paned));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_paned = (GtkPaned*) sgtk_get_gobj (p_paned);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++
++ gtk_paned_add2 (c_paned, c_child);
++
++ return Qnil;
++}
++
++DEFUN("gtk-paned-pack1", Fgtk_paned_pack1, Sgtk_paned_pack1, (repv p_paned, repv p_child, repv p_resize, repv p_shrink), rep_Subr4)
++{
++ GtkPaned* c_paned;
++ GtkWidget* c_child;
++ int c_resize;
++ int c_shrink;
++
++ rep_DECLARE (1, p_paned, sgtk_is_a_gobj (gtk_paned_get_type (), p_paned));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_paned = (GtkPaned*) sgtk_get_gobj (p_paned);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_resize = sgtk_rep_to_bool (p_resize);
++ c_shrink = sgtk_rep_to_bool (p_shrink);
++
++ gtk_paned_pack1 (c_paned, c_child, c_resize, c_shrink);
++
++ return Qnil;
++}
++
++DEFUN("gtk-paned-pack2", Fgtk_paned_pack2, Sgtk_paned_pack2, (repv p_paned, repv p_child, repv p_resize, repv p_shrink), rep_Subr4)
++{
++ GtkPaned* c_paned;
++ GtkWidget* c_child;
++ int c_resize;
++ int c_shrink;
++
++ rep_DECLARE (1, p_paned, sgtk_is_a_gobj (gtk_paned_get_type (), p_paned));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++
++ c_paned = (GtkPaned*) sgtk_get_gobj (p_paned);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_resize = sgtk_rep_to_bool (p_resize);
++ c_shrink = sgtk_rep_to_bool (p_shrink);
++
++ gtk_paned_pack2 (c_paned, c_child, c_resize, c_shrink);
++
++ return Qnil;
++}
++
++DEFUN("gtk-paned-get-position", Fgtk_paned_get_position, Sgtk_paned_get_position, (repv p_paned), rep_Subr1)
++{
++ repv pr_ret;
++ GtkPaned* c_paned;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_paned, sgtk_is_a_gobj (gtk_paned_get_type (), p_paned));
++
++ c_paned = (GtkPaned*) sgtk_get_gobj (p_paned);
++
++ cr_ret = gtk_paned_get_position (c_paned);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-paned-set-position", Fgtk_paned_set_position, Sgtk_paned_set_position, (repv p_paned, repv p_position), rep_Subr2)
++{
++ GtkPaned* c_paned;
++ gint c_position;
++
++ rep_DECLARE (1, p_paned, sgtk_is_a_gobj (gtk_paned_get_type (), p_paned));
++ rep_DECLARE (2, p_position, sgtk_valid_int (p_position));
++
++ c_paned = (GtkPaned*) sgtk_get_gobj (p_paned);
++ c_position = sgtk_rep_to_int (p_position);
++
++ gtk_paned_set_position (c_paned, c_position);
++
++ return Qnil;
++}
++
++DEFUN("gtk-hpaned-new", Fgtk_hpaned_new, Sgtk_hpaned_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_hpaned_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-vpaned-new", Fgtk_vpaned_new, Sgtk_vpaned_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_vpaned_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-type-name", Fgtk_type_name, Sgtk_type_name, (repv p_type), rep_Subr1)
++{
++ repv pr_ret;
++ GtkType c_type;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_type, sgtk_valid_type (p_type));
++
++ c_type = sgtk_rep_to_type (p_type);
++
++ cr_ret = gtk_type_name (c_type);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-type-from-name", Fgtk_type_from_name, Sgtk_type_from_name, (repv p_name), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_name;
++ GtkType cr_ret;
++
++ rep_DECLARE (1, p_name, sgtk_valid_string (p_name));
++
++ c_name = sgtk_rep_to_string (p_name);
++
++ cr_ret = gtk_type_from_name (c_name);
++
++ pr_ret = sgtk_type_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-signal-set-class-function", Fgtk_signal_set_class_function, Sgtk_signal_set_class_function, (repv p_class, repv p_signal, repv p_function), rep_Subr3)
++{
++ rep_GC_root gc_function;
++ GtkType c_class;
++ char* c_signal;
++ sgtk_protshell* c_function;
++
++ rep_DECLARE (1, p_class, sgtk_valid_type (p_class));
++ rep_DECLARE (2, p_signal, sgtk_valid_string (p_signal));
++ rep_DECLARE (3, p_function, sgtk_valid_function (p_function));
++
++ rep_PUSHGC (gc_function, p_function);
++ c_class = sgtk_rep_to_type (p_class);
++ c_signal = sgtk_rep_to_string (p_signal);
++ c_function = sgtk_protect (Qt, p_function);
++
++ gtk_signal_set_class_function_full (c_class, c_signal, 0, sgtk_callback_marshal, (gpointer)c_function, sgtk_callback_destroy);
++
++ rep_POPGC;
++ return Qnil;
++}
++
++DEFUN("gtk-plug-construct", Fgtk_plug_construct, Sgtk_plug_construct, (repv p_plug, repv p_id), rep_Subr2)
++{
++ GtkPlug* c_plug;
++ guint c_id;
++
++ rep_DECLARE (1, p_plug, sgtk_is_a_gobj (gtk_plug_get_type (), p_plug));
++ rep_DECLARE (2, p_id, sgtk_valid_uint (p_id));
++
++ c_plug = (GtkPlug*) sgtk_get_gobj (p_plug);
++ c_id = sgtk_rep_to_uint (p_id);
++
++ gtk_plug_construct (c_plug, c_id);
++
++ return Qnil;
++}
++
++DEFUN("gtk-plug-new", Fgtk_plug_new, Sgtk_plug_new, (repv p_socket_id), rep_Subr1)
++{
++ repv pr_ret;
++ guint c_socket_id;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_socket_id, sgtk_valid_uint (p_socket_id));
++
++ c_socket_id = sgtk_rep_to_uint (p_socket_id);
++
++ cr_ret = gtk_plug_new (c_socket_id);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-socket-new", Fgtk_socket_new, Sgtk_socket_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_socket_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-socket-add-id", Fgtk_socket_add_id, Sgtk_socket_add_id, (repv p_socket, repv p_window_id), rep_Subr2)
++{
++ GtkSocket* c_socket;
++ gulong c_window_id;
++
++ rep_DECLARE (1, p_socket, sgtk_is_a_gobj (gtk_socket_get_type (), p_socket));
++ rep_DECLARE (2, p_window_id, sgtk_valid_ulong (p_window_id));
++
++ c_socket = (GtkSocket*) sgtk_get_gobj (p_socket);
++ c_window_id = sgtk_rep_to_ulong (p_window_id);
++
++ gtk_socket_add_id (c_socket, c_window_id);
++
++ return Qnil;
++}
++
++DEFUN("gtk-socket-get-id", Fgtk_socket_get_id, Sgtk_socket_get_id, (repv p_socket), rep_Subr1)
++{
++ repv pr_ret;
++ GtkSocket* c_socket;
++ gulong cr_ret;
++
++ rep_DECLARE (1, p_socket, sgtk_is_a_gobj (gtk_socket_get_type (), p_socket));
++
++ c_socket = (GtkSocket*) sgtk_get_gobj (p_socket);
++
++ cr_ret = gtk_socket_get_id (c_socket);
++
++ pr_ret = sgtk_ulong_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-tearoff-menu-item-new", Fgtk_tearoff_menu_item_new, Sgtk_tearoff_menu_item_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_tearoff_menu_item_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-calendar-new", Fgtk_calendar_new, Sgtk_calendar_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_calendar_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-calendar-select-month", Fgtk_calendar_select_month, Sgtk_calendar_select_month, (repv p_cal, repv p_month, repv p_year), rep_Subr3)
++{
++ GtkCalendar* c_cal;
++ guint c_month;
++ guint c_year;
++
++ rep_DECLARE (1, p_cal, sgtk_is_a_gobj (gtk_calendar_get_type (), p_cal));
++ rep_DECLARE (2, p_month, sgtk_valid_uint (p_month));
++ rep_DECLARE (3, p_year, sgtk_valid_uint (p_year));
++
++ c_cal = (GtkCalendar*) sgtk_get_gobj (p_cal);
++ c_month = sgtk_rep_to_uint (p_month);
++ c_year = sgtk_rep_to_uint (p_year);
++
++ gtk_calendar_select_month (c_cal, c_month, c_year);
++
++ return Qnil;
++}
++
++DEFUN("gtk-calendar-select-day", Fgtk_calendar_select_day, Sgtk_calendar_select_day, (repv p_cal, repv p_day), rep_Subr2)
++{
++ GtkCalendar* c_cal;
++ guint c_day;
++
++ rep_DECLARE (1, p_cal, sgtk_is_a_gobj (gtk_calendar_get_type (), p_cal));
++ rep_DECLARE (2, p_day, sgtk_valid_uint (p_day));
++
++ c_cal = (GtkCalendar*) sgtk_get_gobj (p_cal);
++ c_day = sgtk_rep_to_uint (p_day);
++
++ gtk_calendar_select_day (c_cal, c_day);
++
++ return Qnil;
++}
++
++DEFUN("gtk-calendar-mark-day", Fgtk_calendar_mark_day, Sgtk_calendar_mark_day, (repv p_cal, repv p_day), rep_Subr2)
++{
++ repv pr_ret;
++ GtkCalendar* c_cal;
++ guint c_day;
++ int cr_ret;
++
++ rep_DECLARE (1, p_cal, sgtk_is_a_gobj (gtk_calendar_get_type (), p_cal));
++ rep_DECLARE (2, p_day, sgtk_valid_uint (p_day));
++
++ c_cal = (GtkCalendar*) sgtk_get_gobj (p_cal);
++ c_day = sgtk_rep_to_uint (p_day);
++
++ cr_ret = gtk_calendar_mark_day (c_cal, c_day);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-calendar-unmark-day", Fgtk_calendar_unmark_day, Sgtk_calendar_unmark_day, (repv p_cal, repv p_day), rep_Subr2)
++{
++ repv pr_ret;
++ GtkCalendar* c_cal;
++ guint c_day;
++ int cr_ret;
++
++ rep_DECLARE (1, p_cal, sgtk_is_a_gobj (gtk_calendar_get_type (), p_cal));
++ rep_DECLARE (2, p_day, sgtk_valid_uint (p_day));
++
++ c_cal = (GtkCalendar*) sgtk_get_gobj (p_cal);
++ c_day = sgtk_rep_to_uint (p_day);
++
++ cr_ret = gtk_calendar_unmark_day (c_cal, c_day);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-calendar-clear-marks", Fgtk_calendar_clear_marks, Sgtk_calendar_clear_marks, (repv p_cal), rep_Subr1)
++{
++ GtkCalendar* c_cal;
++
++ rep_DECLARE (1, p_cal, sgtk_is_a_gobj (gtk_calendar_get_type (), p_cal));
++
++ c_cal = (GtkCalendar*) sgtk_get_gobj (p_cal);
++
++ gtk_calendar_clear_marks (c_cal);
++
++ return Qnil;
++}
++
++DEFUN("gtk-calendar-display-options", Fgtk_calendar_display_options, Sgtk_calendar_display_options, (repv p_cal, repv p_flags), rep_Subr2)
++{
++ GtkCalendar* c_cal;
++ GtkCalendarDisplayOptions c_flags;
++
++ rep_DECLARE (1, p_cal, sgtk_is_a_gobj (gtk_calendar_get_type (), p_cal));
++ rep_DECLARE (2, p_flags, sgtk_valid_flags (p_flags, &sgtk_gtk_calendar_display_options_info));
++
++ c_cal = (GtkCalendar*) sgtk_get_gobj (p_cal);
++ c_flags = (GtkCalendarDisplayOptions) sgtk_rep_to_flags (p_flags, &sgtk_gtk_calendar_display_options_info);
++
++ gtk_calendar_display_options (c_cal, c_flags);
++
++ return Qnil;
++}
++
++/* helpers for uint */
++static int
++_sgtk_helper_valid_uint (repv obj)
++{
++ return obj == Qnil || (sgtk_valid_uint (obj));
++}
++static void
++_sgtk_helper_fromrep_uint (repv obj, void *mem)
++{
++ *(guint*)mem = sgtk_rep_to_uint (obj);
++}
++static repv
++_sgtk_helper_torep_copy_uint (void *mem)
++{
++ return sgtk_uint_to_rep (*(guint*)mem);
++}
++static repv
++_sgtk_helper_torep_nocopy_uint (void *mem)
++{
++ return sgtk_uint_to_rep (*(guint*)mem);
++}
++
++DEFUN("gtk-calendar-get-date", Fgtk_calendar_get_date, Sgtk_calendar_get_date, (repv p_cal, repv p_year, repv p_month, repv p_day), rep_Subr4)
++{
++ rep_GC_root gc_year;
++ rep_GC_root gc_month;
++ rep_GC_root gc_day;
++ GtkCalendar* c_cal;
++ sgtk_cvec c_year;
++ sgtk_cvec c_month;
++ sgtk_cvec c_day;
++
++ rep_DECLARE (1, p_cal, sgtk_is_a_gobj (gtk_calendar_get_type (), p_cal));
++ rep_DECLARE (2, p_year, sgtk_valid_complen (p_year, NULL, 1));
++ rep_DECLARE (3, p_month, sgtk_valid_complen (p_month, NULL, 1));
++ rep_DECLARE (4, p_day, sgtk_valid_complen (p_day, NULL, 1));
++
++ rep_PUSHGC (gc_year, p_year);
++ rep_PUSHGC (gc_month, p_month);
++ rep_PUSHGC (gc_day, p_day);
++ c_cal = (GtkCalendar*) sgtk_get_gobj (p_cal);
++ c_year = sgtk_rep_to_cvec (p_year, 0, sizeof (guint));
++ c_month = sgtk_rep_to_cvec (p_month, 0, sizeof (guint));
++ c_day = sgtk_rep_to_cvec (p_day, 0, sizeof (guint));
++
++ gtk_calendar_get_date (c_cal, (guint*) c_year.vec, (guint*) c_month.vec, (guint*) c_day.vec);
++
++ sgtk_cvec_finish (&c_year, p_year, _sgtk_helper_torep_nocopy_uint, sizeof (guint));
++ sgtk_cvec_finish (&c_month, p_month, _sgtk_helper_torep_nocopy_uint, sizeof (guint));
++ sgtk_cvec_finish (&c_day, p_day, _sgtk_helper_torep_nocopy_uint, sizeof (guint));
++ rep_POPGC;
++ rep_POPGC;
++ rep_POPGC;
++ return Qnil;
++}
++
++DEFUN("gtk-calendar-freeze", Fgtk_calendar_freeze, Sgtk_calendar_freeze, (repv p_cal), rep_Subr1)
++{
++ GtkCalendar* c_cal;
++
++ rep_DECLARE (1, p_cal, sgtk_is_a_gobj (gtk_calendar_get_type (), p_cal));
++
++ c_cal = (GtkCalendar*) sgtk_get_gobj (p_cal);
++
++ gtk_calendar_freeze (c_cal);
++
++ return Qnil;
++}
++
++DEFUN("gtk-calendar-thaw", Fgtk_calendar_thaw, Sgtk_calendar_thaw, (repv p_cal), rep_Subr1)
++{
++ GtkCalendar* c_cal;
++
++ rep_DECLARE (1, p_cal, sgtk_is_a_gobj (gtk_calendar_get_type (), p_cal));
++
++ c_cal = (GtkCalendar*) sgtk_get_gobj (p_cal);
++
++ gtk_calendar_thaw (c_cal);
++
++ return Qnil;
++}
++
++DEFUN("gtk-icon-factory-new", Fgtk_icon_factory_new, Sgtk_icon_factory_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkIconFactory* cr_ret;
++
++ cr_ret = gtk_icon_factory_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-icon-factory-add", Fgtk_icon_factory_add, Sgtk_icon_factory_add, (repv p_factory, repv p_stock_id, repv p_icon_set), rep_Subr3)
++{
++ GtkIconFactory* c_factory;
++ char* c_stock_id;
++ GtkIconSet* c_icon_set;
++
++ rep_DECLARE (1, p_factory, sgtk_is_a_gobj (gtk_icon_factory_get_type (), p_factory));
++ rep_DECLARE (2, p_stock_id, sgtk_valid_string (p_stock_id));
++ rep_DECLARE (3, p_icon_set, sgtk_valid_boxed (p_icon_set, &sgtk_gtk_icon_set_info));
++
++ c_factory = (GtkIconFactory*) sgtk_get_gobj (p_factory);
++ c_stock_id = sgtk_rep_to_string (p_stock_id);
++ c_icon_set = (GtkIconSet*) sgtk_rep_to_boxed (p_icon_set);
++
++ gtk_icon_factory_add (c_factory, c_stock_id, c_icon_set);
++
++ return Qnil;
++}
++
++DEFUN("gtk-icon-factory-lookup", Fgtk_icon_factory_lookup, Sgtk_icon_factory_lookup, (repv p_factory, repv p_stock_id), rep_Subr2)
++{
++ repv pr_ret;
++ GtkIconFactory* c_factory;
++ char* c_stock_id;
++ GtkIconSet* cr_ret;
++
++ rep_DECLARE (1, p_factory, sgtk_is_a_gobj (gtk_icon_factory_get_type (), p_factory));
++ rep_DECLARE (2, p_stock_id, sgtk_valid_string (p_stock_id));
++
++ c_factory = (GtkIconFactory*) sgtk_get_gobj (p_factory);
++ c_stock_id = sgtk_rep_to_string (p_stock_id);
++
++ cr_ret = gtk_icon_factory_lookup (c_factory, c_stock_id);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gtk_icon_set_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-icon-factory-add-default", Fgtk_icon_factory_add_default, Sgtk_icon_factory_add_default, (repv p_factory), rep_Subr1)
++{
++ GtkIconFactory* c_factory;
++
++ rep_DECLARE (1, p_factory, sgtk_is_a_gobj (gtk_icon_factory_get_type (), p_factory));
++
++ c_factory = (GtkIconFactory*) sgtk_get_gobj (p_factory);
++
++ gtk_icon_factory_add_default (c_factory);
++
++ return Qnil;
++}
++
++DEFUN("gtk-icon-factory-remove-default", Fgtk_icon_factory_remove_default, Sgtk_icon_factory_remove_default, (repv p_factory), rep_Subr1)
++{
++ GtkIconFactory* c_factory;
++
++ rep_DECLARE (1, p_factory, sgtk_is_a_gobj (gtk_icon_factory_get_type (), p_factory));
++
++ c_factory = (GtkIconFactory*) sgtk_get_gobj (p_factory);
++
++ gtk_icon_factory_remove_default (c_factory);
++
++ return Qnil;
++}
++
++DEFUN("gtk-icon-factory-lookup-default", Fgtk_icon_factory_lookup_default, Sgtk_icon_factory_lookup_default, (repv p_stock_id), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_stock_id;
++ GtkIconSet* cr_ret;
++
++ rep_DECLARE (1, p_stock_id, sgtk_valid_string (p_stock_id));
++
++ c_stock_id = sgtk_rep_to_string (p_stock_id);
++
++ cr_ret = gtk_icon_factory_lookup_default (c_stock_id);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gtk_icon_set_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-icon-size-register", Fgtk_icon_size_register, Sgtk_icon_size_register, (repv p_name, repv p_width, repv p_height), rep_Subr3)
++{
++ repv pr_ret;
++ char* c_name;
++ gint c_width;
++ gint c_height;
++ GtkIconSize cr_ret;
++
++ rep_DECLARE (1, p_name, sgtk_valid_string (p_name));
++ rep_DECLARE (2, p_width, sgtk_valid_int (p_width));
++ rep_DECLARE (3, p_height, sgtk_valid_int (p_height));
++
++ c_name = sgtk_rep_to_string (p_name);
++ c_width = sgtk_rep_to_int (p_width);
++ c_height = sgtk_rep_to_int (p_height);
++
++ cr_ret = gtk_icon_size_register (c_name, c_width, c_height);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_icon_size_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-icon-size-register-alias", Fgtk_icon_size_register_alias, Sgtk_icon_size_register_alias, (repv p_alias, repv p_target), rep_Subr2)
++{
++ char* c_alias;
++ GtkIconSize c_target;
++
++ rep_DECLARE (1, p_alias, sgtk_valid_string (p_alias));
++ rep_DECLARE (2, p_target, sgtk_valid_enum (p_target, &sgtk_gtk_icon_size_info));
++
++ c_alias = sgtk_rep_to_string (p_alias);
++ c_target = (GtkIconSize) sgtk_rep_to_enum (p_target, &sgtk_gtk_icon_size_info);
++
++ gtk_icon_size_register_alias (c_alias, c_target);
++
++ return Qnil;
++}
++
++DEFUN("gtk-icon-size-from-name", Fgtk_icon_size_from_name, Sgtk_icon_size_from_name, (repv p_name), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_name;
++ GtkIconSize cr_ret;
++
++ rep_DECLARE (1, p_name, sgtk_valid_string (p_name));
++
++ c_name = sgtk_rep_to_string (p_name);
++
++ cr_ret = gtk_icon_size_from_name (c_name);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_icon_size_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-icon-size-get-name", Fgtk_icon_size_get_name, Sgtk_icon_size_get_name, (repv p_size), rep_Subr1)
++{
++ repv pr_ret;
++ GtkIconSize c_size;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_size, sgtk_valid_enum (p_size, &sgtk_gtk_icon_size_info));
++
++ c_size = (GtkIconSize) sgtk_rep_to_enum (p_size, &sgtk_gtk_icon_size_info);
++
++ cr_ret = gtk_icon_size_get_name (c_size);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-icon-set-render-icon", Fgtk_icon_set_render_icon, Sgtk_icon_set_render_icon, (repv args), rep_SubrN)
++{
++ repv pr_ret;
++ repv p_icon_set, p_style, p_direction, p_state, p_size, p_widget, p_detail;
++
++ GtkIconSet* c_icon_set;
++ GtkStyle* c_style;
++ GtkTextDirection c_direction;
++ GtkStateType c_state;
++ GtkIconSize c_size;
++ GtkWidget* c_widget;
++ char* c_detail;
++ GdkPixbuf* cr_ret;
++
++ if (!rep_CONSP(args))
++ p_icon_set = Qnil;
++ else {
++ p_icon_set = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_style = Qnil;
++ else {
++ p_style = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_direction = Qnil;
++ else {
++ p_direction = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_state = Qnil;
++ else {
++ p_state = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_size = Qnil;
++ else {
++ p_size = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_widget = Qnil;
++ else {
++ p_widget = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_detail = Qnil;
++ else {
++ p_detail = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_icon_set, sgtk_valid_boxed (p_icon_set, &sgtk_gtk_icon_set_info));
++ if (p_style != Qnil)
++ rep_DECLARE (2, p_style, sgtk_is_a_gobj (gtk_style_get_type (), p_style));
++ rep_DECLARE (3, p_direction, sgtk_valid_enum (p_direction, &sgtk_gtk_text_direction_info));
++ rep_DECLARE (4, p_state, sgtk_valid_enum (p_state, &sgtk_gtk_state_type_info));
++ rep_DECLARE (5, p_size, sgtk_valid_enum (p_size, &sgtk_gtk_icon_size_info));
++ if (p_widget != Qnil)
++ rep_DECLARE (6, p_widget, sgtk_is_a_gobj (gtk_widget_get_type (), p_widget));
++ if (p_detail != Qnil)
++ rep_DECLARE (7, p_detail, sgtk_valid_string (p_detail));
++
++ c_icon_set = (GtkIconSet*) sgtk_rep_to_boxed (p_icon_set);
++ if (p_style == Qnil)
++ c_style = 0;
++ else
++ c_style = (GtkStyle*) sgtk_get_gobj (p_style);
++ c_direction = (GtkTextDirection) sgtk_rep_to_enum (p_direction, &sgtk_gtk_text_direction_info);
++ c_state = (GtkStateType) sgtk_rep_to_enum (p_state, &sgtk_gtk_state_type_info);
++ c_size = (GtkIconSize) sgtk_rep_to_enum (p_size, &sgtk_gtk_icon_size_info);
++ if (p_widget == Qnil)
++ c_widget = 0;
++ else
++ c_widget = (GtkWidget*) sgtk_get_gobj (p_widget);
++ if (p_detail == Qnil)
++ c_detail = 0;
++ else
++ c_detail = sgtk_rep_to_string (p_detail);
++
++ cr_ret = gtk_icon_set_render_icon (c_icon_set, c_style, c_direction, c_state, c_size, c_widget, c_detail);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_pixbuf_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-new", Fgtk_image_new, Sgtk_image_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_image_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-new-from-file", Fgtk_image_new_from_file, Sgtk_image_new_from_file, (repv p_filename), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_filename;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_filename, sgtk_valid_string (p_filename));
++
++ c_filename = sgtk_rep_to_string (p_filename);
++
++ cr_ret = gtk_image_new_from_file (c_filename);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-new-from-pixbuf", Fgtk_image_new_from_pixbuf, Sgtk_image_new_from_pixbuf, (repv p_pixbuf), rep_Subr1)
++{
++ repv pr_ret;
++ GdkPixbuf* c_pixbuf;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_pixbuf, sgtk_valid_boxed (p_pixbuf, &sgtk_gdk_pixbuf_info));
++
++ c_pixbuf = (GdkPixbuf*) sgtk_rep_to_boxed (p_pixbuf);
++
++ cr_ret = gtk_image_new_from_pixbuf (c_pixbuf);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-new-from-stock", Fgtk_image_new_from_stock, Sgtk_image_new_from_stock, (repv p_stock_id, repv p_size), rep_Subr2)
++{
++ repv pr_ret;
++ char* c_stock_id;
++ GtkIconSize c_size;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_stock_id, sgtk_valid_string (p_stock_id));
++ rep_DECLARE (2, p_size, sgtk_valid_enum (p_size, &sgtk_gtk_icon_size_info));
++
++ c_stock_id = sgtk_rep_to_string (p_stock_id);
++ c_size = (GtkIconSize) sgtk_rep_to_enum (p_size, &sgtk_gtk_icon_size_info);
++
++ cr_ret = gtk_image_new_from_stock (c_stock_id, c_size);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-new-from-icon-set", Fgtk_image_new_from_icon_set, Sgtk_image_new_from_icon_set, (repv p_icon_set, repv p_size), rep_Subr2)
++{
++ repv pr_ret;
++ GtkIconSet* c_icon_set;
++ GtkIconSize c_size;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_icon_set, sgtk_valid_boxed (p_icon_set, &sgtk_gtk_icon_set_info));
++ rep_DECLARE (2, p_size, sgtk_valid_enum (p_size, &sgtk_gtk_icon_size_info));
++
++ c_icon_set = (GtkIconSet*) sgtk_rep_to_boxed (p_icon_set);
++ c_size = (GtkIconSize) sgtk_rep_to_enum (p_size, &sgtk_gtk_icon_size_info);
++
++ cr_ret = gtk_image_new_from_icon_set (c_icon_set, c_size);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-set-from-file", Fgtk_image_set_from_file, Sgtk_image_set_from_file, (repv p_image, repv p_filename), rep_Subr2)
++{
++ GtkImage* c_image;
++ char* c_filename;
++
++ rep_DECLARE (1, p_image, sgtk_is_a_gobj (gtk_image_get_type (), p_image));
++ rep_DECLARE (2, p_filename, sgtk_valid_string (p_filename));
++
++ c_image = (GtkImage*) sgtk_get_gobj (p_image);
++ c_filename = sgtk_rep_to_string (p_filename);
++
++ gtk_image_set_from_file (c_image, c_filename);
++
++ return Qnil;
++}
++
++DEFUN("gtk-image-set-from-pixbuf", Fgtk_image_set_from_pixbuf, Sgtk_image_set_from_pixbuf, (repv p_image, repv p_pixbuf), rep_Subr2)
++{
++ GtkImage* c_image;
++ GdkPixbuf* c_pixbuf;
++
++ rep_DECLARE (1, p_image, sgtk_is_a_gobj (gtk_image_get_type (), p_image));
++ rep_DECLARE (2, p_pixbuf, sgtk_valid_boxed (p_pixbuf, &sgtk_gdk_pixbuf_info));
++
++ c_image = (GtkImage*) sgtk_get_gobj (p_image);
++ c_pixbuf = (GdkPixbuf*) sgtk_rep_to_boxed (p_pixbuf);
++
++ gtk_image_set_from_pixbuf (c_image, c_pixbuf);
++
++ return Qnil;
++}
++
++DEFUN("gtk-image-set-from-stock", Fgtk_image_set_from_stock, Sgtk_image_set_from_stock, (repv p_image, repv p_stock_id, repv p_size), rep_Subr3)
++{
++ GtkImage* c_image;
++ char* c_stock_id;
++ GtkIconSize c_size;
++
++ rep_DECLARE (1, p_image, sgtk_is_a_gobj (gtk_image_get_type (), p_image));
++ rep_DECLARE (2, p_stock_id, sgtk_valid_string (p_stock_id));
++ rep_DECLARE (3, p_size, sgtk_valid_enum (p_size, &sgtk_gtk_icon_size_info));
++
++ c_image = (GtkImage*) sgtk_get_gobj (p_image);
++ c_stock_id = sgtk_rep_to_string (p_stock_id);
++ c_size = (GtkIconSize) sgtk_rep_to_enum (p_size, &sgtk_gtk_icon_size_info);
++
++ gtk_image_set_from_stock (c_image, c_stock_id, c_size);
++
++ return Qnil;
++}
++
++DEFUN("gtk-image-set-from-icon-set", Fgtk_image_set_from_icon_set, Sgtk_image_set_from_icon_set, (repv p_image, repv p_icon_set, repv p_size), rep_Subr3)
++{
++ GtkImage* c_image;
++ GtkIconSet* c_icon_set;
++ GtkIconSize c_size;
++
++ rep_DECLARE (1, p_image, sgtk_is_a_gobj (gtk_image_get_type (), p_image));
++ rep_DECLARE (2, p_icon_set, sgtk_valid_boxed (p_icon_set, &sgtk_gtk_icon_set_info));
++ rep_DECLARE (3, p_size, sgtk_valid_enum (p_size, &sgtk_gtk_icon_size_info));
++
++ c_image = (GtkImage*) sgtk_get_gobj (p_image);
++ c_icon_set = (GtkIconSet*) sgtk_rep_to_boxed (p_icon_set);
++ c_size = (GtkIconSize) sgtk_rep_to_enum (p_size, &sgtk_gtk_icon_size_info);
++
++ gtk_image_set_from_icon_set (c_image, c_icon_set, c_size);
++
++ return Qnil;
++}
++
++DEFUN("gtk-image-get-pixbuf", Fgtk_image_get_pixbuf, Sgtk_image_get_pixbuf, (repv p_image), rep_Subr1)
++{
++ repv pr_ret;
++ GtkImage* c_image;
++ GdkPixbuf* cr_ret;
++
++ rep_DECLARE (1, p_image, sgtk_is_a_gobj (gtk_image_get_type (), p_image));
++
++ c_image = (GtkImage*) sgtk_get_gobj (p_image);
++
++ cr_ret = gtk_image_get_pixbuf (c_image);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_pixbuf_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-menu-item-new", Fgtk_image_menu_item_new, Sgtk_image_menu_item_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_image_menu_item_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-menu-item-new-with-label", Fgtk_image_menu_item_new_with_label, Sgtk_image_menu_item_new_with_label, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_image_menu_item_new_with_label (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-menu-item-new-with-mnemonic", Fgtk_image_menu_item_new_with_mnemonic, Sgtk_image_menu_item_new_with_mnemonic, (repv p_label), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_label;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_label, sgtk_valid_string (p_label));
++
++ c_label = sgtk_rep_to_string (p_label);
++
++ cr_ret = gtk_image_menu_item_new_with_mnemonic (c_label);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-menu-item-new-from-stock", Fgtk_image_menu_item_new_from_stock, Sgtk_image_menu_item_new_from_stock, (repv p_stock_id, repv p_accel_group), rep_Subr2)
++{
++ repv pr_ret;
++ char* c_stock_id;
++ GtkAccelGroup* c_accel_group;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_stock_id, sgtk_valid_string (p_stock_id));
++ rep_DECLARE (2, p_accel_group, sgtk_is_a_gobj (gtk_accel_group_get_type (), p_accel_group));
++
++ c_stock_id = sgtk_rep_to_string (p_stock_id);
++ c_accel_group = (GtkAccelGroup*) sgtk_get_gobj (p_accel_group);
++
++ cr_ret = gtk_image_menu_item_new_from_stock (c_stock_id, c_accel_group);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-image-menu-item-set-image", Fgtk_image_menu_item_set_image, Sgtk_image_menu_item_set_image, (repv p_item, repv p_image), rep_Subr2)
++{
++ GtkImageMenuItem* c_item;
++ GtkWidget* c_image;
++
++ rep_DECLARE (1, p_item, sgtk_is_a_gobj (gtk_image_menu_item_get_type (), p_item));
++ rep_DECLARE (2, p_image, sgtk_is_a_gobj (gtk_widget_get_type (), p_image));
++
++ c_item = (GtkImageMenuItem*) sgtk_get_gobj (p_item);
++ c_image = (GtkWidget*) sgtk_get_gobj (p_image);
++
++ gtk_image_menu_item_set_image (c_item, c_image);
++
++ return Qnil;
++}
++
++DEFUN("gtk-image-menu-item-get-image", Fgtk_image_menu_item_get_image, Sgtk_image_menu_item_get_image, (repv p_item), rep_Subr1)
++{
++ repv pr_ret;
++ GtkImageMenuItem* c_item;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_item, sgtk_is_a_gobj (gtk_image_menu_item_get_type (), p_item));
++
++ c_item = (GtkImageMenuItem*) sgtk_get_gobj (p_item);
++
++ cr_ret = gtk_image_menu_item_get_image (c_item);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-invisible-new", Fgtk_invisible_new, Sgtk_invisible_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_invisible_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-separator-menu-item-new", Fgtk_separator_menu_item_new, Sgtk_separator_menu_item_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_separator_menu_item_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-mark-set-visible", Fgtk_text_mark_set_visible, Sgtk_text_mark_set_visible, (repv p_mark, repv p_setting), rep_Subr2)
++{
++ GtkTextMark* c_mark;
++ int c_setting;
++
++ rep_DECLARE (1, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_text_mark_set_visible (c_mark, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-mark-get-visible", Fgtk_text_mark_get_visible, Sgtk_text_mark_get_visible, (repv p_mark), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextMark* c_mark;
++ int cr_ret;
++
++ rep_DECLARE (1, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++
++ cr_ret = gtk_text_mark_get_visible (c_mark);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-mark-get-name", Fgtk_text_mark_get_name, Sgtk_text_mark_get_name, (repv p_mark), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextMark* c_mark;
++ const char* cr_ret;
++
++ rep_DECLARE (1, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++
++ cr_ret = gtk_text_mark_get_name (c_mark);
++
++ pr_ret = sgtk_static_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-mark-get-deleted", Fgtk_text_mark_get_deleted, Sgtk_text_mark_get_deleted, (repv p_mark), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextMark* c_mark;
++ int cr_ret;
++
++ rep_DECLARE (1, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++
++ cr_ret = gtk_text_mark_get_deleted (c_mark);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-mark-get-buffer", Fgtk_text_mark_get_buffer, Sgtk_text_mark_get_buffer, (repv p_mark), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextMark* c_mark;
++ GtkTextBuffer* cr_ret;
++
++ rep_DECLARE (1, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++
++ cr_ret = gtk_text_mark_get_buffer (c_mark);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-mark-get-left-gravity", Fgtk_text_mark_get_left_gravity, Sgtk_text_mark_get_left_gravity, (repv p_mark), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextMark* c_mark;
++ int cr_ret;
++
++ rep_DECLARE (1, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++
++ cr_ret = gtk_text_mark_get_left_gravity (c_mark);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-tag-new", Fgtk_text_tag_new, Sgtk_text_tag_new, (repv p_name), rep_Subr1)
++{
++ repv pr_ret;
++ char* c_name;
++ GtkTextTag* cr_ret;
++
++ rep_DECLARE (1, p_name, sgtk_valid_string (p_name));
++
++ c_name = sgtk_rep_to_string (p_name);
++
++ cr_ret = gtk_text_tag_new (c_name);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-tag-get-priority", Fgtk_text_tag_get_priority, Sgtk_text_tag_get_priority, (repv p_tag), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextTag* c_tag;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++
++ cr_ret = gtk_text_tag_get_priority (c_tag);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-tag-set-priority", Fgtk_text_tag_set_priority, Sgtk_text_tag_set_priority, (repv p_tag, repv p_priority), rep_Subr2)
++{
++ GtkTextTag* c_tag;
++ gint c_priority;
++
++ rep_DECLARE (1, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++ rep_DECLARE (2, p_priority, sgtk_valid_int (p_priority));
++
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++ c_priority = sgtk_rep_to_int (p_priority);
++
++ gtk_text_tag_set_priority (c_tag, c_priority);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-tag-event", Fgtk_text_tag_event, Sgtk_text_tag_event, (repv p_tag, repv p_event_object, repv p_event, repv p_iter), rep_Subr4)
++{
++ repv pr_ret;
++ GtkTextTag* c_tag;
++ GObject* c_event_object;
++ GdkEvent* c_event;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++ rep_DECLARE (2, p_event_object, sgtk_is_a_gobj (gobject_get_type (), p_event_object));
++ rep_DECLARE (3, p_event, sgtk_valid_boxed (p_event, &sgtk_gdk_event_info));
++ rep_DECLARE (4, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++ c_event_object = (GObject*) sgtk_get_gobj (p_event_object);
++ c_event = (GdkEvent*) sgtk_rep_to_boxed (p_event);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_tag_event (c_tag, c_event_object, c_event, c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-tag-table-new", Fgtk_text_tag_table_new, Sgtk_text_tag_table_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkTextTagTable* cr_ret;
++
++ cr_ret = gtk_text_tag_table_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-tag-table-add", Fgtk_text_tag_table_add, Sgtk_text_tag_table_add, (repv p_table, repv p_tag), rep_Subr2)
++{
++ GtkTextTagTable* c_table;
++ GtkTextTag* c_tag;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_text_tag_table_get_type (), p_table));
++ rep_DECLARE (2, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++
++ c_table = (GtkTextTagTable*) sgtk_get_gobj (p_table);
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++
++ gtk_text_tag_table_add (c_table, c_tag);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-tag-table-remove", Fgtk_text_tag_table_remove, Sgtk_text_tag_table_remove, (repv p_table, repv p_tag), rep_Subr2)
++{
++ GtkTextTagTable* c_table;
++ GtkTextTag* c_tag;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_text_tag_table_get_type (), p_table));
++ rep_DECLARE (2, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++
++ c_table = (GtkTextTagTable*) sgtk_get_gobj (p_table);
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++
++ gtk_text_tag_table_remove (c_table, c_tag);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-tag-table-lookup", Fgtk_text_tag_table_lookup, Sgtk_text_tag_table_lookup, (repv p_table, repv p_name), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextTagTable* c_table;
++ char* c_name;
++ GtkTextTag* cr_ret;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_text_tag_table_get_type (), p_table));
++ rep_DECLARE (2, p_name, sgtk_valid_string (p_name));
++
++ c_table = (GtkTextTagTable*) sgtk_get_gobj (p_table);
++ c_name = sgtk_rep_to_string (p_name);
++
++ cr_ret = gtk_text_tag_table_lookup (c_table, c_name);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-tag-table-get-size", Fgtk_text_tag_table_get_size, Sgtk_text_tag_table_get_size, (repv p_table), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextTagTable* c_table;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_text_tag_table_get_type (), p_table));
++
++ c_table = (GtkTextTagTable*) sgtk_get_gobj (p_table);
++
++ cr_ret = gtk_text_tag_table_get_size (c_table);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-new", Fgtk_text_iter_new, Sgtk_text_iter_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkTextIter* cr_ret;
++
++ cr_ret = gtk_text_iter_new ();
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gtk_text_iter_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-offset", Fgtk_text_iter_get_offset, Sgtk_text_iter_get_offset, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_get_offset (c_iter);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-line", Fgtk_text_iter_get_line, Sgtk_text_iter_get_line, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_get_line (c_iter);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-line-offset", Fgtk_text_iter_get_line_offset, Sgtk_text_iter_get_line_offset, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_get_line_offset (c_iter);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-line-index", Fgtk_text_iter_get_line_index, Sgtk_text_iter_get_line_index, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_get_line_index (c_iter);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-visible-line-offset", Fgtk_text_iter_get_visible_line_offset, Sgtk_text_iter_get_visible_line_offset, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_get_visible_line_offset (c_iter);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-visible-line-index", Fgtk_text_iter_get_visible_line_index, Sgtk_text_iter_get_visible_line_index, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_get_visible_line_index (c_iter);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-char", Fgtk_text_iter_get_char, Sgtk_text_iter_get_char, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gchar cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_get_char (c_iter);
++
++ pr_ret = sgtk_char_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-slice", Fgtk_text_iter_get_slice, Sgtk_text_iter_get_slice, (repv p_start, repv p_end), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++ char* cr_ret;
++
++ rep_DECLARE (1, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ cr_ret = gtk_text_iter_get_slice (c_start, c_end);
++
++ pr_ret = sgtk_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-text", Fgtk_text_iter_get_text, Sgtk_text_iter_get_text, (repv p_start, repv p_end), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++ char* cr_ret;
++
++ rep_DECLARE (1, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ cr_ret = gtk_text_iter_get_text (c_start, c_end);
++
++ pr_ret = sgtk_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-visible-slice", Fgtk_text_iter_get_visible_slice, Sgtk_text_iter_get_visible_slice, (repv p_start, repv p_end), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++ char* cr_ret;
++
++ rep_DECLARE (1, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ cr_ret = gtk_text_iter_get_visible_slice (c_start, c_end);
++
++ pr_ret = sgtk_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-visible-text", Fgtk_text_iter_get_visible_text, Sgtk_text_iter_get_visible_text, (repv p_start, repv p_end), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++ char* cr_ret;
++
++ rep_DECLARE (1, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ cr_ret = gtk_text_iter_get_visible_text (c_start, c_end);
++
++ pr_ret = sgtk_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-pixbuf", Fgtk_text_iter_get_pixbuf, Sgtk_text_iter_get_pixbuf, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ GdkPixbuf* cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_get_pixbuf (c_iter);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_pixbuf_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-begins-tag", Fgtk_text_iter_begins_tag, Sgtk_text_iter_begins_tag, (repv p_iter, repv p_tag), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ GtkTextTag* c_tag;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++
++ cr_ret = gtk_text_iter_begins_tag (c_iter, c_tag);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-ends-tag", Fgtk_text_iter_ends_tag, Sgtk_text_iter_ends_tag, (repv p_iter, repv p_tag), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ GtkTextTag* c_tag;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++
++ cr_ret = gtk_text_iter_ends_tag (c_iter, c_tag);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-toggles-tag", Fgtk_text_iter_toggles_tag, Sgtk_text_iter_toggles_tag, (repv p_iter, repv p_tag), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ GtkTextTag* c_tag;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++
++ cr_ret = gtk_text_iter_toggles_tag (c_iter, c_tag);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-has-tag", Fgtk_text_iter_has_tag, Sgtk_text_iter_has_tag, (repv p_iter, repv p_tag), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ GtkTextTag* c_tag;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++
++ cr_ret = gtk_text_iter_has_tag (c_iter, c_tag);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-editable", Fgtk_text_iter_editable, Sgtk_text_iter_editable, (repv p_iter, repv p_default_setting), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int c_default_setting;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_default_setting = sgtk_rep_to_bool (p_default_setting);
++
++ cr_ret = gtk_text_iter_editable (c_iter, c_default_setting);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-can-insert", Fgtk_text_iter_can_insert, Sgtk_text_iter_can_insert, (repv p_iter, repv p_default_editability), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int c_default_editability;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_default_editability = sgtk_rep_to_bool (p_default_editability);
++
++ cr_ret = gtk_text_iter_can_insert (c_iter, c_default_editability);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-starts-word", Fgtk_text_iter_starts_word, Sgtk_text_iter_starts_word, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_starts_word (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-ends-word", Fgtk_text_iter_ends_word, Sgtk_text_iter_ends_word, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_ends_word (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-inside-word", Fgtk_text_iter_inside_word, Sgtk_text_iter_inside_word, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_inside_word (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-starts-sentence", Fgtk_text_iter_starts_sentence, Sgtk_text_iter_starts_sentence, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_starts_sentence (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-ends-sentence", Fgtk_text_iter_ends_sentence, Sgtk_text_iter_ends_sentence, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_ends_sentence (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-inside-sentence", Fgtk_text_iter_inside_sentence, Sgtk_text_iter_inside_sentence, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_inside_sentence (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-starts-line", Fgtk_text_iter_starts_line, Sgtk_text_iter_starts_line, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_starts_line (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-ends-line", Fgtk_text_iter_ends_line, Sgtk_text_iter_ends_line, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_ends_line (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-is-cursor-position", Fgtk_text_iter_is_cursor_position, Sgtk_text_iter_is_cursor_position, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_is_cursor_position (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-chars-in-line", Fgtk_text_iter_get_chars_in_line, Sgtk_text_iter_get_chars_in_line, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_get_chars_in_line (c_iter);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-get-bytes-in-line", Fgtk_text_iter_get_bytes_in_line, Sgtk_text_iter_get_bytes_in_line, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_get_bytes_in_line (c_iter);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-is-end", Fgtk_text_iter_is_end, Sgtk_text_iter_is_end, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_is_end (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-is-start", Fgtk_text_iter_is_start, Sgtk_text_iter_is_start, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_is_start (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-char", Fgtk_text_iter_forward_char, Sgtk_text_iter_forward_char, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_forward_char (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-char", Fgtk_text_iter_backward_char, Sgtk_text_iter_backward_char, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_backward_char (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-chars", Fgtk_text_iter_forward_chars, Sgtk_text_iter_forward_chars, (repv p_iter, repv p_count), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint c_count;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_count, sgtk_valid_int (p_count));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_count = sgtk_rep_to_int (p_count);
++
++ cr_ret = gtk_text_iter_forward_chars (c_iter, c_count);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-chars", Fgtk_text_iter_backward_chars, Sgtk_text_iter_backward_chars, (repv p_iter, repv p_count), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint c_count;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_count, sgtk_valid_int (p_count));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_count = sgtk_rep_to_int (p_count);
++
++ cr_ret = gtk_text_iter_backward_chars (c_iter, c_count);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-line", Fgtk_text_iter_forward_line, Sgtk_text_iter_forward_line, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_forward_line (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-line", Fgtk_text_iter_backward_line, Sgtk_text_iter_backward_line, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_backward_line (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-lines", Fgtk_text_iter_forward_lines, Sgtk_text_iter_forward_lines, (repv p_iter, repv p_count), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint c_count;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_count, sgtk_valid_int (p_count));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_count = sgtk_rep_to_int (p_count);
++
++ cr_ret = gtk_text_iter_forward_lines (c_iter, c_count);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-lines", Fgtk_text_iter_backward_lines, Sgtk_text_iter_backward_lines, (repv p_iter, repv p_count), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint c_count;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_count, sgtk_valid_int (p_count));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_count = sgtk_rep_to_int (p_count);
++
++ cr_ret = gtk_text_iter_backward_lines (c_iter, c_count);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-word-end", Fgtk_text_iter_forward_word_end, Sgtk_text_iter_forward_word_end, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_forward_word_end (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-word-start", Fgtk_text_iter_backward_word_start, Sgtk_text_iter_backward_word_start, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_backward_word_start (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-word-ends", Fgtk_text_iter_forward_word_ends, Sgtk_text_iter_forward_word_ends, (repv p_iter, repv p_count), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint c_count;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_count, sgtk_valid_int (p_count));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_count = sgtk_rep_to_int (p_count);
++
++ cr_ret = gtk_text_iter_forward_word_ends (c_iter, c_count);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-sentence-starts", Fgtk_text_iter_backward_sentence_starts, Sgtk_text_iter_backward_sentence_starts, (repv p_iter, repv p_count), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint c_count;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_count, sgtk_valid_int (p_count));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_count = sgtk_rep_to_int (p_count);
++
++ cr_ret = gtk_text_iter_backward_sentence_starts (c_iter, c_count);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-sentence-end", Fgtk_text_iter_forward_sentence_end, Sgtk_text_iter_forward_sentence_end, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_forward_sentence_end (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-sentence-start", Fgtk_text_iter_backward_sentence_start, Sgtk_text_iter_backward_sentence_start, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_backward_sentence_start (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-sentence-ends", Fgtk_text_iter_forward_sentence_ends, Sgtk_text_iter_forward_sentence_ends, (repv p_iter, repv p_count), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint c_count;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_count, sgtk_valid_int (p_count));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_count = sgtk_rep_to_int (p_count);
++
++ cr_ret = gtk_text_iter_forward_sentence_ends (c_iter, c_count);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-cursor-position", Fgtk_text_iter_forward_cursor_position, Sgtk_text_iter_forward_cursor_position, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_forward_cursor_position (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-cursor-position", Fgtk_text_iter_backward_cursor_position, Sgtk_text_iter_backward_cursor_position, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_backward_cursor_position (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-cursor-positions", Fgtk_text_iter_forward_cursor_positions, Sgtk_text_iter_forward_cursor_positions, (repv p_iter, repv p_count), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint c_count;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_count, sgtk_valid_int (p_count));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_count = sgtk_rep_to_int (p_count);
++
++ cr_ret = gtk_text_iter_forward_cursor_positions (c_iter, c_count);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-cursor-positions", Fgtk_text_iter_backward_cursor_positions, Sgtk_text_iter_backward_cursor_positions, (repv p_iter, repv p_count), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ gint c_count;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_count, sgtk_valid_int (p_count));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_count = sgtk_rep_to_int (p_count);
++
++ cr_ret = gtk_text_iter_backward_cursor_positions (c_iter, c_count);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-set-offset", Fgtk_text_iter_set_offset, Sgtk_text_iter_set_offset, (repv p_iter, repv p_char_offsets), rep_Subr2)
++{
++ GtkTextIter* c_iter;
++ gint c_char_offsets;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_char_offsets, sgtk_valid_int (p_char_offsets));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_char_offsets = sgtk_rep_to_int (p_char_offsets);
++
++ gtk_text_iter_set_offset (c_iter, c_char_offsets);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-iter-set-line", Fgtk_text_iter_set_line, Sgtk_text_iter_set_line, (repv p_iter, repv p_line_number), rep_Subr2)
++{
++ GtkTextIter* c_iter;
++ gint c_line_number;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_line_number, sgtk_valid_int (p_line_number));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_line_number = sgtk_rep_to_int (p_line_number);
++
++ gtk_text_iter_set_line (c_iter, c_line_number);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-iter-set-line-offset", Fgtk_text_iter_set_line_offset, Sgtk_text_iter_set_line_offset, (repv p_iter, repv p_line_offset), rep_Subr2)
++{
++ GtkTextIter* c_iter;
++ gint c_line_offset;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_line_offset, sgtk_valid_int (p_line_offset));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_line_offset = sgtk_rep_to_int (p_line_offset);
++
++ gtk_text_iter_set_line_offset (c_iter, c_line_offset);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-iter-set-line-index", Fgtk_text_iter_set_line_index, Sgtk_text_iter_set_line_index, (repv p_iter, repv p_line_index), rep_Subr2)
++{
++ GtkTextIter* c_iter;
++ gint c_line_index;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_line_index, sgtk_valid_int (p_line_index));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_line_index = sgtk_rep_to_int (p_line_index);
++
++ gtk_text_iter_set_line_index (c_iter, c_line_index);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-iter-forward-to-end", Fgtk_text_iter_forward_to_end, Sgtk_text_iter_forward_to_end, (repv p_iter), rep_Subr1)
++{
++ GtkTextIter* c_iter;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ gtk_text_iter_forward_to_end (c_iter);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-iter-forward-to-line-end", Fgtk_text_iter_forward_to_line_end, Sgtk_text_iter_forward_to_line_end, (repv p_iter), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_iter_forward_to_line_end (c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-set-visible-line-offset", Fgtk_text_iter_set_visible_line_offset, Sgtk_text_iter_set_visible_line_offset, (repv p_iter, repv p_char_on_line), rep_Subr2)
++{
++ GtkTextIter* c_iter;
++ gint c_char_on_line;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_char_on_line, sgtk_valid_int (p_char_on_line));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_char_on_line = sgtk_rep_to_int (p_char_on_line);
++
++ gtk_text_iter_set_visible_line_offset (c_iter, c_char_on_line);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-iter-set-visible-line-index", Fgtk_text_iter_set_visible_line_index, Sgtk_text_iter_set_visible_line_index, (repv p_iter, repv p_byte_on_line), rep_Subr2)
++{
++ GtkTextIter* c_iter;
++ gint c_byte_on_line;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_byte_on_line, sgtk_valid_int (p_byte_on_line));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_byte_on_line = sgtk_rep_to_int (p_byte_on_line);
++
++ gtk_text_iter_set_visible_line_index (c_iter, c_byte_on_line);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-iter-forward-to-tag-toggle", Fgtk_text_iter_forward_to_tag_toggle, Sgtk_text_iter_forward_to_tag_toggle, (repv p_iter, repv p_tag), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ GtkTextTag* c_tag;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++
++ cr_ret = gtk_text_iter_forward_to_tag_toggle (c_iter, c_tag);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-to-tag-toggle", Fgtk_text_iter_backward_to_tag_toggle, Sgtk_text_iter_backward_to_tag_toggle, (repv p_iter, repv p_tag), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ GtkTextTag* c_tag;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++
++ cr_ret = gtk_text_iter_backward_to_tag_toggle (c_iter, c_tag);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-forward-search", Fgtk_text_iter_forward_search, Sgtk_text_iter_forward_search, (repv args), rep_SubrN)
++{
++ repv pr_ret;
++ repv p_iter, p_str, p_flags, p_match_start, p_match_end, p_limit;
++
++ GtkTextIter* c_iter;
++ char* c_str;
++ GtkTextSearchFlags c_flags;
++ GtkTextIter* c_match_start;
++ GtkTextIter* c_match_end;
++ GtkTextIter* c_limit;
++ int cr_ret;
++
++ if (!rep_CONSP(args))
++ p_iter = Qnil;
++ else {
++ p_iter = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_str = Qnil;
++ else {
++ p_str = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_flags = Qnil;
++ else {
++ p_flags = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_match_start = Qnil;
++ else {
++ p_match_start = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_match_end = Qnil;
++ else {
++ p_match_end = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_limit = Qnil;
++ else {
++ p_limit = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_str, sgtk_valid_string (p_str));
++ rep_DECLARE (3, p_flags, sgtk_valid_flags (p_flags, &sgtk_gtk_text_search_flags_info));
++ rep_DECLARE (4, p_match_start, sgtk_valid_boxed (p_match_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (5, p_match_end, sgtk_valid_boxed (p_match_end, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (6, p_limit, sgtk_valid_boxed (p_limit, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_str = sgtk_rep_to_string (p_str);
++ c_flags = (GtkTextSearchFlags) sgtk_rep_to_flags (p_flags, &sgtk_gtk_text_search_flags_info);
++ c_match_start = (GtkTextIter*) sgtk_rep_to_boxed (p_match_start);
++ c_match_end = (GtkTextIter*) sgtk_rep_to_boxed (p_match_end);
++ c_limit = (GtkTextIter*) sgtk_rep_to_boxed (p_limit);
++
++ cr_ret = gtk_text_iter_forward_search (c_iter, c_str, c_flags, c_match_start, c_match_end, c_limit);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-backward-search", Fgtk_text_iter_backward_search, Sgtk_text_iter_backward_search, (repv args), rep_SubrN)
++{
++ repv pr_ret;
++ repv p_iter, p_str, p_flags, p_match_start, p_match_end, p_limit;
++
++ GtkTextIter* c_iter;
++ char* c_str;
++ GtkTextSearchFlags c_flags;
++ GtkTextIter* c_match_start;
++ GtkTextIter* c_match_end;
++ GtkTextIter* c_limit;
++ int cr_ret;
++
++ if (!rep_CONSP(args))
++ p_iter = Qnil;
++ else {
++ p_iter = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_str = Qnil;
++ else {
++ p_str = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_flags = Qnil;
++ else {
++ p_flags = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_match_start = Qnil;
++ else {
++ p_match_start = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_match_end = Qnil;
++ else {
++ p_match_end = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_limit = Qnil;
++ else {
++ p_limit = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_str, sgtk_valid_string (p_str));
++ rep_DECLARE (3, p_flags, sgtk_valid_flags (p_flags, &sgtk_gtk_text_search_flags_info));
++ rep_DECLARE (4, p_match_start, sgtk_valid_boxed (p_match_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (5, p_match_end, sgtk_valid_boxed (p_match_end, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (6, p_limit, sgtk_valid_boxed (p_limit, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_str = sgtk_rep_to_string (p_str);
++ c_flags = (GtkTextSearchFlags) sgtk_rep_to_flags (p_flags, &sgtk_gtk_text_search_flags_info);
++ c_match_start = (GtkTextIter*) sgtk_rep_to_boxed (p_match_start);
++ c_match_end = (GtkTextIter*) sgtk_rep_to_boxed (p_match_end);
++ c_limit = (GtkTextIter*) sgtk_rep_to_boxed (p_limit);
++
++ cr_ret = gtk_text_iter_backward_search (c_iter, c_str, c_flags, c_match_start, c_match_end, c_limit);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-equal", Fgtk_text_iter_equal, Sgtk_text_iter_equal, (repv p_lhs, repv p_rhs), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_lhs;
++ GtkTextIter* c_rhs;
++ int cr_ret;
++
++ rep_DECLARE (1, p_lhs, sgtk_valid_boxed (p_lhs, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_rhs, sgtk_valid_boxed (p_rhs, &sgtk_gtk_text_iter_info));
++
++ c_lhs = (GtkTextIter*) sgtk_rep_to_boxed (p_lhs);
++ c_rhs = (GtkTextIter*) sgtk_rep_to_boxed (p_rhs);
++
++ cr_ret = gtk_text_iter_equal (c_lhs, c_rhs);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-compare", Fgtk_text_iter_compare, Sgtk_text_iter_compare, (repv p_lhs, repv p_rhs), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextIter* c_lhs;
++ GtkTextIter* c_rhs;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_lhs, sgtk_valid_boxed (p_lhs, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_rhs, sgtk_valid_boxed (p_rhs, &sgtk_gtk_text_iter_info));
++
++ c_lhs = (GtkTextIter*) sgtk_rep_to_boxed (p_lhs);
++ c_rhs = (GtkTextIter*) sgtk_rep_to_boxed (p_rhs);
++
++ cr_ret = gtk_text_iter_compare (c_lhs, c_rhs);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-in-range", Fgtk_text_iter_in_range, Sgtk_text_iter_in_range, (repv p_iter, repv p_start, repv p_end), rep_Subr3)
++{
++ repv pr_ret;
++ GtkTextIter* c_iter;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++ int cr_ret;
++
++ rep_DECLARE (1, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ cr_ret = gtk_text_iter_in_range (c_iter, c_start, c_end);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-iter-order", Fgtk_text_iter_order, Sgtk_text_iter_order, (repv p_first, repv p_second), rep_Subr2)
++{
++ GtkTextIter* c_first;
++ GtkTextIter* c_second;
++
++ rep_DECLARE (1, p_first, sgtk_valid_boxed (p_first, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (2, p_second, sgtk_valid_boxed (p_second, &sgtk_gtk_text_iter_info));
++
++ c_first = (GtkTextIter*) sgtk_rep_to_boxed (p_first);
++ c_second = (GtkTextIter*) sgtk_rep_to_boxed (p_second);
++
++ gtk_text_iter_order (c_first, c_second);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-new", Fgtk_text_buffer_new, Sgtk_text_buffer_new, (repv p_table), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextTagTable* c_table;
++ GtkTextBuffer* cr_ret;
++
++ if (p_table != Qnil)
++ rep_DECLARE (1, p_table, sgtk_is_a_gobj (gtk_text_tag_table_get_type (), p_table));
++
++ if (p_table == Qnil)
++ c_table = 0;
++ else
++ c_table = (GtkTextTagTable*) sgtk_get_gobj (p_table);
++
++ cr_ret = gtk_text_buffer_new (c_table);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-get-line-count", Fgtk_text_buffer_get_line_count, Sgtk_text_buffer_get_line_count, (repv p_buffer), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++
++ cr_ret = gtk_text_buffer_get_line_count (c_buffer);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-get-char-count", Fgtk_text_buffer_get_char_count, Sgtk_text_buffer_get_char_count, (repv p_buffer), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++
++ cr_ret = gtk_text_buffer_get_char_count (c_buffer);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-set-text", Fgtk_text_buffer_set_text, Sgtk_text_buffer_set_text, (repv p_buffer, repv p_text, repv p_len), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ char* c_text;
++ gint c_len;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_text, sgtk_valid_string (p_text));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_text = sgtk_rep_to_string (p_text);
++ if (p_len == Qnil)
++ c_len = -1;
++ else
++ c_len = sgtk_rep_to_int (p_len);
++
++ gtk_text_buffer_set_text (c_buffer, c_text, c_len);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-insert", Fgtk_text_buffer_insert, Sgtk_text_buffer_insert, (repv p_buffer, repv p_iter, repv p_text, repv p_len), rep_Subr4)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++ char* c_text;
++ gint c_len;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_text, sgtk_valid_string (p_text));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_text = sgtk_rep_to_string (p_text);
++ if (p_len == Qnil)
++ c_len = -1;
++ else
++ c_len = sgtk_rep_to_int (p_len);
++
++ gtk_text_buffer_insert (c_buffer, c_iter, c_text, c_len);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-insert-at-cursor", Fgtk_text_buffer_insert_at_cursor, Sgtk_text_buffer_insert_at_cursor, (repv p_buffer, repv p_text, repv p_len), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ char* c_text;
++ gint c_len;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_text, sgtk_valid_string (p_text));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_text = sgtk_rep_to_string (p_text);
++ if (p_len == Qnil)
++ c_len = -1;
++ else
++ c_len = sgtk_rep_to_int (p_len);
++
++ gtk_text_buffer_insert_at_cursor (c_buffer, c_text, c_len);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-insert-interactive", Fgtk_text_buffer_insert_interactive, Sgtk_text_buffer_insert_interactive, (repv p_buffer, repv p_iter, repv p_text, repv p_len, repv p_default_editable), rep_Subr5)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++ char* c_text;
++ gint c_len;
++ int c_default_editable;
++ int cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_text, sgtk_valid_string (p_text));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_text = sgtk_rep_to_string (p_text);
++ if (p_len == Qnil)
++ c_len = -1;
++ else
++ c_len = sgtk_rep_to_int (p_len);
++ c_default_editable = sgtk_rep_to_bool (p_default_editable);
++
++ cr_ret = gtk_text_buffer_insert_interactive (c_buffer, c_iter, c_text, c_len, c_default_editable);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-insert-interactive-at-cursor", Fgtk_text_buffer_insert_interactive_at_cursor, Sgtk_text_buffer_insert_interactive_at_cursor, (repv p_buffer, repv p_text, repv p_len, repv p_default_editable), rep_Subr4)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ char* c_text;
++ gint c_len;
++ int c_default_editable;
++ int cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_text, sgtk_valid_string (p_text));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_text = sgtk_rep_to_string (p_text);
++ if (p_len == Qnil)
++ c_len = -1;
++ else
++ c_len = sgtk_rep_to_int (p_len);
++ c_default_editable = sgtk_rep_to_bool (p_default_editable);
++
++ cr_ret = gtk_text_buffer_insert_interactive_at_cursor (c_buffer, c_text, c_len, c_default_editable);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-insert-range", Fgtk_text_buffer_insert_range, Sgtk_text_buffer_insert_range, (repv p_buffer, repv p_iter, repv p_start, repv p_end), rep_Subr4)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (4, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ gtk_text_buffer_insert_range (c_buffer, c_iter, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-insert-range-interactive", Fgtk_text_buffer_insert_range_interactive, Sgtk_text_buffer_insert_range_interactive, (repv p_buffer, repv p_iter, repv p_start, repv p_end, repv p_default_editable), rep_Subr5)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++ int c_default_editable;
++ int cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (4, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++ c_default_editable = sgtk_rep_to_bool (p_default_editable);
++
++ cr_ret = gtk_text_buffer_insert_range_interactive (c_buffer, c_iter, c_start, c_end, c_default_editable);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-delete", Fgtk_text_buffer_delete, Sgtk_text_buffer_delete, (repv p_buffer, repv p_start, repv p_end), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ gtk_text_buffer_delete (c_buffer, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-delete-interactive", Fgtk_text_buffer_delete_interactive, Sgtk_text_buffer_delete_interactive, (repv p_buffer, repv p_start, repv p_end, repv p_default_editable), rep_Subr4)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++ int c_default_editable;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++ c_default_editable = sgtk_rep_to_bool (p_default_editable);
++
++ gtk_text_buffer_delete_interactive (c_buffer, c_start, c_end, c_default_editable);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-text", Fgtk_text_buffer_get_text, Sgtk_text_buffer_get_text, (repv p_buffer, repv p_start, repv p_end, repv p_include_hidden_chars), rep_Subr4)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++ int c_include_hidden_chars;
++ char* cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++ c_include_hidden_chars = sgtk_rep_to_bool (p_include_hidden_chars);
++
++ cr_ret = gtk_text_buffer_get_text (c_buffer, c_start, c_end, c_include_hidden_chars);
++
++ pr_ret = sgtk_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-get-slice", Fgtk_text_buffer_get_slice, Sgtk_text_buffer_get_slice, (repv p_buffer, repv p_start, repv p_end, repv p_include_hidden_chars), rep_Subr4)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++ int c_include_hidden_chars;
++ char* cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++ c_include_hidden_chars = sgtk_rep_to_bool (p_include_hidden_chars);
++
++ cr_ret = gtk_text_buffer_get_slice (c_buffer, c_start, c_end, c_include_hidden_chars);
++
++ pr_ret = sgtk_string_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-insert-pixbuf", Fgtk_text_buffer_insert_pixbuf, Sgtk_text_buffer_insert_pixbuf, (repv p_buffer, repv p_iter, repv p_pixbuf), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++ GdkPixbuf* c_pixbuf;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_pixbuf, sgtk_valid_boxed (p_pixbuf, &sgtk_gdk_pixbuf_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_pixbuf = (GdkPixbuf*) sgtk_rep_to_boxed (p_pixbuf);
++
++ gtk_text_buffer_insert_pixbuf (c_buffer, c_iter, c_pixbuf);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-create-mark", Fgtk_text_buffer_create_mark, Sgtk_text_buffer_create_mark, (repv p_buffer, repv p_mark_name, repv p_where, repv p_left_gravity), rep_Subr4)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ char* c_mark_name;
++ GtkTextIter* c_where;
++ int c_left_gravity;
++ GtkTextMark* cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_mark_name, sgtk_valid_string (p_mark_name));
++ rep_DECLARE (3, p_where, sgtk_valid_boxed (p_where, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_mark_name = sgtk_rep_to_string (p_mark_name);
++ c_where = (GtkTextIter*) sgtk_rep_to_boxed (p_where);
++ c_left_gravity = sgtk_rep_to_bool (p_left_gravity);
++
++ cr_ret = gtk_text_buffer_create_mark (c_buffer, c_mark_name, c_where, c_left_gravity);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-move-mark", Fgtk_text_buffer_move_mark, Sgtk_text_buffer_move_mark, (repv p_buffer, repv p_mark, repv p_where), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextMark* c_mark;
++ GtkTextIter* c_where;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++ rep_DECLARE (3, p_where, sgtk_valid_boxed (p_where, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++ c_where = (GtkTextIter*) sgtk_rep_to_boxed (p_where);
++
++ gtk_text_buffer_move_mark (c_buffer, c_mark, c_where);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-delete-mark", Fgtk_text_buffer_delete_mark, Sgtk_text_buffer_delete_mark, (repv p_buffer, repv p_mark), rep_Subr2)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextMark* c_mark;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++
++ gtk_text_buffer_delete_mark (c_buffer, c_mark);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-mark", Fgtk_text_buffer_get_mark, Sgtk_text_buffer_get_mark, (repv p_buffer, repv p_name), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ char* c_name;
++ GtkTextMark* cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_name, sgtk_valid_string (p_name));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_name = sgtk_rep_to_string (p_name);
++
++ cr_ret = gtk_text_buffer_get_mark (c_buffer, c_name);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-move-mark-by-name", Fgtk_text_buffer_move_mark_by_name, Sgtk_text_buffer_move_mark_by_name, (repv p_buffer, repv p_name, repv p_where), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ char* c_name;
++ GtkTextIter* c_where;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_name, sgtk_valid_string (p_name));
++ rep_DECLARE (3, p_where, sgtk_valid_boxed (p_where, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_name = sgtk_rep_to_string (p_name);
++ c_where = (GtkTextIter*) sgtk_rep_to_boxed (p_where);
++
++ gtk_text_buffer_move_mark_by_name (c_buffer, c_name, c_where);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-delete-mark-by-name", Fgtk_text_buffer_delete_mark_by_name, Sgtk_text_buffer_delete_mark_by_name, (repv p_buffer, repv p_name), rep_Subr2)
++{
++ GtkTextBuffer* c_buffer;
++ char* c_name;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_name, sgtk_valid_string (p_name));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_name = sgtk_rep_to_string (p_name);
++
++ gtk_text_buffer_delete_mark_by_name (c_buffer, c_name);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-insert", Fgtk_text_buffer_get_insert, Sgtk_text_buffer_get_insert, (repv p_buffer), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ GtkTextMark* cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++
++ cr_ret = gtk_text_buffer_get_insert (c_buffer);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-get-selection-bound", Fgtk_text_buffer_get_selection_bound, Sgtk_text_buffer_get_selection_bound, (repv p_buffer), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ GtkTextMark* cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++
++ cr_ret = gtk_text_buffer_get_selection_bound (c_buffer);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-place-cursor", Fgtk_text_buffer_place_cursor, Sgtk_text_buffer_place_cursor, (repv p_buffer, repv p_where), rep_Subr2)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_where;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_where, sgtk_valid_boxed (p_where, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_where = (GtkTextIter*) sgtk_rep_to_boxed (p_where);
++
++ gtk_text_buffer_place_cursor (c_buffer, c_where);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-apply-tag", Fgtk_text_buffer_apply_tag, Sgtk_text_buffer_apply_tag, (repv p_buffer, repv p_tag, repv p_start, repv p_end), rep_Subr4)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextTag* c_tag;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++ rep_DECLARE (3, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (4, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ gtk_text_buffer_apply_tag (c_buffer, c_tag, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-remove-tag", Fgtk_text_buffer_remove_tag, Sgtk_text_buffer_remove_tag, (repv p_buffer, repv p_tag, repv p_start, repv p_end), rep_Subr4)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextTag* c_tag;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_tag, sgtk_is_a_gobj (gtk_text_tag_get_type (), p_tag));
++ rep_DECLARE (3, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (4, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_tag = (GtkTextTag*) sgtk_get_gobj (p_tag);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ gtk_text_buffer_remove_tag (c_buffer, c_tag, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-apply-tag-by-name", Fgtk_text_buffer_apply_tag_by_name, Sgtk_text_buffer_apply_tag_by_name, (repv p_buffer, repv p_name, repv p_start, repv p_end), rep_Subr4)
++{
++ GtkTextBuffer* c_buffer;
++ char* c_name;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_name, sgtk_valid_string (p_name));
++ rep_DECLARE (3, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (4, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_name = sgtk_rep_to_string (p_name);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ gtk_text_buffer_apply_tag_by_name (c_buffer, c_name, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-remove-tag-by-name", Fgtk_text_buffer_remove_tag_by_name, Sgtk_text_buffer_remove_tag_by_name, (repv p_buffer, repv p_name, repv p_start, repv p_end), rep_Subr4)
++{
++ GtkTextBuffer* c_buffer;
++ char* c_name;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_name, sgtk_valid_string (p_name));
++ rep_DECLARE (3, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (4, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_name = sgtk_rep_to_string (p_name);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ gtk_text_buffer_remove_tag_by_name (c_buffer, c_name, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-remove-all-tags", Fgtk_text_buffer_remove_all_tags, Sgtk_text_buffer_remove_all_tags, (repv p_buffer, repv p_start, repv p_end), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ gtk_text_buffer_remove_all_tags (c_buffer, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-iter-at-line-offset", Fgtk_text_buffer_get_iter_at_line_offset, Sgtk_text_buffer_get_iter_at_line_offset, (repv p_buffer, repv p_iter, repv p_line_number, repv p_char_offset), rep_Subr4)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++ gint c_line_number;
++ gint c_char_offset;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_line_number, sgtk_valid_int (p_line_number));
++ rep_DECLARE (4, p_char_offset, sgtk_valid_int (p_char_offset));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_line_number = sgtk_rep_to_int (p_line_number);
++ c_char_offset = sgtk_rep_to_int (p_char_offset);
++
++ gtk_text_buffer_get_iter_at_line_offset (c_buffer, c_iter, c_line_number, c_char_offset);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-iter-at-line-index", Fgtk_text_buffer_get_iter_at_line_index, Sgtk_text_buffer_get_iter_at_line_index, (repv p_buffer, repv p_iter, repv p_line_number, repv p_byte_index), rep_Subr4)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++ gint c_line_number;
++ gint c_byte_index;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_line_number, sgtk_valid_int (p_line_number));
++ rep_DECLARE (4, p_byte_index, sgtk_valid_int (p_byte_index));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_line_number = sgtk_rep_to_int (p_line_number);
++ c_byte_index = sgtk_rep_to_int (p_byte_index);
++
++ gtk_text_buffer_get_iter_at_line_index (c_buffer, c_iter, c_line_number, c_byte_index);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-iter-at-offset", Fgtk_text_buffer_get_iter_at_offset, Sgtk_text_buffer_get_iter_at_offset, (repv p_buffer, repv p_iter, repv p_char_offset), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++ gint c_char_offset;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_char_offset, sgtk_valid_int (p_char_offset));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_char_offset = sgtk_rep_to_int (p_char_offset);
++
++ gtk_text_buffer_get_iter_at_offset (c_buffer, c_iter, c_char_offset);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-iter-at-line", Fgtk_text_buffer_get_iter_at_line, Sgtk_text_buffer_get_iter_at_line, (repv p_buffer, repv p_iter, repv p_line_number), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++ gint c_line_number;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_line_number, sgtk_valid_int (p_line_number));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_line_number = sgtk_rep_to_int (p_line_number);
++
++ gtk_text_buffer_get_iter_at_line (c_buffer, c_iter, c_line_number);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-start-iter", Fgtk_text_buffer_get_start_iter, Sgtk_text_buffer_get_start_iter, (repv p_buffer, repv p_iter), rep_Subr2)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ gtk_text_buffer_get_start_iter (c_buffer, c_iter);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-end-iter", Fgtk_text_buffer_get_end_iter, Sgtk_text_buffer_get_end_iter, (repv p_buffer, repv p_iter), rep_Subr2)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ gtk_text_buffer_get_end_iter (c_buffer, c_iter);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-bounds", Fgtk_text_buffer_get_bounds, Sgtk_text_buffer_get_bounds, (repv p_buffer, repv p_start, repv p_end), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ gtk_text_buffer_get_bounds (c_buffer, c_start, c_end);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-iter-at-mark", Fgtk_text_buffer_get_iter_at_mark, Sgtk_text_buffer_get_iter_at_mark, (repv p_buffer, repv p_iter, repv p_mark), rep_Subr3)
++{
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_iter;
++ GtkTextMark* c_mark;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++
++ gtk_text_buffer_get_iter_at_mark (c_buffer, c_iter, c_mark);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-modified", Fgtk_text_buffer_get_modified, Sgtk_text_buffer_get_modified, (repv p_buffer), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ int cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++
++ cr_ret = gtk_text_buffer_get_modified (c_buffer);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-set-modified", Fgtk_text_buffer_set_modified, Sgtk_text_buffer_set_modified, (repv p_buffer, repv p_setting), rep_Subr2)
++{
++ GtkTextBuffer* c_buffer;
++ int c_setting;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_text_buffer_set_modified (c_buffer, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-get-selection-bounds", Fgtk_text_buffer_get_selection_bounds, Sgtk_text_buffer_get_selection_bounds, (repv p_buffer, repv p_start, repv p_end), rep_Subr3)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ GtkTextIter* c_start;
++ GtkTextIter* c_end;
++ int cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++ rep_DECLARE (2, p_start, sgtk_valid_boxed (p_start, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_end, sgtk_valid_boxed (p_end, &sgtk_gtk_text_iter_info));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_start = (GtkTextIter*) sgtk_rep_to_boxed (p_start);
++ c_end = (GtkTextIter*) sgtk_rep_to_boxed (p_end);
++
++ cr_ret = gtk_text_buffer_get_selection_bounds (c_buffer, c_start, c_end);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-delete-selection", Fgtk_text_buffer_delete_selection, Sgtk_text_buffer_delete_selection, (repv p_buffer, repv p_interactive, repv p_default_editable), rep_Subr3)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ int c_interactive;
++ int c_default_editable;
++ int cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++ c_interactive = sgtk_rep_to_bool (p_interactive);
++ c_default_editable = sgtk_rep_to_bool (p_default_editable);
++
++ cr_ret = gtk_text_buffer_delete_selection (c_buffer, c_interactive, c_default_editable);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-buffer-begin-user-action", Fgtk_text_buffer_begin_user_action, Sgtk_text_buffer_begin_user_action, (repv p_buffer), rep_Subr1)
++{
++ GtkTextBuffer* c_buffer;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++
++ gtk_text_buffer_begin_user_action (c_buffer);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-buffer-end-user-action", Fgtk_text_buffer_end_user_action, Sgtk_text_buffer_end_user_action, (repv p_buffer), rep_Subr1)
++{
++ GtkTextBuffer* c_buffer;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++
++ gtk_text_buffer_end_user_action (c_buffer);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-new", Fgtk_text_view_new, Sgtk_text_view_new, (void), rep_Subr0)
++{
++ repv pr_ret;
++ GtkWidget* cr_ret;
++
++ cr_ret = gtk_text_view_new ();
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-new-with-buffer", Fgtk_text_view_new_with_buffer, Sgtk_text_view_new_with_buffer, (repv p_buffer), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextBuffer* c_buffer;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++
++ cr_ret = gtk_text_view_new_with_buffer (c_buffer);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-buffer", Fgtk_text_view_set_buffer, Sgtk_text_view_set_buffer, (repv p_view, repv p_buffer), rep_Subr2)
++{
++ GtkTextView* c_view;
++ GtkTextBuffer* c_buffer;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_buffer, sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_buffer));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_buffer = (GtkTextBuffer*) sgtk_get_gobj (p_buffer);
++
++ gtk_text_view_set_buffer (c_view, c_buffer);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-buffer", Fgtk_text_view_get_buffer, Sgtk_text_view_get_buffer, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkTextBuffer* cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_buffer (c_view);
++
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-scroll-to-iter", Fgtk_text_view_scroll_to_iter, Sgtk_text_view_scroll_to_iter, (repv args), rep_SubrN)
++{
++ repv pr_ret;
++ repv p_view, p_iter, p_within_margin, p_use_align, p_xalign, p_yalign;
++
++ GtkTextView* c_view;
++ GtkTextIter* c_iter;
++ gdouble c_within_margin;
++ int c_use_align;
++ gdouble c_xalign;
++ gdouble c_yalign;
++ int cr_ret;
++
++ if (!rep_CONSP(args))
++ p_view = Qnil;
++ else {
++ p_view = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_iter = Qnil;
++ else {
++ p_iter = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_within_margin = Qnil;
++ else {
++ p_within_margin = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_use_align = Qnil;
++ else {
++ p_use_align = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_xalign = Qnil;
++ else {
++ p_xalign = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_yalign = Qnil;
++ else {
++ p_yalign = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_within_margin, sgtk_valid_double (p_within_margin));
++ rep_DECLARE (5, p_xalign, sgtk_valid_double (p_xalign));
++ rep_DECLARE (6, p_yalign, sgtk_valid_double (p_yalign));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_within_margin = sgtk_rep_to_double (p_within_margin);
++ c_use_align = sgtk_rep_to_bool (p_use_align);
++ c_xalign = sgtk_rep_to_double (p_xalign);
++ c_yalign = sgtk_rep_to_double (p_yalign);
++
++ cr_ret = gtk_text_view_scroll_to_iter (c_view, c_iter, c_within_margin, c_use_align, c_xalign, c_yalign);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-scroll-to-mark", Fgtk_text_view_scroll_to_mark, Sgtk_text_view_scroll_to_mark, (repv args), rep_SubrN)
++{
++ repv p_view, p_mark, p_within_margin, p_use_align, p_xalign, p_yalign;
++
++ GtkTextView* c_view;
++ GtkTextMark* c_mark;
++ gdouble c_within_margin;
++ int c_use_align;
++ gdouble c_xalign;
++ gdouble c_yalign;
++
++ if (!rep_CONSP(args))
++ p_view = Qnil;
++ else {
++ p_view = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_mark = Qnil;
++ else {
++ p_mark = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_within_margin = Qnil;
++ else {
++ p_within_margin = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_use_align = Qnil;
++ else {
++ p_use_align = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_xalign = Qnil;
++ else {
++ p_xalign = rep_CAR(args); args = rep_CDR(args);
++ }
++ if (!rep_CONSP(args))
++ p_yalign = Qnil;
++ else {
++ p_yalign = rep_CAR(args); args = rep_CDR(args);
++ }
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++ rep_DECLARE (3, p_within_margin, sgtk_valid_double (p_within_margin));
++ rep_DECLARE (5, p_xalign, sgtk_valid_double (p_xalign));
++ rep_DECLARE (6, p_yalign, sgtk_valid_double (p_yalign));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++ c_within_margin = sgtk_rep_to_double (p_within_margin);
++ c_use_align = sgtk_rep_to_bool (p_use_align);
++ c_xalign = sgtk_rep_to_double (p_xalign);
++ c_yalign = sgtk_rep_to_double (p_yalign);
++
++ gtk_text_view_scroll_to_mark (c_view, c_mark, c_within_margin, c_use_align, c_xalign, c_yalign);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-scroll-mark-onscreen", Fgtk_text_view_scroll_mark_onscreen, Sgtk_text_view_scroll_mark_onscreen, (repv p_view, repv p_mark), rep_Subr2)
++{
++ GtkTextView* c_view;
++ GtkTextMark* c_mark;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++
++ gtk_text_view_scroll_mark_onscreen (c_view, c_mark);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-move-mark-onscreen", Fgtk_text_view_move_mark_onscreen, Sgtk_text_view_move_mark_onscreen, (repv p_view, repv p_mark), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkTextMark* c_mark;
++ int cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_mark, sgtk_is_a_gobj (gtk_text_mark_get_type (), p_mark));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_mark = (GtkTextMark*) sgtk_get_gobj (p_mark);
++
++ cr_ret = gtk_text_view_move_mark_onscreen (c_view, c_mark);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-place-cursor-onscreen", Fgtk_text_view_place_cursor_onscreen, Sgtk_text_view_place_cursor_onscreen, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ int cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_place_cursor_onscreen (c_view);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-cursor-visible", Fgtk_text_view_set_cursor_visible, Sgtk_text_view_set_cursor_visible, (repv p_view, repv p_setting), rep_Subr2)
++{
++ GtkTextView* c_view;
++ int c_setting;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_text_view_set_cursor_visible (c_view, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-cursor-visible", Fgtk_text_view_get_cursor_visible, Sgtk_text_view_get_cursor_visible, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ int cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_cursor_visible (c_view);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-get-iter-at-location", Fgtk_text_view_get_iter_at_location, Sgtk_text_view_get_iter_at_location, (repv p_view, repv p_iter, repv p_x, repv p_y), rep_Subr4)
++{
++ GtkTextView* c_view;
++ GtkTextIter* c_iter;
++ gint c_x;
++ gint c_y;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_x, sgtk_valid_int (p_x));
++ rep_DECLARE (4, p_y, sgtk_valid_int (p_y));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_x = sgtk_rep_to_int (p_x);
++ c_y = sgtk_rep_to_int (p_y);
++
++ gtk_text_view_get_iter_at_location (c_view, c_iter, c_x, c_y);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-window", Fgtk_text_view_get_window, Sgtk_text_view_get_window, (repv p_view, repv p_type), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkTextWindowType c_type;
++ GdkWindow* cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_text_window_type_info));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_type = (GtkTextWindowType) sgtk_rep_to_enum (p_type, &sgtk_gtk_text_window_type_info);
++
++ cr_ret = gtk_text_view_get_window (c_view, c_type);
++
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_window_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-get-window-type", Fgtk_text_view_get_window_type, Sgtk_text_view_get_window_type, (repv p_view, repv p_window), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GdkWindow* c_window;
++ GtkTextWindowType cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_window, sgtk_valid_boxed (p_window, &sgtk_gdk_window_info));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_window = (GdkWindow*) sgtk_rep_to_boxed (p_window);
++
++ cr_ret = gtk_text_view_get_window_type (c_view, c_window);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_text_window_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-border-window-size", Fgtk_text_view_set_border_window_size, Sgtk_text_view_set_border_window_size, (repv p_view, repv p_type, repv p_size), rep_Subr3)
++{
++ GtkTextView* c_view;
++ GtkTextWindowType c_type;
++ gint c_size;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_text_window_type_info));
++ rep_DECLARE (3, p_size, sgtk_valid_int (p_size));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_type = (GtkTextWindowType) sgtk_rep_to_enum (p_type, &sgtk_gtk_text_window_type_info);
++ c_size = sgtk_rep_to_int (p_size);
++
++ gtk_text_view_set_border_window_size (c_view, c_type, c_size);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-border-window-size", Fgtk_text_view_get_border_window_size, Sgtk_text_view_get_border_window_size, (repv p_view, repv p_type), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkTextWindowType c_type;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_type, sgtk_valid_enum (p_type, &sgtk_gtk_text_window_type_info));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_type = (GtkTextWindowType) sgtk_rep_to_enum (p_type, &sgtk_gtk_text_window_type_info);
++
++ cr_ret = gtk_text_view_get_border_window_size (c_view, c_type);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-forward-display-line", Fgtk_text_view_forward_display_line, Sgtk_text_view_forward_display_line, (repv p_view, repv p_iter), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_view_forward_display_line (c_view, c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-backward-display-line", Fgtk_text_view_backward_display_line, Sgtk_text_view_backward_display_line, (repv p_view, repv p_iter), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_view_backward_display_line (c_view, c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-forward-display-line-end", Fgtk_text_view_forward_display_line_end, Sgtk_text_view_forward_display_line_end, (repv p_view, repv p_iter), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_view_forward_display_line_end (c_view, c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-backward-display-line-start", Fgtk_text_view_backward_display_line_start, Sgtk_text_view_backward_display_line_start, (repv p_view, repv p_iter), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_view_backward_display_line_start (c_view, c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-starts-display-line", Fgtk_text_view_starts_display_line, Sgtk_text_view_starts_display_line, (repv p_view, repv p_iter), rep_Subr2)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkTextIter* c_iter;
++ int cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++
++ cr_ret = gtk_text_view_starts_display_line (c_view, c_iter);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-move-visually", Fgtk_text_view_move_visually, Sgtk_text_view_move_visually, (repv p_view, repv p_iter, repv p_count), rep_Subr3)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkTextIter* c_iter;
++ gint c_count;
++ int cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_iter, sgtk_valid_boxed (p_iter, &sgtk_gtk_text_iter_info));
++ rep_DECLARE (3, p_count, sgtk_valid_int (p_count));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_iter = (GtkTextIter*) sgtk_rep_to_boxed (p_iter);
++ c_count = sgtk_rep_to_int (p_count);
++
++ cr_ret = gtk_text_view_move_visually (c_view, c_iter, c_count);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-add-child-in-window", Fgtk_text_view_add_child_in_window, Sgtk_text_view_add_child_in_window, (repv p_view, repv p_child, repv p_which_window, repv p_xpos, repv p_ypos), rep_Subr5)
++{
++ GtkTextView* c_view;
++ GtkWidget* c_child;
++ GtkTextWindowType c_which_window;
++ gint c_xpos;
++ gint c_ypos;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_which_window, sgtk_valid_enum (p_which_window, &sgtk_gtk_text_window_type_info));
++ rep_DECLARE (4, p_xpos, sgtk_valid_int (p_xpos));
++ rep_DECLARE (5, p_ypos, sgtk_valid_int (p_ypos));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_which_window = (GtkTextWindowType) sgtk_rep_to_enum (p_which_window, &sgtk_gtk_text_window_type_info);
++ c_xpos = sgtk_rep_to_int (p_xpos);
++ c_ypos = sgtk_rep_to_int (p_ypos);
++
++ gtk_text_view_add_child_in_window (c_view, c_child, c_which_window, c_xpos, c_ypos);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-move-child", Fgtk_text_view_move_child, Sgtk_text_view_move_child, (repv p_view, repv p_child, repv p_xpos, repv p_ypos), rep_Subr4)
++{
++ GtkTextView* c_view;
++ GtkWidget* c_child;
++ gint c_xpos;
++ gint c_ypos;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_child, sgtk_is_a_gobj (gtk_widget_get_type (), p_child));
++ rep_DECLARE (3, p_xpos, sgtk_valid_int (p_xpos));
++ rep_DECLARE (4, p_ypos, sgtk_valid_int (p_ypos));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_child = (GtkWidget*) sgtk_get_gobj (p_child);
++ c_xpos = sgtk_rep_to_int (p_xpos);
++ c_ypos = sgtk_rep_to_int (p_ypos);
++
++ gtk_text_view_move_child (c_view, c_child, c_xpos, c_ypos);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-set-wrap-mode", Fgtk_text_view_set_wrap_mode, Sgtk_text_view_set_wrap_mode, (repv p_view, repv p_wrap_mode), rep_Subr2)
++{
++ GtkTextView* c_view;
++ GtkWrapMode c_wrap_mode;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_wrap_mode, sgtk_valid_enum (p_wrap_mode, &sgtk_gtk_wrap_mode_info));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_wrap_mode = (GtkWrapMode) sgtk_rep_to_enum (p_wrap_mode, &sgtk_gtk_wrap_mode_info);
++
++ gtk_text_view_set_wrap_mode (c_view, c_wrap_mode);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-wrap-mode", Fgtk_text_view_get_wrap_mode, Sgtk_text_view_get_wrap_mode, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkWrapMode cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_wrap_mode (c_view);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_wrap_mode_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-editable", Fgtk_text_view_set_editable, Sgtk_text_view_set_editable, (repv p_view, repv p_setting), rep_Subr2)
++{
++ GtkTextView* c_view;
++ int c_setting;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_setting = sgtk_rep_to_bool (p_setting);
++
++ gtk_text_view_set_editable (c_view, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-editable", Fgtk_text_view_get_editable, Sgtk_text_view_get_editable, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ int cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_editable (c_view);
++
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-pixels-above-lines", Fgtk_text_view_set_pixels_above_lines, Sgtk_text_view_set_pixels_above_lines, (repv p_view, repv p_setting), rep_Subr2)
++{
++ GtkTextView* c_view;
++ gint c_setting;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_setting, sgtk_valid_int (p_setting));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_setting = sgtk_rep_to_int (p_setting);
++
++ gtk_text_view_set_pixels_above_lines (c_view, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-pixels-above-lines", Fgtk_text_view_get_pixels_above_lines, Sgtk_text_view_get_pixels_above_lines, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_pixels_above_lines (c_view);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-pixels-below-lines", Fgtk_text_view_set_pixels_below_lines, Sgtk_text_view_set_pixels_below_lines, (repv p_view, repv p_setting), rep_Subr2)
++{
++ GtkTextView* c_view;
++ gint c_setting;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_setting, sgtk_valid_int (p_setting));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_setting = sgtk_rep_to_int (p_setting);
++
++ gtk_text_view_set_pixels_below_lines (c_view, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-pixels-below-lines", Fgtk_text_view_get_pixels_below_lines, Sgtk_text_view_get_pixels_below_lines, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_pixels_below_lines (c_view);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-pixels-inside-wrap", Fgtk_text_view_set_pixels_inside_wrap, Sgtk_text_view_set_pixels_inside_wrap, (repv p_view, repv p_setting), rep_Subr2)
++{
++ GtkTextView* c_view;
++ gint c_setting;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_setting, sgtk_valid_int (p_setting));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_setting = sgtk_rep_to_int (p_setting);
++
++ gtk_text_view_set_pixels_inside_wrap (c_view, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-pixels-inside-wrap", Fgtk_text_view_get_pixels_inside_wrap, Sgtk_text_view_get_pixels_inside_wrap, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_pixels_inside_wrap (c_view);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-justification", Fgtk_text_view_set_justification, Sgtk_text_view_set_justification, (repv p_view, repv p_setting), rep_Subr2)
++{
++ GtkTextView* c_view;
++ GtkJustification c_setting;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_setting, sgtk_valid_enum (p_setting, &sgtk_gtk_justification_info));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_setting = (GtkJustification) sgtk_rep_to_enum (p_setting, &sgtk_gtk_justification_info);
++
++ gtk_text_view_set_justification (c_view, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-justification", Fgtk_text_view_get_justification, Sgtk_text_view_get_justification, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ GtkJustification cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_justification (c_view);
++
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_justification_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-left-margin", Fgtk_text_view_set_left_margin, Sgtk_text_view_set_left_margin, (repv p_view, repv p_setting), rep_Subr2)
++{
++ GtkTextView* c_view;
++ gint c_setting;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_setting, sgtk_valid_int (p_setting));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_setting = sgtk_rep_to_int (p_setting);
++
++ gtk_text_view_set_left_margin (c_view, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-left-margin", Fgtk_text_view_get_left_margin, Sgtk_text_view_get_left_margin, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_left_margin (c_view);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-right-margin", Fgtk_text_view_set_right_margin, Sgtk_text_view_set_right_margin, (repv p_view, repv p_setting), rep_Subr2)
++{
++ GtkTextView* c_view;
++ gint c_setting;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_setting, sgtk_valid_int (p_setting));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_setting = sgtk_rep_to_int (p_setting);
++
++ gtk_text_view_set_right_margin (c_view, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-right-margin", Fgtk_text_view_get_right_margin, Sgtk_text_view_get_right_margin, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_right_margin (c_view);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-text-view-set-indent", Fgtk_text_view_set_indent, Sgtk_text_view_set_indent, (repv p_view, repv p_setting), rep_Subr2)
++{
++ GtkTextView* c_view;
++ gint c_setting;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++ rep_DECLARE (2, p_setting, sgtk_valid_int (p_setting));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++ c_setting = sgtk_rep_to_int (p_setting);
++
++ gtk_text_view_set_indent (c_view, c_setting);
++
++ return Qnil;
++}
++
++DEFUN("gtk-text-view-get-indent", Fgtk_text_view_get_indent, Sgtk_text_view_get_indent, (repv p_view), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTextView* c_view;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_view, sgtk_is_a_gobj (gtk_text_view_get_type (), p_view));
++
++ c_view = (GtkTextView*) sgtk_get_gobj (p_view);
++
++ cr_ret = gtk_text_view_get_indent (c_view);
++
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++
++
++DEFUN("gtk-icon-set-p", Fgtk_icon_set_p, Sgtk_icon_set_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_valid_boxed (p_obj, &sgtk_gtk_icon_set_info)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-text-iter-p", Fgtk_text_iter_p, Sgtk_text_iter_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_valid_boxed (p_obj, &sgtk_gtk_text_iter_info)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-widget-style", Fgtk_widget_style, Sgtk_widget_style, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_obj;
++ GtkStyle* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_widget_get_type (), p_obj));
++
++ c_obj = (GtkWidget*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->style;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-window", Fgtk_widget_window, Sgtk_widget_window, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_obj;
++ GdkWindow* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_widget_get_type (), p_obj));
++
++ c_obj = (GtkWidget*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->window;
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_window_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-parent", Fgtk_widget_parent, Sgtk_widget_parent, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_widget_get_type (), p_obj));
++
++ c_obj = (GtkWidget*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->parent;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-allocation", Fgtk_widget_allocation, Sgtk_widget_allocation, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkWidget* c_obj;
++ repv cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_widget_get_type (), p_obj));
++
++ c_obj = (GtkWidget*) sgtk_get_gobj (p_obj);
++
++ cr_ret = sgtk_gtk_widget_get_allocation (c_obj);
++ pr_ret = (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-widget-p", Fgtk_widget_p, Sgtk_widget_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_widget_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-accel-group-p", Fgtk_accel_group_p, Sgtk_accel_group_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_accel_group_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-style-p", Fgtk_style_p, Sgtk_style_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_style_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-rc-style-p", Fgtk_rc_style_p, Sgtk_rc_style_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_rc_style_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-object-p", Fgtk_object_p, Sgtk_object_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_object_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-adjustment-p", Fgtk_adjustment_p, Sgtk_adjustment_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_adjustment_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-container-p", Fgtk_container_p, Sgtk_container_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_container_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-fixed-p", Fgtk_fixed_p, Sgtk_fixed_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_fixed_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-tree-item-p", Fgtk_tree_item_p, Sgtk_tree_item_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_tree_item_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-tree-p", Fgtk_tree_p, Sgtk_tree_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_tree_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-clist-rows", Fgtk_clist_rows, Sgtk_clist_rows, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCList* c_obj;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_clist_get_type (), p_obj));
++
++ c_obj = (GtkCList*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->rows;
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-columns", Fgtk_clist_columns, Sgtk_clist_columns, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCList* c_obj;
++ gint cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_clist_get_type (), p_obj));
++
++ c_obj = (GtkCList*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->columns;
++ pr_ret = sgtk_int_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-clist-p", Fgtk_clist_p, Sgtk_clist_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_clist_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-bin-p", Fgtk_bin_p, Sgtk_bin_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_bin_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-event-box-p", Fgtk_event_box_p, Sgtk_event_box_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_event_box_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-window-p", Fgtk_window_p, Sgtk_window_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_window_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-handle-box-p", Fgtk_handle_box_p, Sgtk_handle_box_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_handle_box_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-box-p", Fgtk_box_p, Sgtk_box_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_box_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-button-box-p", Fgtk_button_box_p, Sgtk_button_box_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_button_box_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-hbutton-box-p", Fgtk_hbutton_box_p, Sgtk_hbutton_box_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_hbutton_box_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-vbutton-box-p", Fgtk_vbutton_box_p, Sgtk_vbutton_box_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_vbutton_box_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-toolbar-p", Fgtk_toolbar_p, Sgtk_toolbar_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_toolbar_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-table-p", Fgtk_table_p, Sgtk_table_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_table_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-button-in-button", Fgtk_button_in_button, Sgtk_button_in_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkButton* c_obj;
++ int cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_button_get_type (), p_obj));
++
++ c_obj = (GtkButton*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->in_button;
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-button-down", Fgtk_button_button_down, Sgtk_button_button_down, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkButton* c_obj;
++ int cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_button_get_type (), p_obj));
++
++ c_obj = (GtkButton*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->button_down;
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-button-p", Fgtk_button_p, Sgtk_button_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_button_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-toggle-button-p", Fgtk_toggle_button_p, Sgtk_toggle_button_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_toggle_button_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-check-button-p", Fgtk_check_button_p, Sgtk_check_button_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_check_button_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-radio-button-p", Fgtk_radio_button_p, Sgtk_radio_button_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_radio_button_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-misc-p", Fgtk_misc_p, Sgtk_misc_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_misc_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-arrow-p", Fgtk_arrow_p, Sgtk_arrow_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_arrow_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-label-p", Fgtk_label_p, Sgtk_label_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_label_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-layout-p", Fgtk_layout_p, Sgtk_layout_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_layout_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-tips-query-p", Fgtk_tips_query_p, Sgtk_tips_query_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_tips_query_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-vbox-p", Fgtk_vbox_p, Sgtk_vbox_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_vbox_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-hbox-p", Fgtk_hbox_p, Sgtk_hbox_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_hbox_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-item-p", Fgtk_item_p, Sgtk_item_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_item_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-combo-entry", Fgtk_combo_entry, Sgtk_combo_entry, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCombo* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_combo_get_type (), p_obj));
++
++ c_obj = (GtkCombo*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->entry;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-combo-button", Fgtk_combo_button, Sgtk_combo_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCombo* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_combo_get_type (), p_obj));
++
++ c_obj = (GtkCombo*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-combo-popup", Fgtk_combo_popup, Sgtk_combo_popup, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCombo* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_combo_get_type (), p_obj));
++
++ c_obj = (GtkCombo*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->popup;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-combo-popwin", Fgtk_combo_popwin, Sgtk_combo_popwin, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCombo* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_combo_get_type (), p_obj));
++
++ c_obj = (GtkCombo*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->popwin;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-combo-list", Fgtk_combo_list, Sgtk_combo_list, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCombo* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_combo_get_type (), p_obj));
++
++ c_obj = (GtkCombo*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->list;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-combo-p", Fgtk_combo_p, Sgtk_combo_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_combo_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-statusbar-p", Fgtk_statusbar_p, Sgtk_statusbar_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_statusbar_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-gamma-curve-table", Fgtk_gamma_curve_table, Sgtk_gamma_curve_table, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkGammaCurve* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_gamma_curve_get_type (), p_obj));
++
++ c_obj = (GtkGammaCurve*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->table;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-gamma-curve-curve", Fgtk_gamma_curve_curve, Sgtk_gamma_curve_curve, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkGammaCurve* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_gamma_curve_get_type (), p_obj));
++
++ c_obj = (GtkGammaCurve*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->curve;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-gamma-curve-gamma", Fgtk_gamma_curve_gamma, Sgtk_gamma_curve_gamma, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkGammaCurve* c_obj;
++ gfloat cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_gamma_curve_get_type (), p_obj));
++
++ c_obj = (GtkGammaCurve*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->gamma;
++ pr_ret = sgtk_float_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-gamma-curve-gamma-dialog", Fgtk_gamma_curve_gamma_dialog, Sgtk_gamma_curve_gamma_dialog, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkGammaCurve* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_gamma_curve_get_type (), p_obj));
++
++ c_obj = (GtkGammaCurve*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->gamma_dialog;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-gamma-curve-gamma-text", Fgtk_gamma_curve_gamma_text, Sgtk_gamma_curve_gamma_text, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkGammaCurve* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_gamma_curve_get_type (), p_obj));
++
++ c_obj = (GtkGammaCurve*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->gamma_text;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-gamma-curve-p", Fgtk_gamma_curve_p, Sgtk_gamma_curve_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_gamma_curve_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-separator-p", Fgtk_separator_p, Sgtk_separator_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_separator_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-hseparator-p", Fgtk_hseparator_p, Sgtk_hseparator_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_hseparator_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-vseparator-p", Fgtk_vseparator_p, Sgtk_vseparator_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_vseparator_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-frame-p", Fgtk_frame_p, Sgtk_frame_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_frame_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-aspect-frame-p", Fgtk_aspect_frame_p, Sgtk_aspect_frame_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_aspect_frame_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-progress-p", Fgtk_progress_p, Sgtk_progress_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_progress_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-progress-bar-p", Fgtk_progress_bar_p, Sgtk_progress_bar_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_progress_bar_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-tooltips-p", Fgtk_tooltips_p, Sgtk_tooltips_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_tooltips_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-menu-shell-p", Fgtk_menu_shell_p, Sgtk_menu_shell_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_menu_shell_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-menu-bar-p", Fgtk_menu_bar_p, Sgtk_menu_bar_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_menu_bar_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-menu-p", Fgtk_menu_p, Sgtk_menu_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_menu_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-menu-item-p", Fgtk_menu_item_p, Sgtk_menu_item_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_menu_item_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-check-menu-item-active", Fgtk_check_menu_item_active, Sgtk_check_menu_item_active, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkCheckMenuItem* c_obj;
++ int cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_check_menu_item_get_type (), p_obj));
++
++ c_obj = (GtkCheckMenuItem*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->active;
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-check-menu-item-p", Fgtk_check_menu_item_p, Sgtk_check_menu_item_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_check_menu_item_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-radio-menu-item-p", Fgtk_radio_menu_item_p, Sgtk_radio_menu_item_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_radio_menu_item_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-option-menu-p", Fgtk_option_menu_p, Sgtk_option_menu_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_option_menu_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-pixmap-p", Fgtk_pixmap_p, Sgtk_pixmap_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_pixmap_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-viewport-p", Fgtk_viewport_p, Sgtk_viewport_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_viewport_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-scrolled-window-p", Fgtk_scrolled_window_p, Sgtk_scrolled_window_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_scrolled_window_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-list-item-p", Fgtk_list_item_p, Sgtk_list_item_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_list_item_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-list-p", Fgtk_list_p, Sgtk_list_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_list_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-notebook-tab-pos", Fgtk_notebook_tab_pos, Sgtk_notebook_tab_pos, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkNotebook* c_obj;
++ GtkPositionType cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_notebook_get_type (), p_obj));
++
++ c_obj = (GtkNotebook*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->tab_pos;
++ pr_ret = sgtk_enum_to_rep (cr_ret, &sgtk_gtk_position_type_info);
++ return pr_ret;
++}
++
++DEFUN("gtk-notebook-p", Fgtk_notebook_p, Sgtk_notebook_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_notebook_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-editable-p", Fgtk_editable_p, Sgtk_editable_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_editable_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-entry-p", Fgtk_entry_p, Sgtk_entry_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_entry_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-spin-button-p", Fgtk_spin_button_p, Sgtk_spin_button_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_spin_button_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-alignment-p", Fgtk_alignment_p, Sgtk_alignment_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_alignment_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-drawing-area-p", Fgtk_drawing_area_p, Sgtk_drawing_area_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_drawing_area_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-curve-p", Fgtk_curve_p, Sgtk_curve_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_curve_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-preview-p", Fgtk_preview_p, Sgtk_preview_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_preview_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-file-selection-dir-list", Fgtk_file_selection_dir_list, Sgtk_file_selection_dir_list, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFileSelection* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_obj));
++
++ c_obj = (GtkFileSelection*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->dir_list;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-file-list", Fgtk_file_selection_file_list, Sgtk_file_selection_file_list, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFileSelection* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_obj));
++
++ c_obj = (GtkFileSelection*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->file_list;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-selection-entry", Fgtk_file_selection_selection_entry, Sgtk_file_selection_selection_entry, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFileSelection* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_obj));
++
++ c_obj = (GtkFileSelection*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->selection_entry;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-selection-text", Fgtk_file_selection_selection_text, Sgtk_file_selection_selection_text, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFileSelection* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_obj));
++
++ c_obj = (GtkFileSelection*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->selection_text;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-main-vbox", Fgtk_file_selection_main_vbox, Sgtk_file_selection_main_vbox, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFileSelection* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_obj));
++
++ c_obj = (GtkFileSelection*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->main_vbox;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-ok-button", Fgtk_file_selection_ok_button, Sgtk_file_selection_ok_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFileSelection* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_obj));
++
++ c_obj = (GtkFileSelection*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->ok_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-cancel-button", Fgtk_file_selection_cancel_button, Sgtk_file_selection_cancel_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFileSelection* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_obj));
++
++ c_obj = (GtkFileSelection*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->cancel_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-help-button", Fgtk_file_selection_help_button, Sgtk_file_selection_help_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFileSelection* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_obj));
++
++ c_obj = (GtkFileSelection*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->help_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-action-area", Fgtk_file_selection_action_area, Sgtk_file_selection_action_area, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFileSelection* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_file_selection_get_type (), p_obj));
++
++ c_obj = (GtkFileSelection*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->action_area;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-file-selection-p", Fgtk_file_selection_p, Sgtk_file_selection_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_file_selection_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-font-selection-dialog-main-vbox", Fgtk_font_selection_dialog_main_vbox, Sgtk_font_selection_dialog_main_vbox, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFontSelectionDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_font_selection_dialog_get_type (), p_obj));
++
++ c_obj = (GtkFontSelectionDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->main_vbox;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-font-selection-dialog-action-area", Fgtk_font_selection_dialog_action_area, Sgtk_font_selection_dialog_action_area, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFontSelectionDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_font_selection_dialog_get_type (), p_obj));
++
++ c_obj = (GtkFontSelectionDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->action_area;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-font-selection-dialog-ok-button", Fgtk_font_selection_dialog_ok_button, Sgtk_font_selection_dialog_ok_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFontSelectionDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_font_selection_dialog_get_type (), p_obj));
++
++ c_obj = (GtkFontSelectionDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->ok_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-font-selection-dialog-apply-button", Fgtk_font_selection_dialog_apply_button, Sgtk_font_selection_dialog_apply_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFontSelectionDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_font_selection_dialog_get_type (), p_obj));
++
++ c_obj = (GtkFontSelectionDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->apply_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-font-selection-dialog-cancel-button", Fgtk_font_selection_dialog_cancel_button, Sgtk_font_selection_dialog_cancel_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkFontSelectionDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_font_selection_dialog_get_type (), p_obj));
++
++ c_obj = (GtkFontSelectionDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->cancel_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-font-selection-dialog-p", Fgtk_font_selection_dialog_p, Sgtk_font_selection_dialog_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_font_selection_dialog_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-color-selection-dialog-colorsel", Fgtk_color_selection_dialog_colorsel, Sgtk_color_selection_dialog_colorsel, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkColorSelectionDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_color_selection_dialog_get_type (), p_obj));
++
++ c_obj = (GtkColorSelectionDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->colorsel;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-color-selection-dialog-ok-button", Fgtk_color_selection_dialog_ok_button, Sgtk_color_selection_dialog_ok_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkColorSelectionDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_color_selection_dialog_get_type (), p_obj));
++
++ c_obj = (GtkColorSelectionDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->ok_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-color-selection-dialog-cancel-button", Fgtk_color_selection_dialog_cancel_button, Sgtk_color_selection_dialog_cancel_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkColorSelectionDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_color_selection_dialog_get_type (), p_obj));
++
++ c_obj = (GtkColorSelectionDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->cancel_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-color-selection-dialog-help-button", Fgtk_color_selection_dialog_help_button, Sgtk_color_selection_dialog_help_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkColorSelectionDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_color_selection_dialog_get_type (), p_obj));
++
++ c_obj = (GtkColorSelectionDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->help_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-color-selection-dialog-p", Fgtk_color_selection_dialog_p, Sgtk_color_selection_dialog_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_color_selection_dialog_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-color-selection-p", Fgtk_color_selection_p, Sgtk_color_selection_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_color_selection_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-range-p", Fgtk_range_p, Sgtk_range_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_range_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-scale-p", Fgtk_scale_p, Sgtk_scale_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_scale_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-hscale-p", Fgtk_hscale_p, Sgtk_hscale_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_hscale_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-vscale-p", Fgtk_vscale_p, Sgtk_vscale_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_vscale_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-scrollbar-p", Fgtk_scrollbar_p, Sgtk_scrollbar_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_scrollbar_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-hscrollbar-p", Fgtk_hscrollbar_p, Sgtk_hscrollbar_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_hscrollbar_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-vscrollbar-p", Fgtk_vscrollbar_p, Sgtk_vscrollbar_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_vscrollbar_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-ruler-p", Fgtk_ruler_p, Sgtk_ruler_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_ruler_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-hruler-p", Fgtk_hruler_p, Sgtk_hruler_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_hruler_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-vruler-p", Fgtk_vruler_p, Sgtk_vruler_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_vruler_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-dialog-vbox", Fgtk_dialog_vbox, Sgtk_dialog_vbox, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_dialog_get_type (), p_obj));
++
++ c_obj = (GtkDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->vbox;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-dialog-action-area", Fgtk_dialog_action_area, Sgtk_dialog_action_area, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_dialog_get_type (), p_obj));
++
++ c_obj = (GtkDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->action_area;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-dialog-p", Fgtk_dialog_p, Sgtk_dialog_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_dialog_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-input-dialog-close-button", Fgtk_input_dialog_close_button, Sgtk_input_dialog_close_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkInputDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_input_dialog_get_type (), p_obj));
++
++ c_obj = (GtkInputDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->close_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-input-dialog-save-button", Fgtk_input_dialog_save_button, Sgtk_input_dialog_save_button, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkInputDialog* c_obj;
++ GtkWidget* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_input_dialog_get_type (), p_obj));
++
++ c_obj = (GtkInputDialog*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->save_button;
++ pr_ret = sgtk_wrap_gobj ((GObject*) cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-input-dialog-p", Fgtk_input_dialog_p, Sgtk_input_dialog_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_input_dialog_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-paned-p", Fgtk_paned_p, Sgtk_paned_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_paned_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-hpaned-p", Fgtk_hpaned_p, Sgtk_hpaned_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_hpaned_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-vpaned-p", Fgtk_vpaned_p, Sgtk_vpaned_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_vpaned_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-plug-socket-window", Fgtk_plug_socket_window, Sgtk_plug_socket_window, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkPlug* c_obj;
++ GdkWindow* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_plug_get_type (), p_obj));
++
++ c_obj = (GtkPlug*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->socket_window;
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_window_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-plug-p", Fgtk_plug_p, Sgtk_plug_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_plug_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-socket-plug-window", Fgtk_socket_plug_window, Sgtk_socket_plug_window, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkSocket* c_obj;
++ GdkWindow* cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_socket_get_type (), p_obj));
++
++ c_obj = (GtkSocket*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->plug_window;
++ pr_ret = sgtk_boxed_to_rep (cr_ret, &sgtk_gdk_window_info, 1);
++ return pr_ret;
++}
++
++DEFUN("gtk-socket-p", Fgtk_socket_p, Sgtk_socket_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_socket_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-tearoff-menu-item-torn-off", Fgtk_tearoff_menu_item_torn_off, Sgtk_tearoff_menu_item_torn_off, (repv p_obj), rep_Subr1)
++{
++ repv pr_ret;
++ GtkTearoffMenuItem* c_obj;
++ int cr_ret;
++
++ rep_DECLARE (1, p_obj, sgtk_is_a_gobj (gtk_tearoff_menu_item_get_type (), p_obj));
++
++ c_obj = (GtkTearoffMenuItem*) sgtk_get_gobj (p_obj);
++
++ cr_ret = c_obj->torn_off;
++ pr_ret = sgtk_bool_to_rep (cr_ret);
++ return pr_ret;
++}
++
++DEFUN("gtk-tearoff-menu-item-p", Fgtk_tearoff_menu_item_p, Sgtk_tearoff_menu_item_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_tearoff_menu_item_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-calendar-p", Fgtk_calendar_p, Sgtk_calendar_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_calendar_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-icon-factory-p", Fgtk_icon_factory_p, Sgtk_icon_factory_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_icon_factory_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-image-p", Fgtk_image_p, Sgtk_image_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_image_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-image-menu-item-p", Fgtk_image_menu_item_p, Sgtk_image_menu_item_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_image_menu_item_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-invisible-p", Fgtk_invisible_p, Sgtk_invisible_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_invisible_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-separator-menu-item-p", Fgtk_separator_menu_item_p, Sgtk_separator_menu_item_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_separator_menu_item_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-text-buffer-p", Fgtk_text_buffer_p, Sgtk_text_buffer_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_text_buffer_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-text-mark-p", Fgtk_text_mark_p, Sgtk_text_mark_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_text_mark_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-text-tag-p", Fgtk_text_tag_p, Sgtk_text_tag_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_text_tag_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-text-tag-table-p", Fgtk_text_tag_table_p, Sgtk_text_tag_table_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_text_tag_table_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++DEFUN("gtk-text-view-p", Fgtk_text_view_p, Sgtk_text_view_p, (repv p_obj), rep_Subr1)
++{
++ return (sgtk_is_a_gobj (gtk_text_view_get_type (), p_obj)) ? Qt : Qnil;
++}
++
++
++/* Vector of all type information */
++
++static sgtk_type_info *_type_infos[] = {
++ (sgtk_type_info*)&sgtk_gtk_anchor_type_info,
++ (sgtk_type_info*)&sgtk_gtk_arrow_type_info,
++ (sgtk_type_info*)&sgtk_gtk_button_box_style_info,
++ (sgtk_type_info*)&sgtk_gtk_curve_type_info,
++ (sgtk_type_info*)&sgtk_gtk_delete_type_info,
++ (sgtk_type_info*)&sgtk_gtk_direction_type_info,
++ (sgtk_type_info*)&sgtk_gtk_expander_style_info,
++ (sgtk_type_info*)&sgtk_gtk_icon_size_info,
++ (sgtk_type_info*)&sgtk_gtk_text_direction_info,
++ (sgtk_type_info*)&sgtk_gtk_justification_info,
++ (sgtk_type_info*)&sgtk_gtk_menu_direction_type_info,
++ (sgtk_type_info*)&sgtk_gtk_metric_type_info,
++ (sgtk_type_info*)&sgtk_gtk_movement_step_info,
++ (sgtk_type_info*)&sgtk_gtk_orientation_info,
++ (sgtk_type_info*)&sgtk_gtk_corner_type_info,
++ (sgtk_type_info*)&sgtk_gtk_pack_type_info,
++ (sgtk_type_info*)&sgtk_gtk_path_priority_type_info,
++ (sgtk_type_info*)&sgtk_gtk_path_type_info,
++ (sgtk_type_info*)&sgtk_gtk_policy_type_info,
++ (sgtk_type_info*)&sgtk_gtk_position_type_info,
++ (sgtk_type_info*)&sgtk_gtk_preview_type_info,
++ (sgtk_type_info*)&sgtk_gtk_relief_style_info,
++ (sgtk_type_info*)&sgtk_gtk_resize_mode_info,
++ (sgtk_type_info*)&sgtk_gtk_scroll_type_info,
++ (sgtk_type_info*)&sgtk_gtk_selection_mode_info,
++ (sgtk_type_info*)&sgtk_gtk_shadow_type_info,
++ (sgtk_type_info*)&sgtk_gtk_state_type_info,
++ (sgtk_type_info*)&sgtk_gtk_submenu_direction_info,
++ (sgtk_type_info*)&sgtk_gtk_submenu_placement_info,
++ (sgtk_type_info*)&sgtk_gtk_toolbar_style_info,
++ (sgtk_type_info*)&sgtk_gtk_update_type_info,
++ (sgtk_type_info*)&sgtk_gtk_visibility_info,
++ (sgtk_type_info*)&sgtk_gtk_window_position_info,
++ (sgtk_type_info*)&sgtk_gtk_window_type_info,
++ (sgtk_type_info*)&sgtk_gtk_wrap_mode_info,
++ (sgtk_type_info*)&sgtk_gtk_sort_type_info,
++ (sgtk_type_info*)&sgtk_gtk_toolbar_child_type_info,
++ (sgtk_type_info*)&sgtk_gtk_fundamental_type_info,
++ (sgtk_type_info*)&sgtk_gtk_spin_button_update_policy_info,
++ (sgtk_type_info*)&sgtk_gtk_spin_type_info,
++ (sgtk_type_info*)&sgtk_gtk_cell_type_info,
++ (sgtk_type_info*)&sgtk_gtk_progress_bar_orientation_info,
++ (sgtk_type_info*)&sgtk_gtk_text_window_type_info,
++ (sgtk_type_info*)&sgtk_gtk_attach_options_info,
++ (sgtk_type_info*)&sgtk_gtk_signal_run_type_info,
++ (sgtk_type_info*)&sgtk_gtk_widget_flags_info,
++ (sgtk_type_info*)&sgtk_gtk_arg_flags_info,
++ (sgtk_type_info*)&sgtk_gtk_accel_flags_info,
++ (sgtk_type_info*)&sgtk_gtk_calendar_display_options_info,
++ (sgtk_type_info*)&sgtk_gtk_text_search_flags_info,
++ (sgtk_type_info*)&sgtk_gtk_icon_set_info,
++ (sgtk_type_info*)&sgtk_gtk_text_iter_info,
++ (sgtk_type_info*)&sgtk_gtk_widget_info,
++ (sgtk_type_info*)&sgtk_gtk_accel_group_info,
++ (sgtk_type_info*)&sgtk_gtk_style_info,
++ (sgtk_type_info*)&sgtk_gtk_rc_style_info,
++ (sgtk_type_info*)&sgtk_gtk_object_info,
++ (sgtk_type_info*)&sgtk_gtk_adjustment_info,
++ (sgtk_type_info*)&sgtk_gtk_container_info,
++ (sgtk_type_info*)&sgtk_gtk_fixed_info,
++ (sgtk_type_info*)&sgtk_gtk_tree_item_info,
++ (sgtk_type_info*)&sgtk_gtk_tree_info,
++ (sgtk_type_info*)&sgtk_gtk_clist_info,
++ (sgtk_type_info*)&sgtk_gtk_bin_info,
++ (sgtk_type_info*)&sgtk_gtk_event_box_info,
++ (sgtk_type_info*)&sgtk_gtk_window_info,
++ (sgtk_type_info*)&sgtk_gtk_handle_box_info,
++ (sgtk_type_info*)&sgtk_gtk_box_info,
++ (sgtk_type_info*)&sgtk_gtk_button_box_info,
++ (sgtk_type_info*)&sgtk_gtk_hbutton_box_info,
++ (sgtk_type_info*)&sgtk_gtk_vbutton_box_info,
++ (sgtk_type_info*)&sgtk_gtk_toolbar_info,
++ (sgtk_type_info*)&sgtk_gtk_table_info,
++ (sgtk_type_info*)&sgtk_gtk_button_info,
++ (sgtk_type_info*)&sgtk_gtk_toggle_button_info,
++ (sgtk_type_info*)&sgtk_gtk_check_button_info,
++ (sgtk_type_info*)&sgtk_gtk_radio_button_info,
++ (sgtk_type_info*)&sgtk_gtk_misc_info,
++ (sgtk_type_info*)&sgtk_gtk_arrow_info,
++ (sgtk_type_info*)&sgtk_gtk_label_info,
++ (sgtk_type_info*)&sgtk_gtk_layout_info,
++ (sgtk_type_info*)&sgtk_gtk_tips_query_info,
++ (sgtk_type_info*)&sgtk_gtk_vbox_info,
++ (sgtk_type_info*)&sgtk_gtk_hbox_info,
++ (sgtk_type_info*)&sgtk_gtk_item_info,
++ (sgtk_type_info*)&sgtk_gtk_combo_info,
++ (sgtk_type_info*)&sgtk_gtk_statusbar_info,
++ (sgtk_type_info*)&sgtk_gtk_gamma_curve_info,
++ (sgtk_type_info*)&sgtk_gtk_separator_info,
++ (sgtk_type_info*)&sgtk_gtk_hseparator_info,
++ (sgtk_type_info*)&sgtk_gtk_vseparator_info,
++ (sgtk_type_info*)&sgtk_gtk_frame_info,
++ (sgtk_type_info*)&sgtk_gtk_aspect_frame_info,
++ (sgtk_type_info*)&sgtk_gtk_progress_info,
++ (sgtk_type_info*)&sgtk_gtk_progress_bar_info,
++ (sgtk_type_info*)&sgtk_gtk_tooltips_info,
++ (sgtk_type_info*)&sgtk_gtk_menu_shell_info,
++ (sgtk_type_info*)&sgtk_gtk_menu_bar_info,
++ (sgtk_type_info*)&sgtk_gtk_menu_info,
++ (sgtk_type_info*)&sgtk_gtk_menu_item_info,
++ (sgtk_type_info*)&sgtk_gtk_check_menu_item_info,
++ (sgtk_type_info*)&sgtk_gtk_radio_menu_item_info,
++ (sgtk_type_info*)&sgtk_gtk_option_menu_info,
++ (sgtk_type_info*)&sgtk_gtk_pixmap_info,
++ (sgtk_type_info*)&sgtk_gtk_viewport_info,
++ (sgtk_type_info*)&sgtk_gtk_scrolled_window_info,
++ (sgtk_type_info*)&sgtk_gtk_list_item_info,
++ (sgtk_type_info*)&sgtk_gtk_list_info,
++ (sgtk_type_info*)&sgtk_gtk_notebook_info,
++ (sgtk_type_info*)&sgtk_gtk_editable_info,
++ (sgtk_type_info*)&sgtk_gtk_entry_info,
++ (sgtk_type_info*)&sgtk_gtk_spin_button_info,
++ (sgtk_type_info*)&sgtk_gtk_alignment_info,
++ (sgtk_type_info*)&sgtk_gtk_drawing_area_info,
++ (sgtk_type_info*)&sgtk_gtk_curve_info,
++ (sgtk_type_info*)&sgtk_gtk_preview_info,
++ (sgtk_type_info*)&sgtk_gtk_file_selection_info,
++ (sgtk_type_info*)&sgtk_gtk_font_selection_dialog_info,
++ (sgtk_type_info*)&sgtk_gtk_color_selection_dialog_info,
++ (sgtk_type_info*)&sgtk_gtk_color_selection_info,
++ (sgtk_type_info*)&sgtk_gtk_range_info,
++ (sgtk_type_info*)&sgtk_gtk_scale_info,
++ (sgtk_type_info*)&sgtk_gtk_hscale_info,
++ (sgtk_type_info*)&sgtk_gtk_vscale_info,
++ (sgtk_type_info*)&sgtk_gtk_scrollbar_info,
++ (sgtk_type_info*)&sgtk_gtk_hscrollbar_info,
++ (sgtk_type_info*)&sgtk_gtk_vscrollbar_info,
++ (sgtk_type_info*)&sgtk_gtk_ruler_info,
++ (sgtk_type_info*)&sgtk_gtk_hruler_info,
++ (sgtk_type_info*)&sgtk_gtk_vruler_info,
++ (sgtk_type_info*)&sgtk_gtk_dialog_info,
++ (sgtk_type_info*)&sgtk_gtk_input_dialog_info,
++ (sgtk_type_info*)&sgtk_gtk_paned_info,
++ (sgtk_type_info*)&sgtk_gtk_hpaned_info,
++ (sgtk_type_info*)&sgtk_gtk_vpaned_info,
++ (sgtk_type_info*)&sgtk_gtk_plug_info,
++ (sgtk_type_info*)&sgtk_gtk_socket_info,
++ (sgtk_type_info*)&sgtk_gtk_tearoff_menu_item_info,
++ (sgtk_type_info*)&sgtk_gtk_calendar_info,
++ (sgtk_type_info*)&sgtk_gtk_icon_factory_info,
++ (sgtk_type_info*)&sgtk_gtk_image_info,
++ (sgtk_type_info*)&sgtk_gtk_image_menu_item_info,
++ (sgtk_type_info*)&sgtk_gtk_invisible_info,
++ (sgtk_type_info*)&sgtk_gtk_separator_menu_item_info,
++ (sgtk_type_info*)&sgtk_gtk_text_buffer_info,
++ (sgtk_type_info*)&sgtk_gtk_text_mark_info,
++ (sgtk_type_info*)&sgtk_gtk_text_tag_info,
++ (sgtk_type_info*)&sgtk_gtk_text_tag_table_info,
++ (sgtk_type_info*)&sgtk_gtk_text_view_info,
++ NULL
++};
++
++
++/* Initialisation */
++
++void
++sgtk_init_gtk_gtk_glue (void)
++{
++ static int done;
++ if (!done)
++ {
++ done = 1;
++ sgtk_init_gtk_glib_glue ();
++ sgtk_init_gtk_gdk_glue ();
++ sgtk_init_gdk_pixbuf_glue ();
++ sgtk_register_type_infos (_type_infos);
++ rep_ADD_SUBR(Sgtk_style_get_white_interp);
++ rep_ADD_SUBR(Sgtk_style_fg_gc);
++ rep_ADD_SUBR(Sgtk_style_bg_gc);
++ rep_ADD_SUBR(Sgtk_set_locale);
++ rep_ADD_SUBR(Sgtk_events_pending);
++ rep_ADD_SUBR(Sgtk_main);
++ rep_ADD_SUBR(Sgtk_main_level);
++ rep_ADD_SUBR(Sgtk_main_quit);
++ rep_ADD_SUBR(Sgtk_main_iteration);
++ rep_ADD_SUBR(Sgtk_main_iteration_do);
++ rep_ADD_SUBR(Sgtk_true);
++ rep_ADD_SUBR(Sgtk_false);
++ rep_ADD_SUBR(Sgtk_grab_add);
++ rep_ADD_SUBR(Sgtk_grab_get_current);
++ rep_ADD_SUBR(Sgtk_grab_remove);
++ rep_ADD_SUBR(Sgtk_quit_add);
++ rep_ADD_SUBR(Sgtk_quit_remove);
++ rep_ADD_SUBR(Sgtk_timeout_add);
++ rep_ADD_SUBR(Sgtk_timeout_remove);
++ rep_ADD_SUBR(Sgtk_idle_add);
++ rep_ADD_SUBR(Sgtk_idle_remove);
++ rep_ADD_SUBR(Sgtk_input_add);
++ rep_ADD_SUBR(Sgtk_input_remove);
++ rep_ADD_SUBR(Sgtk_get_current_event);
++ rep_ADD_SUBR(Sgtk_get_current_event_time);
++ rep_ADD_SUBR(Sgtk_rc_add_default_file);
++ rep_ADD_SUBR(Sgtk_rc_get_style);
++ rep_ADD_SUBR(Sgtk_rc_parse);
++ rep_ADD_SUBR(Sgtk_object_destroy);
++ rep_ADD_SUBR(SGTK_OBJECT_TYPE);
++ rep_ADD_SUBR(SGTK_WIDGET_STATE);
++ rep_ADD_SUBR(SGTK_WIDGET_FLAGS);
++ rep_ADD_SUBR(SGTK_WIDGET_SET_FLAGS);
++ rep_ADD_SUBR(SGTK_WIDGET_UNSET_FLAGS);
++ rep_ADD_SUBR(Sgtk_widget_destroy);
++ rep_ADD_SUBR(Sgtk_widget_unparent);
++ rep_ADD_SUBR(Sgtk_widget_show);
++ rep_ADD_SUBR(Sgtk_widget_show_now);
++ rep_ADD_SUBR(Sgtk_widget_hide);
++ rep_ADD_SUBR(Sgtk_widget_show_all);
++ rep_ADD_SUBR(Sgtk_widget_hide_all);
++ rep_ADD_SUBR(Sgtk_widget_map);
++ rep_ADD_SUBR(Sgtk_widget_unmap);
++ rep_ADD_SUBR(Sgtk_widget_realize);
++ rep_ADD_SUBR(Sgtk_widget_unrealize);
++ rep_ADD_SUBR(Sgtk_widget_draw_interp);
++ rep_ADD_SUBR(Sgtk_widget_queue_draw);
++ rep_ADD_SUBR(Sgtk_widget_queue_draw_area);
++ rep_ADD_SUBR(Sgtk_widget_queue_resize);
++ rep_ADD_SUBR(Sgtk_widget_add_accelerator);
++ rep_ADD_SUBR(Sgtk_widget_remove_accelerator);
++ rep_ADD_SUBR(Sgtk_widget_event);
++ rep_ADD_SUBR(Sgtk_widget_activate);
++ rep_ADD_SUBR(Sgtk_widget_set_scroll_adjustments);
++ rep_ADD_SUBR(Sgtk_widget_reparent);
++ rep_ADD_SUBR(Sgtk_widget_is_focus);
++ rep_ADD_SUBR(Sgtk_widget_grab_focus);
++ rep_ADD_SUBR(Sgtk_widget_grab_default);
++ rep_ADD_SUBR(Sgtk_widget_set_name);
++ rep_ADD_SUBR(Sgtk_widget_get_name);
++ rep_ADD_SUBR(Sgtk_widget_set_state);
++ rep_ADD_SUBR(Sgtk_widget_set_sensitive);
++ rep_ADD_SUBR(Sgtk_widget_set_app_paintable);
++ rep_ADD_SUBR(Sgtk_widget_set_double_buffered);
++ rep_ADD_SUBR(Sgtk_widget_set_redraw_on_allocate);
++ rep_ADD_SUBR(Sgtk_widget_set_parent);
++ rep_ADD_SUBR(Sgtk_widget_set_parent_window);
++ rep_ADD_SUBR(Sgtk_widget_set_child_visible);
++ rep_ADD_SUBR(Sgtk_widget_get_child_visible);
++ rep_ADD_SUBR(Sgtk_widget_get_parent);
++ rep_ADD_SUBR(Sgtk_widget_get_parent_window);
++ rep_ADD_SUBR(Sgtk_widget_child_focus);
++ rep_ADD_SUBR(Sgtk_widget_set_size_request);
++ rep_ADD_SUBR(Sgtk_widget_get_size_request);
++ rep_ADD_SUBR(Sgtk_widget_set_events);
++ rep_ADD_SUBR(Sgtk_widget_add_events);
++ rep_ADD_SUBR(Sgtk_widget_set_extension_events);
++ rep_ADD_SUBR(Sgtk_widget_get_toplevel);
++ rep_ADD_SUBR(Sgtk_widget_get_colormap);
++ rep_ADD_SUBR(Sgtk_widget_get_visual);
++ rep_ADD_SUBR(Sgtk_widget_is_ancestor);
++ rep_ADD_SUBR(Sgtk_widget_hide_on_delete);
++ rep_ADD_SUBR(Sgtk_widget_set_style);
++ rep_ADD_SUBR(Sgtk_widget_ensure_style);
++ rep_ADD_SUBR(Sgtk_widget_get_style);
++ rep_ADD_SUBR(Sgtk_widget_modify_style);
++ rep_ADD_SUBR(Sgtk_widget_get_modifier_style);
++ rep_ADD_SUBR(Sgtk_widget_modify_fg);
++ rep_ADD_SUBR(Sgtk_widget_modify_bg);
++ rep_ADD_SUBR(Sgtk_widget_modify_text);
++ rep_ADD_SUBR(Sgtk_widget_modify_base);
++ rep_ADD_SUBR(Sgtk_widget_render_icon);
++ rep_ADD_SUBR(Sgtk_widget_get_events);
++ rep_ADD_SUBR(Sgtk_widget_get_extension_events);
++ rep_ADD_SUBR(Sgtk_widget_push_colormap);
++ rep_ADD_SUBR(Sgtk_widget_push_composite_child);
++ rep_ADD_SUBR(Sgtk_widget_pop_colormap);
++ rep_ADD_SUBR(Sgtk_widget_pop_composite_child);
++ rep_ADD_SUBR(Sgtk_widget_set_default_colormap);
++ rep_ADD_SUBR(Sgtk_widget_get_default_colormap);
++ rep_ADD_SUBR(Sgtk_widget_get_default_visual);
++ rep_ADD_SUBR(Sgtk_widget_get_default_style);
++ rep_ADD_SUBR(Sgtk_container_set_border_width);
++ rep_ADD_SUBR(Sgtk_container_get_border_width);
++ rep_ADD_SUBR(Sgtk_container_add);
++ rep_ADD_SUBR(Sgtk_container_remove);
++ rep_ADD_SUBR(Sgtk_container_set_resize_mode);
++ rep_ADD_SUBR(Sgtk_container_get_resize_mode);
++ rep_ADD_SUBR(Sgtk_container_check_resize);
++ rep_ADD_SUBR(Sgtk_container_foreach);
++ rep_ADD_SUBR(Sgtk_container_get_children);
++ rep_ADD_SUBR(Sgtk_container_set_focus_chain);
++ rep_ADD_SUBR(Sgtk_container_unset_focus_chain);
++ rep_ADD_SUBR(Sgtk_fixed_new);
++ rep_ADD_SUBR(Sgtk_fixed_put);
++ rep_ADD_SUBR(Sgtk_fixed_move);
++ rep_ADD_SUBR(Sgtk_fixed_set_has_window);
++ rep_ADD_SUBR(Sgtk_fixed_get_has_window);
++ rep_ADD_SUBR(Sgtk_tree_item_new);
++ rep_ADD_SUBR(Sgtk_tree_item_new_with_label);
++ rep_ADD_SUBR(Sgtk_tree_item_set_subtree);
++ rep_ADD_SUBR(Sgtk_tree_item_remove_subtree);
++ rep_ADD_SUBR(Sgtk_tree_item_select);
++ rep_ADD_SUBR(Sgtk_tree_item_deselect);
++ rep_ADD_SUBR(Sgtk_tree_item_expand);
++ rep_ADD_SUBR(Sgtk_tree_item_collapse);
++ rep_ADD_SUBR(Sgtk_tree_new);
++ rep_ADD_SUBR(Sgtk_tree_append);
++ rep_ADD_SUBR(Sgtk_tree_prepend);
++ rep_ADD_SUBR(Sgtk_tree_insert);
++ rep_ADD_SUBR(Sgtk_tree_remove_item);
++ rep_ADD_SUBR(Sgtk_tree_clear_items);
++ rep_ADD_SUBR(Sgtk_tree_select_item);
++ rep_ADD_SUBR(Sgtk_tree_unselect_item);
++ rep_ADD_SUBR(Sgtk_tree_select_child);
++ rep_ADD_SUBR(Sgtk_tree_unselect_child);
++ rep_ADD_SUBR(Sgtk_tree_child_position);
++ rep_ADD_SUBR(Sgtk_tree_set_selection_mode);
++ rep_ADD_SUBR(Sgtk_tree_set_view_lines);
++ rep_ADD_SUBR(Sgtk_clist_new);
++ rep_ADD_SUBR(Sgtk_clist_new_with_titles);
++ rep_ADD_SUBR(Sgtk_clist_set_hadjustment);
++ rep_ADD_SUBR(Sgtk_clist_set_vadjustment);
++ rep_ADD_SUBR(Sgtk_clist_get_hadjustment);
++ rep_ADD_SUBR(Sgtk_clist_get_vadjustment);
++ rep_ADD_SUBR(Sgtk_clist_set_shadow_type);
++ rep_ADD_SUBR(Sgtk_clist_set_selection_mode);
++ rep_ADD_SUBR(Sgtk_clist_set_reorderable);
++ rep_ADD_SUBR(Sgtk_clist_set_use_drag_icons);
++ rep_ADD_SUBR(Sgtk_clist_set_button_actions);
++ rep_ADD_SUBR(Sgtk_clist_freeze);
++ rep_ADD_SUBR(Sgtk_clist_thaw);
++ rep_ADD_SUBR(Sgtk_clist_column_titles_show);
++ rep_ADD_SUBR(Sgtk_clist_column_titles_hide);
++ rep_ADD_SUBR(Sgtk_clist_column_title_active);
++ rep_ADD_SUBR(Sgtk_clist_column_title_passive);
++ rep_ADD_SUBR(Sgtk_clist_column_titles_active);
++ rep_ADD_SUBR(Sgtk_clist_column_titles_passive);
++ rep_ADD_SUBR(Sgtk_clist_set_column_title);
++ rep_ADD_SUBR(Sgtk_clist_set_column_widget);
++ rep_ADD_SUBR(Sgtk_clist_get_column_widget);
++ rep_ADD_SUBR(Sgtk_clist_set_column_justification);
++ rep_ADD_SUBR(Sgtk_clist_set_column_visibility);
++ rep_ADD_SUBR(Sgtk_clist_set_column_resizeable);
++ rep_ADD_SUBR(Sgtk_clist_set_column_auto_resize);
++ rep_ADD_SUBR(Sgtk_clist_columns_autosize);
++ rep_ADD_SUBR(Sgtk_clist_optimal_column_width);
++ rep_ADD_SUBR(Sgtk_clist_set_column_width);
++ rep_ADD_SUBR(Sgtk_clist_set_column_min_width);
++ rep_ADD_SUBR(Sgtk_clist_set_column_max_width);
++ rep_ADD_SUBR(Sgtk_clist_set_row_height);
++ rep_ADD_SUBR(Sgtk_clist_moveto);
++ rep_ADD_SUBR(Sgtk_clist_row_is_visible);
++ rep_ADD_SUBR(Sgtk_clist_get_cell_type);
++ rep_ADD_SUBR(Sgtk_clist_set_text);
++ rep_ADD_SUBR(Sgtk_clist_get_text);
++ rep_ADD_SUBR(Sgtk_clist_set_foreground);
++ rep_ADD_SUBR(Sgtk_clist_set_background);
++ rep_ADD_SUBR(Sgtk_clist_set_cell_style);
++ rep_ADD_SUBR(Sgtk_clist_get_cell_style);
++ rep_ADD_SUBR(Sgtk_clist_set_row_style);
++ rep_ADD_SUBR(Sgtk_clist_get_row_style);
++ rep_ADD_SUBR(Sgtk_clist_set_shift);
++ rep_ADD_SUBR(Sgtk_clist_set_selectable);
++ rep_ADD_SUBR(Sgtk_clist_get_selectable);
++ rep_ADD_SUBR(Sgtk_clist_prepend);
++ rep_ADD_SUBR(Sgtk_clist_append);
++ rep_ADD_SUBR(Sgtk_clist_insert);
++ rep_ADD_SUBR(Sgtk_clist_remove);
++ rep_ADD_SUBR(Sgtk_clist_select_row);
++ rep_ADD_SUBR(Sgtk_clist_unselect_row);
++ rep_ADD_SUBR(Sgtk_clist_undo_selection);
++ rep_ADD_SUBR(Sgtk_clist_clear);
++ rep_ADD_SUBR(Sgtk_clist_get_selection_info);
++ rep_ADD_SUBR(Sgtk_clist_unselect_all);
++ rep_ADD_SUBR(Sgtk_clist_swap_rows);
++ rep_ADD_SUBR(Sgtk_clist_set_sort_column);
++ rep_ADD_SUBR(Sgtk_clist_set_sort_type);
++ rep_ADD_SUBR(Sgtk_clist_sort);
++ rep_ADD_SUBR(Sgtk_clist_set_auto_sort);
++ rep_ADD_SUBR(Sgtk_event_box_new);
++ rep_ADD_SUBR(Sgtk_window_new);
++ rep_ADD_SUBR(Sgtk_window_set_title);
++ rep_ADD_SUBR(Sgtk_window_get_title);
++ rep_ADD_SUBR(Sgtk_window_set_wmclass);
++ rep_ADD_SUBR(Sgtk_window_set_role);
++ rep_ADD_SUBR(Sgtk_window_get_role);
++ rep_ADD_SUBR(Sgtk_window_add_accel_group);
++ rep_ADD_SUBR(Sgtk_window_remove_accel_group);
++ rep_ADD_SUBR(Sgtk_window_set_position);
++ rep_ADD_SUBR(Sgtk_window_set_default);
++ rep_ADD_SUBR(Sgtk_window_activate_focus);
++ rep_ADD_SUBR(Sgtk_window_activate_default);
++ rep_ADD_SUBR(Sgtk_window_set_transient_for);
++ rep_ADD_SUBR(Sgtk_window_get_transient_for);
++ rep_ADD_SUBR(Sgtk_window_set_destroy_with_parent);
++ rep_ADD_SUBR(Sgtk_window_get_destroy_with_parent);
++ rep_ADD_SUBR(Sgtk_window_set_resizable);
++ rep_ADD_SUBR(Sgtk_window_get_resizable);
++ rep_ADD_SUBR(Sgtk_window_set_has_frame);
++ rep_ADD_SUBR(Sgtk_window_get_has_frame);
++ rep_ADD_SUBR(Sgtk_window_set_frame_dimensions);
++ rep_ADD_SUBR(Sgtk_window_set_decorated);
++ rep_ADD_SUBR(Sgtk_window_get_decorated);
++ rep_ADD_SUBR(Sgtk_window_set_modal);
++ rep_ADD_SUBR(Sgtk_window_get_modal);
++ rep_ADD_SUBR(Sgtk_window_list_toplevels);
++ rep_ADD_SUBR(Sgtk_window_add_mnemonic);
++ rep_ADD_SUBR(Sgtk_window_remove_mnemonic);
++ rep_ADD_SUBR(Sgtk_window_mnemonic_activate);
++ rep_ADD_SUBR(Sgtk_window_set_mnemonic_modifier);
++ rep_ADD_SUBR(Sgtk_window_get_mnemonic_modifier);
++ rep_ADD_SUBR(Sgtk_window_present);
++ rep_ADD_SUBR(Sgtk_window_iconify);
++ rep_ADD_SUBR(Sgtk_window_deiconify);
++ rep_ADD_SUBR(Sgtk_window_stick);
++ rep_ADD_SUBR(Sgtk_window_unstick);
++ rep_ADD_SUBR(Sgtk_window_maximize);
++ rep_ADD_SUBR(Sgtk_window_unmaximize);
++ rep_ADD_SUBR(Sgtk_window_set_default_size);
++ rep_ADD_SUBR(Sgtk_window_resize);
++ rep_ADD_SUBR(Sgtk_window_move);
++ rep_ADD_SUBR(Sgtk_window_parse_geometry);
++ rep_ADD_SUBR(Sgtk_window_set_focus);
++ rep_ADD_SUBR(Sgtk_handle_box_new);
++ rep_ADD_SUBR(Sgtk_handle_box_set_shadow_type);
++ rep_ADD_SUBR(Sgtk_handle_box_get_shadow_type);
++ rep_ADD_SUBR(Sgtk_handle_box_set_handle_position);
++ rep_ADD_SUBR(Sgtk_handle_box_get_handle_position);
++ rep_ADD_SUBR(Sgtk_handle_box_set_snap_edge);
++ rep_ADD_SUBR(Sgtk_handle_box_get_snap_edge);
++ rep_ADD_SUBR(Sgtk_box_pack_start);
++ rep_ADD_SUBR(Sgtk_box_pack_end);
++ rep_ADD_SUBR(Sgtk_box_pack_start_defaults);
++ rep_ADD_SUBR(Sgtk_box_pack_end_defaults);
++ rep_ADD_SUBR(Sgtk_box_set_homogeneous);
++ rep_ADD_SUBR(Sgtk_box_get_homogeneous);
++ rep_ADD_SUBR(Sgtk_box_set_spacing);
++ rep_ADD_SUBR(Sgtk_box_get_spacing);
++ rep_ADD_SUBR(Sgtk_box_reorder_child);
++ rep_ADD_SUBR(Sgtk_box_set_child_packing);
++ rep_ADD_SUBR(Sgtk_button_box_set_layout);
++ rep_ADD_SUBR(Sgtk_button_box_get_layout);
++ rep_ADD_SUBR(Sgtk_button_box_set_child_secondary);
++ rep_ADD_SUBR(Sgtk_button_box_set_child_size);
++ rep_ADD_SUBR(Sgtk_button_box_set_child_ipadding);
++ rep_ADD_SUBR(Sgtk_hbutton_box_new);
++ rep_ADD_SUBR(Sgtk_vbutton_box_new);
++ rep_ADD_SUBR(Sgtk_toolbar_new);
++ rep_ADD_SUBR(Sgtk_toolbar_append_space);
++ rep_ADD_SUBR(Sgtk_toolbar_prepend_space);
++ rep_ADD_SUBR(Sgtk_toolbar_insert_space);
++ rep_ADD_SUBR(Sgtk_toolbar_remove_space);
++ rep_ADD_SUBR(Sgtk_toolbar_append_widget);
++ rep_ADD_SUBR(Sgtk_toolbar_prepend_widget);
++ rep_ADD_SUBR(Sgtk_toolbar_insert_widget);
++ rep_ADD_SUBR(Sgtk_toolbar_set_orientation);
++ rep_ADD_SUBR(Sgtk_toolbar_set_style);
++ rep_ADD_SUBR(Sgtk_toolbar_set_icon_size);
++ rep_ADD_SUBR(Sgtk_toolbar_set_tooltips);
++ rep_ADD_SUBR(Sgtk_toolbar_unset_style);
++ rep_ADD_SUBR(Sgtk_toolbar_unset_icon_size);
++ rep_ADD_SUBR(Sgtk_toolbar_get_orientation);
++ rep_ADD_SUBR(Sgtk_toolbar_get_style);
++ rep_ADD_SUBR(Sgtk_toolbar_get_icon_size);
++ rep_ADD_SUBR(Sgtk_toolbar_get_tooltips);
++ rep_ADD_SUBR(Sgtk_table_new);
++ rep_ADD_SUBR(Sgtk_table_resize);
++ rep_ADD_SUBR(Sgtk_table_attach);
++ rep_ADD_SUBR(Sgtk_table_attach_defaults);
++ rep_ADD_SUBR(Sgtk_table_set_row_spacing);
++ rep_ADD_SUBR(Sgtk_table_get_row_spacing);
++ rep_ADD_SUBR(Sgtk_table_set_col_spacing);
++ rep_ADD_SUBR(Sgtk_table_get_col_spacing);
++ rep_ADD_SUBR(Sgtk_table_set_row_spacings);
++ rep_ADD_SUBR(Sgtk_table_get_default_row_spacing);
++ rep_ADD_SUBR(Sgtk_table_set_col_spacings);
++ rep_ADD_SUBR(Sgtk_table_set_homogeneous);
++ rep_ADD_SUBR(Sgtk_table_get_homogeneous);
++ rep_ADD_SUBR(Sgtk_button_new);
++ rep_ADD_SUBR(Sgtk_button_new_with_label);
++ rep_ADD_SUBR(Sgtk_button_new_from_stock);
++ rep_ADD_SUBR(Sgtk_button_new_with_mnemonic);
++ rep_ADD_SUBR(Sgtk_button_pressed);
++ rep_ADD_SUBR(Sgtk_button_released);
++ rep_ADD_SUBR(Sgtk_button_clicked);
++ rep_ADD_SUBR(Sgtk_button_enter);
++ rep_ADD_SUBR(Sgtk_button_leave);
++ rep_ADD_SUBR(Sgtk_button_set_relief);
++ rep_ADD_SUBR(Sgtk_button_get_relief);
++ rep_ADD_SUBR(Sgtk_button_set_label);
++ rep_ADD_SUBR(Sgtk_button_get_label);
++ rep_ADD_SUBR(Sgtk_button_set_use_underline);
++ rep_ADD_SUBR(Sgtk_button_get_use_underline);
++ rep_ADD_SUBR(Sgtk_button_set_use_stock);
++ rep_ADD_SUBR(Sgtk_button_get_use_stock);
++ rep_ADD_SUBR(Sgtk_toggle_button_new);
++ rep_ADD_SUBR(Sgtk_toggle_button_new_with_label);
++ rep_ADD_SUBR(Sgtk_toggle_button_new_with_mnemonic);
++ rep_ADD_SUBR(Sgtk_toggle_button_set_mode);
++ rep_ADD_SUBR(Sgtk_toggle_button_get_mode);
++ rep_ADD_SUBR(Sgtk_toggle_button_set_active);
++ rep_ADD_SUBR(Sgtk_toggle_button_get_active);
++ rep_ADD_SUBR(Sgtk_toggle_button_toggled);
++ rep_ADD_SUBR(Sgtk_toggle_button_set_inconsistent);
++ rep_ADD_SUBR(Sgtk_toggle_button_get_inconsistent);
++ rep_ADD_SUBR(Sgtk_check_button_new);
++ rep_ADD_SUBR(Sgtk_check_button_new_with_label);
++ rep_ADD_SUBR(Sgtk_check_button_new_with_mnemonic);
++ rep_ADD_SUBR(Sgtk_radio_button_new_from_widget);
++ rep_ADD_SUBR(Sgtk_radio_button_new_with_label_from_widget);
++ rep_ADD_SUBR(Sgtk_radio_button_new_with_mnemonic_from_widget);
++ rep_ADD_SUBR(Sgtk_misc_set_alignment);
++ rep_ADD_SUBR(Sgtk_misc_set_padding);
++ rep_ADD_SUBR(Sgtk_arrow_new);
++ rep_ADD_SUBR(Sgtk_arrow_set);
++ rep_ADD_SUBR(Sgtk_label_new);
++ rep_ADD_SUBR(Sgtk_label_new_with_mnemonic);
++ rep_ADD_SUBR(Sgtk_label_set_text);
++ rep_ADD_SUBR(Sgtk_label_get_text);
++ rep_ADD_SUBR(Sgtk_label_set_label);
++ rep_ADD_SUBR(Sgtk_label_get_label);
++ rep_ADD_SUBR(Sgtk_label_set_markup);
++ rep_ADD_SUBR(Sgtk_label_set_use_markup);
++ rep_ADD_SUBR(Sgtk_label_get_use_markup);
++ rep_ADD_SUBR(Sgtk_label_set_use_underline);
++ rep_ADD_SUBR(Sgtk_label_get_use_underline);
++ rep_ADD_SUBR(Sgtk_label_set_markup_with_mnemonic);
++ rep_ADD_SUBR(Sgtk_label_get_mnemonic_keyval);
++ rep_ADD_SUBR(Sgtk_label_set_mnemonic_widget);
++ rep_ADD_SUBR(Sgtk_label_get_mnemonic_widget);
++ rep_ADD_SUBR(Sgtk_label_set_text_with_mnemonic);
++ rep_ADD_SUBR(Sgtk_label_set_justify);
++ rep_ADD_SUBR(Sgtk_label_get_justify);
++ rep_ADD_SUBR(Sgtk_label_set_pattern);
++ rep_ADD_SUBR(Sgtk_label_set_line_wrap);
++ rep_ADD_SUBR(Sgtk_label_get_line_wrap);
++ rep_ADD_SUBR(Sgtk_label_set_selectable);
++ rep_ADD_SUBR(Sgtk_label_get_selectable);
++ rep_ADD_SUBR(Sgtk_label_select_region);
++ rep_ADD_SUBR(Sgtk_layout_new);
++ rep_ADD_SUBR(Sgtk_layout_put);
++ rep_ADD_SUBR(Sgtk_layout_move);
++ rep_ADD_SUBR(Sgtk_layout_set_size);
++ rep_ADD_SUBR(Sgtk_layout_get_hadjustment);
++ rep_ADD_SUBR(Sgtk_layout_get_vadjustment);
++ rep_ADD_SUBR(Sgtk_layout_set_hadjustment);
++ rep_ADD_SUBR(Sgtk_layout_set_vadjustment);
++ rep_ADD_SUBR(Sgtk_tips_query_new);
++ rep_ADD_SUBR(Sgtk_tips_query_start_query);
++ rep_ADD_SUBR(Sgtk_tips_query_stop_query);
++ rep_ADD_SUBR(Sgtk_tips_query_set_caller);
++ rep_ADD_SUBR(Sgtk_tips_query_set_labels);
++ rep_ADD_SUBR(Sgtk_vbox_new);
++ rep_ADD_SUBR(Sgtk_hbox_new);
++ rep_ADD_SUBR(Sgtk_item_select);
++ rep_ADD_SUBR(Sgtk_item_deselect);
++ rep_ADD_SUBR(Sgtk_item_toggle);
++ rep_ADD_SUBR(Sgtk_combo_new);
++ rep_ADD_SUBR(Sgtk_combo_set_value_in_list);
++ rep_ADD_SUBR(Sgtk_combo_set_use_arrows);
++ rep_ADD_SUBR(Sgtk_combo_set_use_arrows_always);
++ rep_ADD_SUBR(Sgtk_combo_set_case_sensitive);
++ rep_ADD_SUBR(Sgtk_combo_set_item_string);
++ rep_ADD_SUBR(Sgtk_combo_disable_activate);
++ rep_ADD_SUBR(Sgtk_combo_set_popdown_strings);
++ rep_ADD_SUBR(Sgtk_statusbar_new);
++ rep_ADD_SUBR(Sgtk_statusbar_get_context_id);
++ rep_ADD_SUBR(Sgtk_statusbar_push);
++ rep_ADD_SUBR(Sgtk_statusbar_pop);
++ rep_ADD_SUBR(Sgtk_statusbar_remove);
++ rep_ADD_SUBR(Sgtk_gamma_curve_new);
++ rep_ADD_SUBR(Sgtk_hseparator_new);
++ rep_ADD_SUBR(Sgtk_vseparator_new);
++ rep_ADD_SUBR(Sgtk_frame_new);
++ rep_ADD_SUBR(Sgtk_frame_set_label);
++ rep_ADD_SUBR(Sgtk_frame_get_label);
++ rep_ADD_SUBR(Sgtk_frame_set_label_widget);
++ rep_ADD_SUBR(Sgtk_frame_get_label_widget);
++ rep_ADD_SUBR(Sgtk_frame_set_label_align);
++ rep_ADD_SUBR(Sgtk_frame_set_shadow_type);
++ rep_ADD_SUBR(Sgtk_frame_get_shadow_type);
++ rep_ADD_SUBR(Sgtk_aspect_frame_new);
++ rep_ADD_SUBR(Sgtk_aspect_frame_set);
++ rep_ADD_SUBR(Sgtk_progress_bar_new);
++ rep_ADD_SUBR(Sgtk_progress_bar_pulse);
++ rep_ADD_SUBR(Sgtk_progress_bar_set_text);
++ rep_ADD_SUBR(Sgtk_progress_bar_set_fraction);
++ rep_ADD_SUBR(Sgtk_progress_bar_set_pulse_step);
++ rep_ADD_SUBR(Sgtk_progress_bar_set_orientation);
++ rep_ADD_SUBR(Sgtk_progress_bar_get_text);
++ rep_ADD_SUBR(Sgtk_progress_bar_get_fraction);
++ rep_ADD_SUBR(Sgtk_progress_bar_get_pulse_step);
++ rep_ADD_SUBR(Sgtk_progress_bar_get_orientation);
++ rep_ADD_SUBR(Sgtk_tooltips_new);
++ rep_ADD_SUBR(Sgtk_tooltips_enable);
++ rep_ADD_SUBR(Sgtk_tooltips_disable);
++ rep_ADD_SUBR(Sgtk_tooltips_set_tip);
++ rep_ADD_SUBR(Sgtk_tooltips_force_window);
++ rep_ADD_SUBR(Sgtk_menu_shell_append);
++ rep_ADD_SUBR(Sgtk_menu_shell_prepend);
++ rep_ADD_SUBR(Sgtk_menu_shell_insert);
++ rep_ADD_SUBR(Sgtk_menu_shell_deactivate);
++ rep_ADD_SUBR(Sgtk_menu_shell_select_item);
++ rep_ADD_SUBR(Sgtk_menu_shell_deselect);
++ rep_ADD_SUBR(Sgtk_menu_shell_activate_item);
++ rep_ADD_SUBR(Sgtk_menu_bar_new);
++ rep_ADD_SUBR(Sgtk_menu_new);
++ rep_ADD_SUBR(Sgtk_menu_popup_interp);
++ rep_ADD_SUBR(Sgtk_menu_reposition);
++ rep_ADD_SUBR(Sgtk_menu_popdown);
++ rep_ADD_SUBR(Sgtk_menu_get_active);
++ rep_ADD_SUBR(Sgtk_menu_set_active);
++ rep_ADD_SUBR(Sgtk_menu_set_accel_group);
++ rep_ADD_SUBR(Sgtk_menu_get_accel_group);
++ rep_ADD_SUBR(Sgtk_menu_set_accel_path);
++ rep_ADD_SUBR(Sgtk_menu_detach);
++ rep_ADD_SUBR(Sgtk_menu_get_attach_widget);
++ rep_ADD_SUBR(Sgtk_menu_set_tearoff_state);
++ rep_ADD_SUBR(Sgtk_menu_get_tearoff_state);
++ rep_ADD_SUBR(Sgtk_menu_set_title);
++ rep_ADD_SUBR(Sgtk_menu_get_title);
++ rep_ADD_SUBR(Sgtk_menu_reorder_child);
++ rep_ADD_SUBR(Sgtk_menu_item_new);
++ rep_ADD_SUBR(Sgtk_menu_item_new_with_label);
++ rep_ADD_SUBR(Sgtk_menu_item_new_with_mnemonic);
++ rep_ADD_SUBR(Sgtk_menu_item_set_submenu);
++ rep_ADD_SUBR(Sgtk_menu_item_get_submenu);
++ rep_ADD_SUBR(Sgtk_menu_item_remove_submenu);
++ rep_ADD_SUBR(Sgtk_menu_item_select);
++ rep_ADD_SUBR(Sgtk_menu_item_deselect);
++ rep_ADD_SUBR(Sgtk_menu_item_activate);
++ rep_ADD_SUBR(Sgtk_menu_item_set_right_justified);
++ rep_ADD_SUBR(Sgtk_menu_item_get_right_justified);
++ rep_ADD_SUBR(Sgtk_menu_item_set_accel_path);
++ rep_ADD_SUBR(Sgtk_check_menu_item_new);
++ rep_ADD_SUBR(Sgtk_check_menu_item_new_with_label);
++ rep_ADD_SUBR(Sgtk_check_menu_item_new_with_mnemonic);
++ rep_ADD_SUBR(Sgtk_check_menu_item_set_active);
++ rep_ADD_SUBR(Sgtk_check_menu_item_get_active);
++ rep_ADD_SUBR(Sgtk_check_menu_item_toggled);
++ rep_ADD_SUBR(Sgtk_check_menu_item_set_inconsistent);
++ rep_ADD_SUBR(Sgtk_check_menu_item_get_inconsistent);
++ rep_ADD_SUBR(Sgtk_radio_menu_item_new_from_widget);
++ rep_ADD_SUBR(Sgtk_radio_menu_item_new_with_label_from_widget);
++ rep_ADD_SUBR(Sgtk_radio_menu_item_new_with_mnemonic_from_widget);
++ rep_ADD_SUBR(Sgtk_option_menu_new);
++ rep_ADD_SUBR(Sgtk_option_menu_get_menu);
++ rep_ADD_SUBR(Sgtk_option_menu_set_menu);
++ rep_ADD_SUBR(Sgtk_option_menu_remove_menu);
++ rep_ADD_SUBR(Sgtk_option_menu_get_history);
++ rep_ADD_SUBR(Sgtk_option_menu_set_history);
++ rep_ADD_SUBR(Sgtk_pixmap_new_interp);
++ rep_ADD_SUBR(Sgtk_viewport_new);
++ rep_ADD_SUBR(Sgtk_viewport_get_hadjustment);
++ rep_ADD_SUBR(Sgtk_viewport_get_vadjustment);
++ rep_ADD_SUBR(Sgtk_viewport_set_hadjustment);
++ rep_ADD_SUBR(Sgtk_viewport_set_vadjustment);
++ rep_ADD_SUBR(Sgtk_viewport_set_shadow_type);
++ rep_ADD_SUBR(Sgtk_viewport_get_shadow_type);
++ rep_ADD_SUBR(Sgtk_scrolled_window_new);
++ rep_ADD_SUBR(Sgtk_scrolled_window_set_hadjustment);
++ rep_ADD_SUBR(Sgtk_scrolled_window_set_vadjustment);
++ rep_ADD_SUBR(Sgtk_scrolled_window_get_hadjustment);
++ rep_ADD_SUBR(Sgtk_scrolled_window_get_vadjustment);
++ rep_ADD_SUBR(Sgtk_scrolled_window_set_policy);
++ rep_ADD_SUBR(Sgtk_scrolled_window_set_placement);
++ rep_ADD_SUBR(Sgtk_scrolled_window_get_placement);
++ rep_ADD_SUBR(Sgtk_scrolled_window_set_shadow_type);
++ rep_ADD_SUBR(Sgtk_scrolled_window_get_shadow_type);
++ rep_ADD_SUBR(Sgtk_scrolled_window_add_with_viewport);
++ rep_ADD_SUBR(Sgtk_list_item_new);
++ rep_ADD_SUBR(Sgtk_list_item_new_with_label);
++ rep_ADD_SUBR(Sgtk_list_item_select);
++ rep_ADD_SUBR(Sgtk_list_item_deselect);
++ rep_ADD_SUBR(Sgtk_list_new);
++ rep_ADD_SUBR(Sgtk_list_insert_items);
++ rep_ADD_SUBR(Sgtk_list_append_items);
++ rep_ADD_SUBR(Sgtk_list_prepend_items);
++ rep_ADD_SUBR(Sgtk_list_remove_items);
++ rep_ADD_SUBR(Sgtk_list_append_item);
++ rep_ADD_SUBR(Sgtk_list_prepend_item);
++ rep_ADD_SUBR(Sgtk_list_clear_items);
++ rep_ADD_SUBR(Sgtk_list_select_item);
++ rep_ADD_SUBR(Sgtk_list_unselect_item);
++ rep_ADD_SUBR(Sgtk_list_select_child);
++ rep_ADD_SUBR(Sgtk_list_unselect_child);
++ rep_ADD_SUBR(Sgtk_list_child_position);
++ rep_ADD_SUBR(Sgtk_list_set_selection_mode);
++ rep_ADD_SUBR(Sgtk_list_extend_selection);
++ rep_ADD_SUBR(Sgtk_list_start_selection);
++ rep_ADD_SUBR(Sgtk_list_end_selection);
++ rep_ADD_SUBR(Sgtk_list_select_all);
++ rep_ADD_SUBR(Sgtk_list_unselect_all);
++ rep_ADD_SUBR(Sgtk_list_scroll_horizontal);
++ rep_ADD_SUBR(Sgtk_list_scroll_vertical);
++ rep_ADD_SUBR(Sgtk_list_toggle_add_mode);
++ rep_ADD_SUBR(Sgtk_list_toggle_focus_row);
++ rep_ADD_SUBR(Sgtk_list_toggle_row);
++ rep_ADD_SUBR(Sgtk_list_undo_selection);
++ rep_ADD_SUBR(Sgtk_list_end_drag_selection);
++ rep_ADD_SUBR(Sgtk_notebook_new);
++ rep_ADD_SUBR(Sgtk_notebook_append_page);
++ rep_ADD_SUBR(Sgtk_notebook_append_page_menu);
++ rep_ADD_SUBR(Sgtk_notebook_prepend_page);
++ rep_ADD_SUBR(Sgtk_notebook_prepend_page_menu);
++ rep_ADD_SUBR(Sgtk_notebook_insert_page);
++ rep_ADD_SUBR(Sgtk_notebook_insert_page_menu);
++ rep_ADD_SUBR(Sgtk_notebook_remove_page);
++ rep_ADD_SUBR(Sgtk_notebook_get_current_page);
++ rep_ADD_SUBR(Sgtk_notebook_get_nth_page);
++ rep_ADD_SUBR(Sgtk_notebook_page_num);
++ rep_ADD_SUBR(Sgtk_notebook_set_current_page);
++ rep_ADD_SUBR(Sgtk_notebook_next_page);
++ rep_ADD_SUBR(Sgtk_notebook_prev_page);
++ rep_ADD_SUBR(Sgtk_notebook_set_show_border);
++ rep_ADD_SUBR(Sgtk_notebook_get_show_border);
++ rep_ADD_SUBR(Sgtk_notebook_set_show_tabs);
++ rep_ADD_SUBR(Sgtk_notebook_get_show_tabs);
++ rep_ADD_SUBR(Sgtk_notebook_set_tab_pos);
++ rep_ADD_SUBR(Sgtk_notebook_get_tab_pos);
++ rep_ADD_SUBR(Sgtk_notebook_set_scrollable);
++ rep_ADD_SUBR(Sgtk_notebook_get_scrollable);
++ rep_ADD_SUBR(Sgtk_notebook_popup_enable);
++ rep_ADD_SUBR(Sgtk_notebook_popup_disable);
++ rep_ADD_SUBR(Sgtk_notebook_get_tab_label);
++ rep_ADD_SUBR(Sgtk_notebook_set_tab_label);
++ rep_ADD_SUBR(Sgtk_notebook_set_tab_label_text);
++ rep_ADD_SUBR(Sgtk_notebook_get_tab_label_text);
++ rep_ADD_SUBR(Sgtk_notebook_get_menu_label);
++ rep_ADD_SUBR(Sgtk_notebook_set_menu_label);
++ rep_ADD_SUBR(Sgtk_notebook_set_menu_label_text);
++ rep_ADD_SUBR(Sgtk_notebook_get_menu_label_text);
++ rep_ADD_SUBR(Sgtk_notebook_reorder_child);
++ rep_ADD_SUBR(Sgtk_editable_select_region);
++ rep_ADD_SUBR(Sgtk_editable_insert_text);
++ rep_ADD_SUBR(Sgtk_editable_delete_text);
++ rep_ADD_SUBR(Sgtk_editable_get_chars);
++ rep_ADD_SUBR(Sgtk_editable_cut_clipboard);
++ rep_ADD_SUBR(Sgtk_editable_copy_clipboard);
++ rep_ADD_SUBR(Sgtk_editable_paste_clipboard);
++ rep_ADD_SUBR(Sgtk_editable_delete_selection);
++ rep_ADD_SUBR(Sgtk_editable_set_position);
++ rep_ADD_SUBR(Sgtk_editable_get_position);
++ rep_ADD_SUBR(Sgtk_editable_set_editable);
++ rep_ADD_SUBR(Sgtk_editable_get_editable);
++ rep_ADD_SUBR(Sgtk_entry_new);
++ rep_ADD_SUBR(Sgtk_entry_set_visibility);
++ rep_ADD_SUBR(Sgtk_entry_get_visibility);
++ rep_ADD_SUBR(Sgtk_entry_set_has_frame);
++ rep_ADD_SUBR(Sgtk_entry_get_has_frame);
++ rep_ADD_SUBR(Sgtk_entry_set_max_length);
++ rep_ADD_SUBR(Sgtk_entry_get_max_length);
++ rep_ADD_SUBR(Sgtk_entry_set_activates_default);
++ rep_ADD_SUBR(Sgtk_entry_get_activates_default);
++ rep_ADD_SUBR(Sgtk_entry_set_width_chars);
++ rep_ADD_SUBR(Sgtk_entry_get_width_chars);
++ rep_ADD_SUBR(Sgtk_entry_set_text);
++ rep_ADD_SUBR(Sgtk_entry_get_text);
++ rep_ADD_SUBR(Sgtk_spin_button_new);
++ rep_ADD_SUBR(Sgtk_spin_button_new_with_range);
++ rep_ADD_SUBR(Sgtk_spin_button_set_adjustment);
++ rep_ADD_SUBR(Sgtk_spin_button_get_adjustment);
++ rep_ADD_SUBR(Sgtk_spin_button_set_digits);
++ rep_ADD_SUBR(Sgtk_spin_button_get_digits);
++ rep_ADD_SUBR(Sgtk_spin_button_set_increments);
++ rep_ADD_SUBR(Sgtk_spin_button_set_range);
++ rep_ADD_SUBR(Sgtk_spin_button_get_value);
++ rep_ADD_SUBR(Sgtk_spin_button_get_value_as_int);
++ rep_ADD_SUBR(Sgtk_spin_button_set_value);
++ rep_ADD_SUBR(Sgtk_spin_button_set_update_policy);
++ rep_ADD_SUBR(Sgtk_spin_button_get_update_policy);
++ rep_ADD_SUBR(Sgtk_spin_button_set_numeric);
++ rep_ADD_SUBR(Sgtk_spin_button_get_numeric);
++ rep_ADD_SUBR(Sgtk_spin_button_spin);
++ rep_ADD_SUBR(Sgtk_spin_button_set_wrap);
++ rep_ADD_SUBR(Sgtk_spin_button_get_wrap);
++ rep_ADD_SUBR(Sgtk_spin_button_set_snap_to_ticks);
++ rep_ADD_SUBR(Sgtk_spin_button_get_snap_to_ticks);
++ rep_ADD_SUBR(Sgtk_spin_button_update);
++ rep_ADD_SUBR(Sgtk_alignment_new);
++ rep_ADD_SUBR(Sgtk_alignment_set);
++ rep_ADD_SUBR(Sgtk_drawing_area_new);
++ rep_ADD_SUBR(Sgtk_curve_new);
++ rep_ADD_SUBR(Sgtk_curve_reset);
++ rep_ADD_SUBR(Sgtk_curve_set_gamma);
++ rep_ADD_SUBR(Sgtk_curve_set_range);
++ rep_ADD_SUBR(Sgtk_curve_set_curve_type);
++ rep_ADD_SUBR(Sgtk_preview_new);
++ rep_ADD_SUBR(Sgtk_preview_size);
++ rep_ADD_SUBR(Sgtk_preview_put);
++ rep_ADD_SUBR(Sgtk_preview_draw_row);
++ rep_ADD_SUBR(Sgtk_preview_set_expand);
++ rep_ADD_SUBR(Sgtk_preview_set_gamma);
++ rep_ADD_SUBR(Sgtk_preview_set_color_cube);
++ rep_ADD_SUBR(Sgtk_preview_set_install_cmap);
++ rep_ADD_SUBR(Sgtk_preview_set_reserved);
++ rep_ADD_SUBR(Sgtk_file_selection_new);
++ rep_ADD_SUBR(Sgtk_file_selection_set_filename);
++ rep_ADD_SUBR(Sgtk_file_selection_get_filename);
++ rep_ADD_SUBR(Sgtk_file_selection_complete);
++ rep_ADD_SUBR(Sgtk_file_selection_show_fileop_buttons);
++ rep_ADD_SUBR(Sgtk_file_selection_hide_fileop_buttons);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_new);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_get_font_name);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_set_font_name);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_get_preview_text);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_set_preview_text);
++ rep_ADD_SUBR(Sgtk_color_selection_dialog_new);
++ rep_ADD_SUBR(Sgtk_color_selection_new);
++ rep_ADD_SUBR(Sgtk_color_selection_set_has_opacity_control);
++ rep_ADD_SUBR(Sgtk_color_selection_get_has_opacity_control);
++ rep_ADD_SUBR(Sgtk_color_selection_get_has_palette);
++ rep_ADD_SUBR(Sgtk_color_selection_set_has_palette);
++ rep_ADD_SUBR(Sgtk_color_selection_set_current_color);
++ rep_ADD_SUBR(Sgtk_color_selection_set_current_alpha);
++ rep_ADD_SUBR(Sgtk_color_selection_get_current_alpha);
++ rep_ADD_SUBR(Sgtk_color_selection_is_adjusting);
++ rep_ADD_SUBR(Sgtk_color_selection_set_color_interp);
++ rep_ADD_SUBR(Sgtk_color_selection_get_color_interp);
++ rep_ADD_SUBR(Sgtk_range_set_update_policy);
++ rep_ADD_SUBR(Sgtk_range_get_update_policy);
++ rep_ADD_SUBR(Sgtk_range_set_adjustment);
++ rep_ADD_SUBR(Sgtk_range_get_adjustment);
++ rep_ADD_SUBR(Sgtk_range_set_inverted);
++ rep_ADD_SUBR(Sgtk_range_get_inverted);
++ rep_ADD_SUBR(Sgtk_range_set_increments);
++ rep_ADD_SUBR(Sgtk_range_set_range);
++ rep_ADD_SUBR(Sgtk_range_set_value);
++ rep_ADD_SUBR(Sgtk_range_get_value);
++ rep_ADD_SUBR(Sgtk_scale_set_digits);
++ rep_ADD_SUBR(Sgtk_scale_get_digits);
++ rep_ADD_SUBR(Sgtk_scale_set_draw_value);
++ rep_ADD_SUBR(Sgtk_scale_get_draw_value);
++ rep_ADD_SUBR(Sgtk_scale_set_value_pos);
++ rep_ADD_SUBR(Sgtk_scale_get_value_pos);
++ rep_ADD_SUBR(Sgtk_hscale_new);
++ rep_ADD_SUBR(Sgtk_hscale_new_with_range);
++ rep_ADD_SUBR(Sgtk_vscale_new);
++ rep_ADD_SUBR(Sgtk_vscale_new_with_range);
++ rep_ADD_SUBR(Sgtk_hscrollbar_new);
++ rep_ADD_SUBR(Sgtk_vscrollbar_new);
++ rep_ADD_SUBR(Sgtk_ruler_set_metric);
++ rep_ADD_SUBR(Sgtk_ruler_set_range);
++ rep_ADD_SUBR(Sgtk_ruler_draw_ticks);
++ rep_ADD_SUBR(Sgtk_ruler_draw_pos);
++ rep_ADD_SUBR(Sgtk_ruler_get_metric);
++ rep_ADD_SUBR(Sgtk_hruler_new);
++ rep_ADD_SUBR(Sgtk_vruler_new);
++ rep_ADD_SUBR(Sgtk_dialog_new);
++ rep_ADD_SUBR(Sgtk_dialog_add_button);
++ rep_ADD_SUBR(Sgtk_dialog_set_response_sensitive);
++ rep_ADD_SUBR(Sgtk_dialog_set_default_response);
++ rep_ADD_SUBR(Sgtk_dialog_set_has_separator);
++ rep_ADD_SUBR(Sgtk_dialog_get_has_separator);
++ rep_ADD_SUBR(Sgtk_dialog_response);
++ rep_ADD_SUBR(Sgtk_dialog_run);
++ rep_ADD_SUBR(Sgtk_input_dialog_new);
++ rep_ADD_SUBR(Sgtk_paned_add1);
++ rep_ADD_SUBR(Sgtk_paned_add2);
++ rep_ADD_SUBR(Sgtk_paned_pack1);
++ rep_ADD_SUBR(Sgtk_paned_pack2);
++ rep_ADD_SUBR(Sgtk_paned_get_position);
++ rep_ADD_SUBR(Sgtk_paned_set_position);
++ rep_ADD_SUBR(Sgtk_hpaned_new);
++ rep_ADD_SUBR(Sgtk_vpaned_new);
++ rep_ADD_SUBR(Sgtk_type_name);
++ rep_ADD_SUBR(Sgtk_type_from_name);
++ rep_ADD_SUBR(Sgtk_signal_set_class_function);
++ rep_ADD_SUBR(Sgtk_plug_construct);
++ rep_ADD_SUBR(Sgtk_plug_new);
++ rep_ADD_SUBR(Sgtk_socket_new);
++ rep_ADD_SUBR(Sgtk_socket_add_id);
++ rep_ADD_SUBR(Sgtk_socket_get_id);
++ rep_ADD_SUBR(Sgtk_tearoff_menu_item_new);
++ rep_ADD_SUBR(Sgtk_calendar_new);
++ rep_ADD_SUBR(Sgtk_calendar_select_month);
++ rep_ADD_SUBR(Sgtk_calendar_select_day);
++ rep_ADD_SUBR(Sgtk_calendar_mark_day);
++ rep_ADD_SUBR(Sgtk_calendar_unmark_day);
++ rep_ADD_SUBR(Sgtk_calendar_clear_marks);
++ rep_ADD_SUBR(Sgtk_calendar_display_options);
++ rep_ADD_SUBR(Sgtk_calendar_get_date);
++ rep_ADD_SUBR(Sgtk_calendar_freeze);
++ rep_ADD_SUBR(Sgtk_calendar_thaw);
++ rep_ADD_SUBR(Sgtk_icon_factory_new);
++ rep_ADD_SUBR(Sgtk_icon_factory_add);
++ rep_ADD_SUBR(Sgtk_icon_factory_lookup);
++ rep_ADD_SUBR(Sgtk_icon_factory_add_default);
++ rep_ADD_SUBR(Sgtk_icon_factory_remove_default);
++ rep_ADD_SUBR(Sgtk_icon_factory_lookup_default);
++ rep_ADD_SUBR(Sgtk_icon_size_register);
++ rep_ADD_SUBR(Sgtk_icon_size_register_alias);
++ rep_ADD_SUBR(Sgtk_icon_size_from_name);
++ rep_ADD_SUBR(Sgtk_icon_size_get_name);
++ rep_ADD_SUBR(Sgtk_icon_set_render_icon);
++ rep_ADD_SUBR(Sgtk_image_new);
++ rep_ADD_SUBR(Sgtk_image_new_from_file);
++ rep_ADD_SUBR(Sgtk_image_new_from_pixbuf);
++ rep_ADD_SUBR(Sgtk_image_new_from_stock);
++ rep_ADD_SUBR(Sgtk_image_new_from_icon_set);
++ rep_ADD_SUBR(Sgtk_image_set_from_file);
++ rep_ADD_SUBR(Sgtk_image_set_from_pixbuf);
++ rep_ADD_SUBR(Sgtk_image_set_from_stock);
++ rep_ADD_SUBR(Sgtk_image_set_from_icon_set);
++ rep_ADD_SUBR(Sgtk_image_get_pixbuf);
++ rep_ADD_SUBR(Sgtk_image_menu_item_new);
++ rep_ADD_SUBR(Sgtk_image_menu_item_new_with_label);
++ rep_ADD_SUBR(Sgtk_image_menu_item_new_with_mnemonic);
++ rep_ADD_SUBR(Sgtk_image_menu_item_new_from_stock);
++ rep_ADD_SUBR(Sgtk_image_menu_item_set_image);
++ rep_ADD_SUBR(Sgtk_image_menu_item_get_image);
++ rep_ADD_SUBR(Sgtk_invisible_new);
++ rep_ADD_SUBR(Sgtk_separator_menu_item_new);
++ rep_ADD_SUBR(Sgtk_text_mark_set_visible);
++ rep_ADD_SUBR(Sgtk_text_mark_get_visible);
++ rep_ADD_SUBR(Sgtk_text_mark_get_name);
++ rep_ADD_SUBR(Sgtk_text_mark_get_deleted);
++ rep_ADD_SUBR(Sgtk_text_mark_get_buffer);
++ rep_ADD_SUBR(Sgtk_text_mark_get_left_gravity);
++ rep_ADD_SUBR(Sgtk_text_tag_new);
++ rep_ADD_SUBR(Sgtk_text_tag_get_priority);
++ rep_ADD_SUBR(Sgtk_text_tag_set_priority);
++ rep_ADD_SUBR(Sgtk_text_tag_event);
++ rep_ADD_SUBR(Sgtk_text_tag_table_new);
++ rep_ADD_SUBR(Sgtk_text_tag_table_add);
++ rep_ADD_SUBR(Sgtk_text_tag_table_remove);
++ rep_ADD_SUBR(Sgtk_text_tag_table_lookup);
++ rep_ADD_SUBR(Sgtk_text_tag_table_get_size);
++ rep_ADD_SUBR(Sgtk_text_iter_new);
++ rep_ADD_SUBR(Sgtk_text_iter_get_offset);
++ rep_ADD_SUBR(Sgtk_text_iter_get_line);
++ rep_ADD_SUBR(Sgtk_text_iter_get_line_offset);
++ rep_ADD_SUBR(Sgtk_text_iter_get_line_index);
++ rep_ADD_SUBR(Sgtk_text_iter_get_visible_line_offset);
++ rep_ADD_SUBR(Sgtk_text_iter_get_visible_line_index);
++ rep_ADD_SUBR(Sgtk_text_iter_get_char);
++ rep_ADD_SUBR(Sgtk_text_iter_get_slice);
++ rep_ADD_SUBR(Sgtk_text_iter_get_text);
++ rep_ADD_SUBR(Sgtk_text_iter_get_visible_slice);
++ rep_ADD_SUBR(Sgtk_text_iter_get_visible_text);
++ rep_ADD_SUBR(Sgtk_text_iter_get_pixbuf);
++ rep_ADD_SUBR(Sgtk_text_iter_begins_tag);
++ rep_ADD_SUBR(Sgtk_text_iter_ends_tag);
++ rep_ADD_SUBR(Sgtk_text_iter_toggles_tag);
++ rep_ADD_SUBR(Sgtk_text_iter_has_tag);
++ rep_ADD_SUBR(Sgtk_text_iter_editable);
++ rep_ADD_SUBR(Sgtk_text_iter_can_insert);
++ rep_ADD_SUBR(Sgtk_text_iter_starts_word);
++ rep_ADD_SUBR(Sgtk_text_iter_ends_word);
++ rep_ADD_SUBR(Sgtk_text_iter_inside_word);
++ rep_ADD_SUBR(Sgtk_text_iter_starts_sentence);
++ rep_ADD_SUBR(Sgtk_text_iter_ends_sentence);
++ rep_ADD_SUBR(Sgtk_text_iter_inside_sentence);
++ rep_ADD_SUBR(Sgtk_text_iter_starts_line);
++ rep_ADD_SUBR(Sgtk_text_iter_ends_line);
++ rep_ADD_SUBR(Sgtk_text_iter_is_cursor_position);
++ rep_ADD_SUBR(Sgtk_text_iter_get_chars_in_line);
++ rep_ADD_SUBR(Sgtk_text_iter_get_bytes_in_line);
++ rep_ADD_SUBR(Sgtk_text_iter_is_end);
++ rep_ADD_SUBR(Sgtk_text_iter_is_start);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_char);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_char);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_chars);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_chars);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_line);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_line);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_lines);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_lines);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_word_end);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_word_start);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_word_ends);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_sentence_starts);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_sentence_end);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_sentence_start);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_sentence_ends);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_cursor_position);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_cursor_position);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_cursor_positions);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_cursor_positions);
++ rep_ADD_SUBR(Sgtk_text_iter_set_offset);
++ rep_ADD_SUBR(Sgtk_text_iter_set_line);
++ rep_ADD_SUBR(Sgtk_text_iter_set_line_offset);
++ rep_ADD_SUBR(Sgtk_text_iter_set_line_index);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_to_end);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_to_line_end);
++ rep_ADD_SUBR(Sgtk_text_iter_set_visible_line_offset);
++ rep_ADD_SUBR(Sgtk_text_iter_set_visible_line_index);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_to_tag_toggle);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_to_tag_toggle);
++ rep_ADD_SUBR(Sgtk_text_iter_forward_search);
++ rep_ADD_SUBR(Sgtk_text_iter_backward_search);
++ rep_ADD_SUBR(Sgtk_text_iter_equal);
++ rep_ADD_SUBR(Sgtk_text_iter_compare);
++ rep_ADD_SUBR(Sgtk_text_iter_in_range);
++ rep_ADD_SUBR(Sgtk_text_iter_order);
++ rep_ADD_SUBR(Sgtk_text_buffer_new);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_line_count);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_char_count);
++ rep_ADD_SUBR(Sgtk_text_buffer_set_text);
++ rep_ADD_SUBR(Sgtk_text_buffer_insert);
++ rep_ADD_SUBR(Sgtk_text_buffer_insert_at_cursor);
++ rep_ADD_SUBR(Sgtk_text_buffer_insert_interactive);
++ rep_ADD_SUBR(Sgtk_text_buffer_insert_interactive_at_cursor);
++ rep_ADD_SUBR(Sgtk_text_buffer_insert_range);
++ rep_ADD_SUBR(Sgtk_text_buffer_insert_range_interactive);
++ rep_ADD_SUBR(Sgtk_text_buffer_delete);
++ rep_ADD_SUBR(Sgtk_text_buffer_delete_interactive);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_text);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_slice);
++ rep_ADD_SUBR(Sgtk_text_buffer_insert_pixbuf);
++ rep_ADD_SUBR(Sgtk_text_buffer_create_mark);
++ rep_ADD_SUBR(Sgtk_text_buffer_move_mark);
++ rep_ADD_SUBR(Sgtk_text_buffer_delete_mark);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_mark);
++ rep_ADD_SUBR(Sgtk_text_buffer_move_mark_by_name);
++ rep_ADD_SUBR(Sgtk_text_buffer_delete_mark_by_name);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_insert);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_selection_bound);
++ rep_ADD_SUBR(Sgtk_text_buffer_place_cursor);
++ rep_ADD_SUBR(Sgtk_text_buffer_apply_tag);
++ rep_ADD_SUBR(Sgtk_text_buffer_remove_tag);
++ rep_ADD_SUBR(Sgtk_text_buffer_apply_tag_by_name);
++ rep_ADD_SUBR(Sgtk_text_buffer_remove_tag_by_name);
++ rep_ADD_SUBR(Sgtk_text_buffer_remove_all_tags);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_iter_at_line_offset);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_iter_at_line_index);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_iter_at_offset);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_iter_at_line);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_start_iter);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_end_iter);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_bounds);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_iter_at_mark);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_modified);
++ rep_ADD_SUBR(Sgtk_text_buffer_set_modified);
++ rep_ADD_SUBR(Sgtk_text_buffer_get_selection_bounds);
++ rep_ADD_SUBR(Sgtk_text_buffer_delete_selection);
++ rep_ADD_SUBR(Sgtk_text_buffer_begin_user_action);
++ rep_ADD_SUBR(Sgtk_text_buffer_end_user_action);
++ rep_ADD_SUBR(Sgtk_text_view_new);
++ rep_ADD_SUBR(Sgtk_text_view_new_with_buffer);
++ rep_ADD_SUBR(Sgtk_text_view_set_buffer);
++ rep_ADD_SUBR(Sgtk_text_view_get_buffer);
++ rep_ADD_SUBR(Sgtk_text_view_scroll_to_iter);
++ rep_ADD_SUBR(Sgtk_text_view_scroll_to_mark);
++ rep_ADD_SUBR(Sgtk_text_view_scroll_mark_onscreen);
++ rep_ADD_SUBR(Sgtk_text_view_move_mark_onscreen);
++ rep_ADD_SUBR(Sgtk_text_view_place_cursor_onscreen);
++ rep_ADD_SUBR(Sgtk_text_view_set_cursor_visible);
++ rep_ADD_SUBR(Sgtk_text_view_get_cursor_visible);
++ rep_ADD_SUBR(Sgtk_text_view_get_iter_at_location);
++ rep_ADD_SUBR(Sgtk_text_view_get_window);
++ rep_ADD_SUBR(Sgtk_text_view_get_window_type);
++ rep_ADD_SUBR(Sgtk_text_view_set_border_window_size);
++ rep_ADD_SUBR(Sgtk_text_view_get_border_window_size);
++ rep_ADD_SUBR(Sgtk_text_view_forward_display_line);
++ rep_ADD_SUBR(Sgtk_text_view_backward_display_line);
++ rep_ADD_SUBR(Sgtk_text_view_forward_display_line_end);
++ rep_ADD_SUBR(Sgtk_text_view_backward_display_line_start);
++ rep_ADD_SUBR(Sgtk_text_view_starts_display_line);
++ rep_ADD_SUBR(Sgtk_text_view_move_visually);
++ rep_ADD_SUBR(Sgtk_text_view_add_child_in_window);
++ rep_ADD_SUBR(Sgtk_text_view_move_child);
++ rep_ADD_SUBR(Sgtk_text_view_set_wrap_mode);
++ rep_ADD_SUBR(Sgtk_text_view_get_wrap_mode);
++ rep_ADD_SUBR(Sgtk_text_view_set_editable);
++ rep_ADD_SUBR(Sgtk_text_view_get_editable);
++ rep_ADD_SUBR(Sgtk_text_view_set_pixels_above_lines);
++ rep_ADD_SUBR(Sgtk_text_view_get_pixels_above_lines);
++ rep_ADD_SUBR(Sgtk_text_view_set_pixels_below_lines);
++ rep_ADD_SUBR(Sgtk_text_view_get_pixels_below_lines);
++ rep_ADD_SUBR(Sgtk_text_view_set_pixels_inside_wrap);
++ rep_ADD_SUBR(Sgtk_text_view_get_pixels_inside_wrap);
++ rep_ADD_SUBR(Sgtk_text_view_set_justification);
++ rep_ADD_SUBR(Sgtk_text_view_get_justification);
++ rep_ADD_SUBR(Sgtk_text_view_set_left_margin);
++ rep_ADD_SUBR(Sgtk_text_view_get_left_margin);
++ rep_ADD_SUBR(Sgtk_text_view_set_right_margin);
++ rep_ADD_SUBR(Sgtk_text_view_get_right_margin);
++ rep_ADD_SUBR(Sgtk_text_view_set_indent);
++ rep_ADD_SUBR(Sgtk_text_view_get_indent);
++ rep_ADD_SUBR(Sgtk_icon_set_p);
++ rep_ADD_SUBR(Sgtk_text_iter_p);
++ rep_ADD_SUBR(Sgtk_widget_style);
++ rep_ADD_SUBR(Sgtk_widget_window);
++ rep_ADD_SUBR(Sgtk_widget_parent);
++ rep_ADD_SUBR(Sgtk_widget_allocation);
++ rep_ADD_SUBR(Sgtk_widget_p);
++ rep_ADD_SUBR(Sgtk_accel_group_p);
++ rep_ADD_SUBR(Sgtk_style_p);
++ rep_ADD_SUBR(Sgtk_rc_style_p);
++ rep_ADD_SUBR(Sgtk_object_p);
++ rep_ADD_SUBR(Sgtk_adjustment_p);
++ rep_ADD_SUBR(Sgtk_container_p);
++ rep_ADD_SUBR(Sgtk_fixed_p);
++ rep_ADD_SUBR(Sgtk_tree_item_p);
++ rep_ADD_SUBR(Sgtk_tree_p);
++ rep_ADD_SUBR(Sgtk_clist_rows);
++ rep_ADD_SUBR(Sgtk_clist_columns);
++ rep_ADD_SUBR(Sgtk_clist_p);
++ rep_ADD_SUBR(Sgtk_bin_p);
++ rep_ADD_SUBR(Sgtk_event_box_p);
++ rep_ADD_SUBR(Sgtk_window_p);
++ rep_ADD_SUBR(Sgtk_handle_box_p);
++ rep_ADD_SUBR(Sgtk_box_p);
++ rep_ADD_SUBR(Sgtk_button_box_p);
++ rep_ADD_SUBR(Sgtk_hbutton_box_p);
++ rep_ADD_SUBR(Sgtk_vbutton_box_p);
++ rep_ADD_SUBR(Sgtk_toolbar_p);
++ rep_ADD_SUBR(Sgtk_table_p);
++ rep_ADD_SUBR(Sgtk_button_in_button);
++ rep_ADD_SUBR(Sgtk_button_button_down);
++ rep_ADD_SUBR(Sgtk_button_p);
++ rep_ADD_SUBR(Sgtk_toggle_button_p);
++ rep_ADD_SUBR(Sgtk_check_button_p);
++ rep_ADD_SUBR(Sgtk_radio_button_p);
++ rep_ADD_SUBR(Sgtk_misc_p);
++ rep_ADD_SUBR(Sgtk_arrow_p);
++ rep_ADD_SUBR(Sgtk_label_p);
++ rep_ADD_SUBR(Sgtk_layout_p);
++ rep_ADD_SUBR(Sgtk_tips_query_p);
++ rep_ADD_SUBR(Sgtk_vbox_p);
++ rep_ADD_SUBR(Sgtk_hbox_p);
++ rep_ADD_SUBR(Sgtk_item_p);
++ rep_ADD_SUBR(Sgtk_combo_entry);
++ rep_ADD_SUBR(Sgtk_combo_button);
++ rep_ADD_SUBR(Sgtk_combo_popup);
++ rep_ADD_SUBR(Sgtk_combo_popwin);
++ rep_ADD_SUBR(Sgtk_combo_list);
++ rep_ADD_SUBR(Sgtk_combo_p);
++ rep_ADD_SUBR(Sgtk_statusbar_p);
++ rep_ADD_SUBR(Sgtk_gamma_curve_table);
++ rep_ADD_SUBR(Sgtk_gamma_curve_curve);
++ rep_ADD_SUBR(Sgtk_gamma_curve_gamma);
++ rep_ADD_SUBR(Sgtk_gamma_curve_gamma_dialog);
++ rep_ADD_SUBR(Sgtk_gamma_curve_gamma_text);
++ rep_ADD_SUBR(Sgtk_gamma_curve_p);
++ rep_ADD_SUBR(Sgtk_separator_p);
++ rep_ADD_SUBR(Sgtk_hseparator_p);
++ rep_ADD_SUBR(Sgtk_vseparator_p);
++ rep_ADD_SUBR(Sgtk_frame_p);
++ rep_ADD_SUBR(Sgtk_aspect_frame_p);
++ rep_ADD_SUBR(Sgtk_progress_p);
++ rep_ADD_SUBR(Sgtk_progress_bar_p);
++ rep_ADD_SUBR(Sgtk_tooltips_p);
++ rep_ADD_SUBR(Sgtk_menu_shell_p);
++ rep_ADD_SUBR(Sgtk_menu_bar_p);
++ rep_ADD_SUBR(Sgtk_menu_p);
++ rep_ADD_SUBR(Sgtk_menu_item_p);
++ rep_ADD_SUBR(Sgtk_check_menu_item_active);
++ rep_ADD_SUBR(Sgtk_check_menu_item_p);
++ rep_ADD_SUBR(Sgtk_radio_menu_item_p);
++ rep_ADD_SUBR(Sgtk_option_menu_p);
++ rep_ADD_SUBR(Sgtk_pixmap_p);
++ rep_ADD_SUBR(Sgtk_viewport_p);
++ rep_ADD_SUBR(Sgtk_scrolled_window_p);
++ rep_ADD_SUBR(Sgtk_list_item_p);
++ rep_ADD_SUBR(Sgtk_list_p);
++ rep_ADD_SUBR(Sgtk_notebook_tab_pos);
++ rep_ADD_SUBR(Sgtk_notebook_p);
++ rep_ADD_SUBR(Sgtk_editable_p);
++ rep_ADD_SUBR(Sgtk_entry_p);
++ rep_ADD_SUBR(Sgtk_spin_button_p);
++ rep_ADD_SUBR(Sgtk_alignment_p);
++ rep_ADD_SUBR(Sgtk_drawing_area_p);
++ rep_ADD_SUBR(Sgtk_curve_p);
++ rep_ADD_SUBR(Sgtk_preview_p);
++ rep_ADD_SUBR(Sgtk_file_selection_dir_list);
++ rep_ADD_SUBR(Sgtk_file_selection_file_list);
++ rep_ADD_SUBR(Sgtk_file_selection_selection_entry);
++ rep_ADD_SUBR(Sgtk_file_selection_selection_text);
++ rep_ADD_SUBR(Sgtk_file_selection_main_vbox);
++ rep_ADD_SUBR(Sgtk_file_selection_ok_button);
++ rep_ADD_SUBR(Sgtk_file_selection_cancel_button);
++ rep_ADD_SUBR(Sgtk_file_selection_help_button);
++ rep_ADD_SUBR(Sgtk_file_selection_action_area);
++ rep_ADD_SUBR(Sgtk_file_selection_p);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_main_vbox);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_action_area);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_ok_button);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_apply_button);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_cancel_button);
++ rep_ADD_SUBR(Sgtk_font_selection_dialog_p);
++ rep_ADD_SUBR(Sgtk_color_selection_dialog_colorsel);
++ rep_ADD_SUBR(Sgtk_color_selection_dialog_ok_button);
++ rep_ADD_SUBR(Sgtk_color_selection_dialog_cancel_button);
++ rep_ADD_SUBR(Sgtk_color_selection_dialog_help_button);
++ rep_ADD_SUBR(Sgtk_color_selection_dialog_p);
++ rep_ADD_SUBR(Sgtk_color_selection_p);
++ rep_ADD_SUBR(Sgtk_range_p);
++ rep_ADD_SUBR(Sgtk_scale_p);
++ rep_ADD_SUBR(Sgtk_hscale_p);
++ rep_ADD_SUBR(Sgtk_vscale_p);
++ rep_ADD_SUBR(Sgtk_scrollbar_p);
++ rep_ADD_SUBR(Sgtk_hscrollbar_p);
++ rep_ADD_SUBR(Sgtk_vscrollbar_p);
++ rep_ADD_SUBR(Sgtk_ruler_p);
++ rep_ADD_SUBR(Sgtk_hruler_p);
++ rep_ADD_SUBR(Sgtk_vruler_p);
++ rep_ADD_SUBR(Sgtk_dialog_vbox);
++ rep_ADD_SUBR(Sgtk_dialog_action_area);
++ rep_ADD_SUBR(Sgtk_dialog_p);
++ rep_ADD_SUBR(Sgtk_input_dialog_close_button);
++ rep_ADD_SUBR(Sgtk_input_dialog_save_button);
++ rep_ADD_SUBR(Sgtk_input_dialog_p);
++ rep_ADD_SUBR(Sgtk_paned_p);
++ rep_ADD_SUBR(Sgtk_hpaned_p);
++ rep_ADD_SUBR(Sgtk_vpaned_p);
++ rep_ADD_SUBR(Sgtk_plug_socket_window);
++ rep_ADD_SUBR(Sgtk_plug_p);
++ rep_ADD_SUBR(Sgtk_socket_plug_window);
++ rep_ADD_SUBR(Sgtk_socket_p);
++ rep_ADD_SUBR(Sgtk_tearoff_menu_item_torn_off);
++ rep_ADD_SUBR(Sgtk_tearoff_menu_item_p);
++ rep_ADD_SUBR(Sgtk_calendar_p);
++ rep_ADD_SUBR(Sgtk_icon_factory_p);
++ rep_ADD_SUBR(Sgtk_image_p);
++ rep_ADD_SUBR(Sgtk_image_menu_item_p);
++ rep_ADD_SUBR(Sgtk_invisible_p);
++ rep_ADD_SUBR(Sgtk_separator_menu_item_p);
++ rep_ADD_SUBR(Sgtk_text_buffer_p);
++ rep_ADD_SUBR(Sgtk_text_mark_p);
++ rep_ADD_SUBR(Sgtk_text_tag_p);
++ rep_ADD_SUBR(Sgtk_text_tag_table_p);
++ rep_ADD_SUBR(Sgtk_text_view_p);
++ }
++}
Added: trunk/dports/x11/rep-gtk/files/patch-rep-gtk.h
===================================================================
--- trunk/dports/x11/rep-gtk/files/patch-rep-gtk.h (rev 0)
+++ trunk/dports/x11/rep-gtk/files/patch-rep-gtk.h 2006-09-14 05:22:32 UTC (rev 19523)
@@ -0,0 +1,23 @@
+--- ../rep-gtk-0.18.orig/rep-gtk.h 2006-08-07 09:16:07.000000000 -0600
++++ rep-gtk.h 2006-08-07 09:16:23.000000000 -0600
+@@ -290,12 +290,15 @@
+ repv position);
+
+ GtkWidget*
+-gtk_radio_menu_item_new_with_label_from_widget (GtkRadioMenuItem *group,
+- gchar *label);
++wrapper_gtk_radio_menu_item_new_with_label_from_widget (
++ GtkRadioMenuItem *group,
++ const gchar *label);
+ GtkWidget*
+-gtk_radio_menu_item_new_with_mnemonic_from_widget (GtkRadioMenuItem *group,
+- gchar *label);
+-GtkWidget* gtk_radio_menu_item_new_from_widget (GtkRadioMenuItem *group);
++wrapper_gtk_radio_menu_item_new_with_mnemonic_from_widget (
++ GtkRadioMenuItem *group,
++ const gchar *label);
++GtkWidget*
++wrapper_gtk_radio_menu_item_new_from_widget (GtkRadioMenuItem *group);
+ GtkWidget* gtk_pixmap_new_interp (char *file, GtkWidget *intended_parent);
+
+ #ifndef HAVE_GDK_COLOR_COPY
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.macosforge.org/pipermail/macports-changes/attachments/20060913/512faf8a/attachment.html
More information about the macports-changes
mailing list